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


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


WORST_CASE(Omega(n^1), O(n^2))
proof of /export/starexec/sandbox/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), 46 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) InliningProof [UPPER BOUND(ID), 282 ms]
    (18) CpxRNTS
    (19) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (20) CpxRNTS
    (21) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
    (22) CpxRNTS
    (23) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (24) CpxRNTS
    (25) IntTrsBoundProof [UPPER BOUND(ID), 97 ms]
    (26) CpxRNTS
    (27) IntTrsBoundProof [UPPER BOUND(ID), 6 ms]
    (28) CpxRNTS
    (29) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (30) CpxRNTS
    (31) IntTrsBoundProof [UPPER BOUND(ID), 210 ms]
    (32) CpxRNTS
    (33) IntTrsBoundProof [UPPER BOUND(ID), 65 ms]
    (34) CpxRNTS
    (35) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (36) CpxRNTS
    (37) IntTrsBoundProof [UPPER BOUND(ID), 77 ms]
    (38) CpxRNTS
    (39) IntTrsBoundProof [UPPER BOUND(ID), 0 ms]
    (40) CpxRNTS
    (41) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (42) CpxRNTS
    (43) IntTrsBoundProof [UPPER BOUND(ID), 166 ms]
    (44) CpxRNTS
    (45) IntTrsBoundProof [UPPER BOUND(ID), 52 ms]
    (46) CpxRNTS
    (47) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (48) CpxRNTS
    (49) IntTrsBoundProof [UPPER BOUND(ID), 64 ms]
    (50) CpxRNTS
    (51) IntTrsBoundProof [UPPER BOUND(ID), 31 ms]
    (52) CpxRNTS
    (53) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (54) CpxRNTS
    (55) IntTrsBoundProof [UPPER BOUND(ID), 254 ms]
    (56) CpxRNTS
    (57) IntTrsBoundProof [UPPER BOUND(ID), 7 ms]
    (58) CpxRNTS
    (59) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (60) CpxRNTS
    (61) IntTrsBoundProof [UPPER BOUND(ID), 1419 ms]
    (62) CpxRNTS
    (63) IntTrsBoundProof [UPPER BOUND(ID), 800 ms]
    (64) CpxRNTS
    (65) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (66) CpxRNTS
    (67) IntTrsBoundProof [UPPER BOUND(ID), 558 ms]
    (68) CpxRNTS
    (69) IntTrsBoundProof [UPPER BOUND(ID), 0 ms]
    (70) CpxRNTS
    (71) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (72) CpxRNTS
    (73) IntTrsBoundProof [UPPER BOUND(ID), 526 ms]
    (74) CpxRNTS
    (75) IntTrsBoundProof [UPPER BOUND(ID), 26 ms]
    (76) CpxRNTS
    (77) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (78) CpxRNTS
    (79) IntTrsBoundProof [UPPER BOUND(ID), 137 ms]
    (80) CpxRNTS
    (81) IntTrsBoundProof [UPPER BOUND(ID), 0 ms]
    (82) CpxRNTS
    (83) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (84) CpxRNTS
    (85) IntTrsBoundProof [UPPER BOUND(ID), 494 ms]
    (86) CpxRNTS
    (87) IntTrsBoundProof [UPPER BOUND(ID), 5 ms]
    (88) CpxRNTS
    (89) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (90) CpxRNTS
    (91) IntTrsBoundProof [UPPER BOUND(ID), 198 ms]
    (92) CpxRNTS
    (93) IntTrsBoundProof [UPPER BOUND(ID), 0 ms]
    (94) CpxRNTS
    (95) FinalProof [FINISHED, 0 ms]
    (96) BOUNDS(1, n^2)
(97) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms]
(98) TRS for Loop Detection
    (99) DecreasingLoopProof [LOWER BOUND(ID), 7 ms]
    (100) BEST
        (101) proven lower bound
            (102) LowerBoundPropagationProof [FINISHED, 0 ms]
            (103) BOUNDS(n^1, INF)
        (104) TRS for Loop Detection


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

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

   f(n__f(n__a)) -> f(n__g(n__f(n__a)))
   f(X) -> n__f(X)
   a -> n__a
   g(X) -> n__g(X)
   activate(n__f(X)) -> f(X)
   activate(n__a) -> a
   activate(n__g(X)) -> g(activate(X))
   activate(X) -> X

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(n__f(x_1)) -> n__f(encArg(x_1))
   encArg(n__a) -> n__a
   encArg(n__g(x_1)) -> n__g(encArg(x_1))
   encArg(cons_f(x_1)) -> f(encArg(x_1))
   encArg(cons_a) -> a
   encArg(cons_g(x_1)) -> g(encArg(x_1))
   encArg(cons_activate(x_1)) -> activate(encArg(x_1))
   encode_f(x_1) -> f(encArg(x_1))
   encode_n__f(x_1) -> n__f(encArg(x_1))
   encode_n__a -> n__a
   encode_n__g(x_1) -> n__g(encArg(x_1))
   encode_a -> a
   encode_g(x_1) -> g(encArg(x_1))
   encode_activate(x_1) -> activate(encArg(x_1))


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

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

   f(n__f(n__a)) -> f(n__g(n__f(n__a)))
   f(X) -> n__f(X)
   a -> n__a
   g(X) -> n__g(X)
   activate(n__f(X)) -> f(X)
   activate(n__a) -> a
   activate(n__g(X)) -> g(activate(X))
   activate(X) -> X

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

   encArg(n__f(x_1)) -> n__f(encArg(x_1))
   encArg(n__a) -> n__a
   encArg(n__g(x_1)) -> n__g(encArg(x_1))
   encArg(cons_f(x_1)) -> f(encArg(x_1))
   encArg(cons_a) -> a
   encArg(cons_g(x_1)) -> g(encArg(x_1))
   encArg(cons_activate(x_1)) -> activate(encArg(x_1))
   encode_f(x_1) -> f(encArg(x_1))
   encode_n__f(x_1) -> n__f(encArg(x_1))
   encode_n__a -> n__a
   encode_n__g(x_1) -> n__g(encArg(x_1))
   encode_a -> a
   encode_g(x_1) -> g(encArg(x_1))
   encode_activate(x_1) -> activate(encArg(x_1))

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:

   f(n__f(n__a)) -> f(n__g(n__f(n__a)))
   f(X) -> n__f(X)
   a -> n__a
   g(X) -> n__g(X)
   activate(n__f(X)) -> f(X)
   activate(n__a) -> a
   activate(n__g(X)) -> g(activate(X))
   activate(X) -> X

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

   encArg(n__f(x_1)) -> n__f(encArg(x_1))
   encArg(n__a) -> n__a
   encArg(n__g(x_1)) -> n__g(encArg(x_1))
   encArg(cons_f(x_1)) -> f(encArg(x_1))
   encArg(cons_a) -> a
   encArg(cons_g(x_1)) -> g(encArg(x_1))
   encArg(cons_activate(x_1)) -> activate(encArg(x_1))
   encode_f(x_1) -> f(encArg(x_1))
   encode_n__f(x_1) -> n__f(encArg(x_1))
   encode_n__a -> n__a
   encode_n__g(x_1) -> n__g(encArg(x_1))
   encode_a -> a
   encode_g(x_1) -> g(encArg(x_1))
   encode_activate(x_1) -> activate(encArg(x_1))

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:

   f(n__f(n__a)) -> f(n__g(n__f(n__a)))
   f(X) -> n__f(X)
   a -> n__a
   g(X) -> n__g(X)
   activate(n__f(X)) -> f(X)
   activate(n__a) -> a
   activate(n__g(X)) -> g(activate(X))
   activate(X) -> X

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

   encArg(n__f(x_1)) -> n__f(encArg(x_1))
   encArg(n__a) -> n__a
   encArg(n__g(x_1)) -> n__g(encArg(x_1))
   encArg(cons_f(x_1)) -> f(encArg(x_1))
   encArg(cons_a) -> a
   encArg(cons_g(x_1)) -> g(encArg(x_1))
   encArg(cons_activate(x_1)) -> activate(encArg(x_1))
   encode_f(x_1) -> f(encArg(x_1))
   encode_n__f(x_1) -> n__f(encArg(x_1))
   encode_n__a -> n__a
   encode_n__g(x_1) -> n__g(encArg(x_1))
   encode_a -> a
   encode_g(x_1) -> g(encArg(x_1))
   encode_activate(x_1) -> activate(encArg(x_1))

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:

   f(n__f(n__a)) -> f(n__g(n__f(n__a))) [1]
   f(X) -> n__f(X) [1]
   a -> n__a [1]
   g(X) -> n__g(X) [1]
   activate(n__f(X)) -> f(X) [1]
   activate(n__a) -> a [1]
   activate(n__g(X)) -> g(activate(X)) [1]
   activate(X) -> X [1]
   encArg(n__f(x_1)) -> n__f(encArg(x_1)) [0]
   encArg(n__a) -> n__a [0]
   encArg(n__g(x_1)) -> n__g(encArg(x_1)) [0]
   encArg(cons_f(x_1)) -> f(encArg(x_1)) [0]
   encArg(cons_a) -> a [0]
   encArg(cons_g(x_1)) -> g(encArg(x_1)) [0]
   encArg(cons_activate(x_1)) -> activate(encArg(x_1)) [0]
   encode_f(x_1) -> f(encArg(x_1)) [0]
   encode_n__f(x_1) -> n__f(encArg(x_1)) [0]
   encode_n__a -> n__a [0]
   encode_n__g(x_1) -> n__g(encArg(x_1)) [0]
   encode_a -> a [0]
   encode_g(x_1) -> g(encArg(x_1)) [0]
   encode_activate(x_1) -> activate(encArg(x_1)) [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:

   f(n__f(n__a)) -> f(n__g(n__f(n__a))) [1]
   f(X) -> n__f(X) [1]
   a -> n__a [1]
   g(X) -> n__g(X) [1]
   activate(n__f(X)) -> f(X) [1]
   activate(n__a) -> a [1]
   activate(n__g(X)) -> g(activate(X)) [1]
   activate(X) -> X [1]
   encArg(n__f(x_1)) -> n__f(encArg(x_1)) [0]
   encArg(n__a) -> n__a [0]
   encArg(n__g(x_1)) -> n__g(encArg(x_1)) [0]
   encArg(cons_f(x_1)) -> f(encArg(x_1)) [0]
   encArg(cons_a) -> a [0]
   encArg(cons_g(x_1)) -> g(encArg(x_1)) [0]
   encArg(cons_activate(x_1)) -> activate(encArg(x_1)) [0]
   encode_f(x_1) -> f(encArg(x_1)) [0]
   encode_n__f(x_1) -> n__f(encArg(x_1)) [0]
   encode_n__a -> n__a [0]
   encode_n__g(x_1) -> n__g(encArg(x_1)) [0]
   encode_a -> a [0]
   encode_g(x_1) -> g(encArg(x_1)) [0]
   encode_activate(x_1) -> activate(encArg(x_1)) [0]

The TRS has the following type information:
f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
n__f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
n__a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
n__g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
activate :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
encArg :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
cons_f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
cons_a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
cons_g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
cons_activate :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
encode_f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
encode_n__f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
encode_n__a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
encode_n__g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
encode_a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
encode_g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate
encode_activate :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate

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:

   activate_1
   a
   f_1
   g_1
   encArg_1
   encode_f_1
   encode_n__f_1
   encode_n__a
   encode_n__g_1
   encode_a
   encode_g_1
   encode_activate_1

Due to the following rules being added:

   encArg(v0) -> null_encArg [0]
   encode_f(v0) -> null_encode_f [0]
   encode_n__f(v0) -> null_encode_n__f [0]
   encode_n__a -> null_encode_n__a [0]
   encode_n__g(v0) -> null_encode_n__g [0]
   encode_a -> null_encode_a [0]
   encode_g(v0) -> null_encode_g [0]
   encode_activate(v0) -> null_encode_activate [0]

And the following fresh constants:    null_encArg, null_encode_f, null_encode_n__f, null_encode_n__a, null_encode_n__g, null_encode_a, null_encode_g, null_encode_activate

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

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

   f(n__f(n__a)) -> f(n__g(n__f(n__a))) [1]
   f(X) -> n__f(X) [1]
   a -> n__a [1]
   g(X) -> n__g(X) [1]
   activate(n__f(X)) -> f(X) [1]
   activate(n__a) -> a [1]
   activate(n__g(X)) -> g(activate(X)) [1]
   activate(X) -> X [1]
   encArg(n__f(x_1)) -> n__f(encArg(x_1)) [0]
   encArg(n__a) -> n__a [0]
   encArg(n__g(x_1)) -> n__g(encArg(x_1)) [0]
   encArg(cons_f(x_1)) -> f(encArg(x_1)) [0]
   encArg(cons_a) -> a [0]
   encArg(cons_g(x_1)) -> g(encArg(x_1)) [0]
   encArg(cons_activate(x_1)) -> activate(encArg(x_1)) [0]
   encode_f(x_1) -> f(encArg(x_1)) [0]
   encode_n__f(x_1) -> n__f(encArg(x_1)) [0]
   encode_n__a -> n__a [0]
   encode_n__g(x_1) -> n__g(encArg(x_1)) [0]
   encode_a -> a [0]
   encode_g(x_1) -> g(encArg(x_1)) [0]
   encode_activate(x_1) -> activate(encArg(x_1)) [0]
   encArg(v0) -> null_encArg [0]
   encode_f(v0) -> null_encode_f [0]
   encode_n__f(v0) -> null_encode_n__f [0]
   encode_n__a -> null_encode_n__a [0]
   encode_n__g(v0) -> null_encode_n__g [0]
   encode_a -> null_encode_a [0]
   encode_g(v0) -> null_encode_g [0]
   encode_activate(v0) -> null_encode_activate [0]

The TRS has the following type information:
f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
n__f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
n__a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
n__g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
activate :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encArg :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
cons_f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
cons_a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
cons_g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
cons_activate :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encode_f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encode_n__f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encode_n__a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encode_n__g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encode_a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encode_g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encode_activate :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encArg :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encode_f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encode_n__f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encode_n__a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encode_n__g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encode_a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encode_g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encode_activate :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate

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:

   f(n__f(n__a)) -> f(n__g(n__f(n__a))) [1]
   f(X) -> n__f(X) [1]
   a -> n__a [1]
   g(X) -> n__g(X) [1]
   activate(n__f(X)) -> f(X) [1]
   activate(n__a) -> a [1]
   activate(n__g(n__f(X'))) -> g(f(X')) [2]
   activate(n__g(n__a)) -> g(a) [2]
   activate(n__g(n__g(X''))) -> g(g(activate(X''))) [2]
   activate(n__g(X)) -> g(X) [2]
   activate(X) -> X [1]
   encArg(n__f(x_1)) -> n__f(encArg(x_1)) [0]
   encArg(n__a) -> n__a [0]
   encArg(n__g(x_1)) -> n__g(encArg(x_1)) [0]
   encArg(cons_f(n__f(x_1'))) -> f(n__f(encArg(x_1'))) [0]
   encArg(cons_f(n__a)) -> f(n__a) [0]
   encArg(cons_f(n__g(x_1''))) -> f(n__g(encArg(x_1''))) [0]
   encArg(cons_f(cons_f(x_11))) -> f(f(encArg(x_11))) [0]
   encArg(cons_f(cons_a)) -> f(a) [0]
   encArg(cons_f(cons_g(x_12))) -> f(g(encArg(x_12))) [0]
   encArg(cons_f(cons_activate(x_13))) -> f(activate(encArg(x_13))) [0]
   encArg(cons_f(x_1)) -> f(null_encArg) [0]
   encArg(cons_a) -> a [0]
   encArg(cons_g(n__f(x_14))) -> g(n__f(encArg(x_14))) [0]
   encArg(cons_g(n__a)) -> g(n__a) [0]
   encArg(cons_g(n__g(x_15))) -> g(n__g(encArg(x_15))) [0]
   encArg(cons_g(cons_f(x_16))) -> g(f(encArg(x_16))) [0]
   encArg(cons_g(cons_a)) -> g(a) [0]
   encArg(cons_g(cons_g(x_17))) -> g(g(encArg(x_17))) [0]
   encArg(cons_g(cons_activate(x_18))) -> g(activate(encArg(x_18))) [0]
   encArg(cons_g(x_1)) -> g(null_encArg) [0]
   encArg(cons_activate(n__f(x_19))) -> activate(n__f(encArg(x_19))) [0]
   encArg(cons_activate(n__a)) -> activate(n__a) [0]
   encArg(cons_activate(n__g(x_110))) -> activate(n__g(encArg(x_110))) [0]
   encArg(cons_activate(cons_f(x_111))) -> activate(f(encArg(x_111))) [0]
   encArg(cons_activate(cons_a)) -> activate(a) [0]
   encArg(cons_activate(cons_g(x_112))) -> activate(g(encArg(x_112))) [0]
   encArg(cons_activate(cons_activate(x_113))) -> activate(activate(encArg(x_113))) [0]
   encArg(cons_activate(x_1)) -> activate(null_encArg) [0]
   encode_f(n__f(x_114)) -> f(n__f(encArg(x_114))) [0]
   encode_f(n__a) -> f(n__a) [0]
   encode_f(n__g(x_115)) -> f(n__g(encArg(x_115))) [0]
   encode_f(cons_f(x_116)) -> f(f(encArg(x_116))) [0]
   encode_f(cons_a) -> f(a) [0]
   encode_f(cons_g(x_117)) -> f(g(encArg(x_117))) [0]
   encode_f(cons_activate(x_118)) -> f(activate(encArg(x_118))) [0]
   encode_f(x_1) -> f(null_encArg) [0]
   encode_n__f(x_1) -> n__f(encArg(x_1)) [0]
   encode_n__a -> n__a [0]
   encode_n__g(x_1) -> n__g(encArg(x_1)) [0]
   encode_a -> a [0]
   encode_g(n__f(x_119)) -> g(n__f(encArg(x_119))) [0]
   encode_g(n__a) -> g(n__a) [0]
   encode_g(n__g(x_120)) -> g(n__g(encArg(x_120))) [0]
   encode_g(cons_f(x_121)) -> g(f(encArg(x_121))) [0]
   encode_g(cons_a) -> g(a) [0]
   encode_g(cons_g(x_122)) -> g(g(encArg(x_122))) [0]
   encode_g(cons_activate(x_123)) -> g(activate(encArg(x_123))) [0]
   encode_g(x_1) -> g(null_encArg) [0]
   encode_activate(n__f(x_124)) -> activate(n__f(encArg(x_124))) [0]
   encode_activate(n__a) -> activate(n__a) [0]
   encode_activate(n__g(x_125)) -> activate(n__g(encArg(x_125))) [0]
   encode_activate(cons_f(x_126)) -> activate(f(encArg(x_126))) [0]
   encode_activate(cons_a) -> activate(a) [0]
   encode_activate(cons_g(x_127)) -> activate(g(encArg(x_127))) [0]
   encode_activate(cons_activate(x_128)) -> activate(activate(encArg(x_128))) [0]
   encode_activate(x_1) -> activate(null_encArg) [0]
   encArg(v0) -> null_encArg [0]
   encode_f(v0) -> null_encode_f [0]
   encode_n__f(v0) -> null_encode_n__f [0]
   encode_n__a -> null_encode_n__a [0]
   encode_n__g(v0) -> null_encode_n__g [0]
   encode_a -> null_encode_a [0]
   encode_g(v0) -> null_encode_g [0]
   encode_activate(v0) -> null_encode_activate [0]

The TRS has the following type information:
f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
n__f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
n__a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
n__g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
activate :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encArg :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
cons_f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
cons_a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
cons_g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
cons_activate :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encode_f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encode_n__f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encode_n__a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encode_n__g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encode_a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encode_g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
encode_activate :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate -> n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encArg :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encode_f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encode_n__f :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encode_n__a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encode_n__g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encode_a :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encode_g :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate
null_encode_activate :: n__a:n__f:n__g:cons_f:cons_a:cons_g:cons_activate:null_encArg:null_encode_f:null_encode_n__f:null_encode_n__a:null_encode_n__g:null_encode_a:null_encode_g:null_encode_activate

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:

   n__a => 1
   cons_a => 0
   null_encArg => 0
   null_encode_f => 0
   null_encode_n__f => 0
   null_encode_n__a => 0
   null_encode_n__g => 0
   null_encode_a => 0
   null_encode_g => 0
   null_encode_activate => 0

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 1 }-> X :|: X >= 0, z = X
   activate(z) -{ 2 }-> g(X) :|: z = 1 + X, X >= 0
   activate(z) -{ 2 }-> g(g(activate(X''))) :|: z = 1 + (1 + X''), X'' >= 0
   activate(z) -{ 2 }-> g(f(X')) :|: X' >= 0, z = 1 + (1 + X')
   activate(z) -{ 2 }-> g(a) :|: z = 1 + 1
   activate(z) -{ 1 }-> f(X) :|: z = 1 + X, X >= 0
   activate(z) -{ 1 }-> a :|: z = 1
   encArg(z) -{ 0 }-> g(g(encArg(x_17))) :|: x_17 >= 0, z = 1 + (1 + x_17)
   encArg(z) -{ 0 }-> g(f(encArg(x_16))) :|: x_16 >= 0, z = 1 + (1 + x_16)
   encArg(z) -{ 0 }-> g(activate(encArg(x_18))) :|: z = 1 + (1 + x_18), x_18 >= 0
   encArg(z) -{ 0 }-> g(a) :|: z = 1 + 0
   encArg(z) -{ 0 }-> g(1) :|: z = 1 + 1
   encArg(z) -{ 0 }-> g(0) :|: z = 1 + x_1, x_1 >= 0
   encArg(z) -{ 0 }-> g(1 + encArg(x_14)) :|: x_14 >= 0, z = 1 + (1 + x_14)
   encArg(z) -{ 0 }-> g(1 + encArg(x_15)) :|: x_15 >= 0, z = 1 + (1 + x_15)
   encArg(z) -{ 0 }-> f(g(encArg(x_12))) :|: z = 1 + (1 + x_12), x_12 >= 0
   encArg(z) -{ 0 }-> f(f(encArg(x_11))) :|: x_11 >= 0, z = 1 + (1 + x_11)
   encArg(z) -{ 0 }-> f(activate(encArg(x_13))) :|: z = 1 + (1 + x_13), x_13 >= 0
   encArg(z) -{ 0 }-> f(a) :|: z = 1 + 0
   encArg(z) -{ 0 }-> f(1) :|: z = 1 + 1
   encArg(z) -{ 0 }-> f(0) :|: z = 1 + x_1, x_1 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(x_1')) :|: z = 1 + (1 + x_1'), x_1' >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(x_1'')) :|: z = 1 + (1 + x_1''), x_1'' >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(x_112))) :|: x_112 >= 0, z = 1 + (1 + x_112)
   encArg(z) -{ 0 }-> activate(f(encArg(x_111))) :|: z = 1 + (1 + x_111), x_111 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(x_113))) :|: x_113 >= 0, z = 1 + (1 + x_113)
   encArg(z) -{ 0 }-> activate(a) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 0 }-> activate(0) :|: z = 1 + x_1, x_1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(x_110)) :|: z = 1 + (1 + x_110), x_110 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(x_19)) :|: z = 1 + (1 + x_19), x_19 >= 0
   encArg(z) -{ 0 }-> a :|: z = 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encArg(z) -{ 0 }-> 1 + encArg(x_1) :|: z = 1 + x_1, x_1 >= 0
   encode_a -{ 0 }-> a :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(x_127))) :|: x_127 >= 0, z = 1 + x_127
   encode_activate(z) -{ 0 }-> activate(f(encArg(x_126))) :|: z = 1 + x_126, x_126 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(x_128))) :|: x_128 >= 0, z = 1 + x_128
   encode_activate(z) -{ 0 }-> activate(a) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 0 }-> activate(0) :|: x_1 >= 0, z = x_1
   encode_activate(z) -{ 0 }-> activate(1 + encArg(x_124)) :|: x_124 >= 0, z = 1 + x_124
   encode_activate(z) -{ 0 }-> activate(1 + encArg(x_125)) :|: z = 1 + x_125, x_125 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_f(z) -{ 0 }-> f(g(encArg(x_117))) :|: x_117 >= 0, z = 1 + x_117
   encode_f(z) -{ 0 }-> f(f(encArg(x_116))) :|: x_116 >= 0, z = 1 + x_116
   encode_f(z) -{ 0 }-> f(activate(encArg(x_118))) :|: z = 1 + x_118, x_118 >= 0
   encode_f(z) -{ 0 }-> f(a) :|: z = 0
   encode_f(z) -{ 0 }-> f(1) :|: z = 1
   encode_f(z) -{ 0 }-> f(0) :|: x_1 >= 0, z = x_1
   encode_f(z) -{ 0 }-> f(1 + encArg(x_114)) :|: x_114 >= 0, z = 1 + x_114
   encode_f(z) -{ 0 }-> f(1 + encArg(x_115)) :|: x_115 >= 0, z = 1 + x_115
   encode_f(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_g(z) -{ 0 }-> g(g(encArg(x_122))) :|: x_122 >= 0, z = 1 + x_122
   encode_g(z) -{ 0 }-> g(f(encArg(x_121))) :|: z = 1 + x_121, x_121 >= 0
   encode_g(z) -{ 0 }-> g(activate(encArg(x_123))) :|: x_123 >= 0, z = 1 + x_123
   encode_g(z) -{ 0 }-> g(a) :|: z = 0
   encode_g(z) -{ 0 }-> g(1) :|: z = 1
   encode_g(z) -{ 0 }-> g(0) :|: x_1 >= 0, z = x_1
   encode_g(z) -{ 0 }-> g(1 + encArg(x_119)) :|: z = 1 + x_119, x_119 >= 0
   encode_g(z) -{ 0 }-> g(1 + encArg(x_120)) :|: x_120 >= 0, z = 1 + x_120
   encode_g(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_n__f(z) -{ 0 }-> 1 + encArg(x_1) :|: x_1 >= 0, z = x_1
   encode_n__g(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_n__g(z) -{ 0 }-> 1 + encArg(x_1) :|: x_1 >= 0, z = x_1
   f(z) -{ 1 }-> f(1 + (1 + 1)) :|: z = 1 + 1
   f(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   g(z) -{ 1 }-> 1 + X :|: X >= 0, z = X


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

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

   a -{ 1 }-> 1 :|: 
   g(z) -{ 1 }-> 1 + X :|: X >= 0, z = X

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 1 }-> X :|: X >= 0, z = X
   activate(z) -{ 2 }-> g(g(activate(X''))) :|: z = 1 + (1 + X''), X'' >= 0
   activate(z) -{ 2 }-> g(f(X')) :|: X' >= 0, z = 1 + (1 + X')
   activate(z) -{ 1 }-> f(X) :|: z = 1 + X, X >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z = 1 + X, X >= 0, X' >= 0, X = X'
   encArg(z) -{ 0 }-> g(g(encArg(x_17))) :|: x_17 >= 0, z = 1 + (1 + x_17)
   encArg(z) -{ 0 }-> g(f(encArg(x_16))) :|: x_16 >= 0, z = 1 + (1 + x_16)
   encArg(z) -{ 0 }-> g(activate(encArg(x_18))) :|: z = 1 + (1 + x_18), x_18 >= 0
   encArg(z) -{ 0 }-> g(1 + encArg(x_14)) :|: x_14 >= 0, z = 1 + (1 + x_14)
   encArg(z) -{ 0 }-> g(1 + encArg(x_15)) :|: x_15 >= 0, z = 1 + (1 + x_15)
   encArg(z) -{ 0 }-> f(g(encArg(x_12))) :|: z = 1 + (1 + x_12), x_12 >= 0
   encArg(z) -{ 0 }-> f(f(encArg(x_11))) :|: x_11 >= 0, z = 1 + (1 + x_11)
   encArg(z) -{ 0 }-> f(activate(encArg(x_13))) :|: z = 1 + (1 + x_13), x_13 >= 0
   encArg(z) -{ 0 }-> f(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> f(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> f(0) :|: z = 1 + x_1, x_1 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(x_1')) :|: z = 1 + (1 + x_1'), x_1' >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(x_1'')) :|: z = 1 + (1 + x_1''), x_1'' >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(x_112))) :|: x_112 >= 0, z = 1 + (1 + x_112)
   encArg(z) -{ 0 }-> activate(f(encArg(x_111))) :|: z = 1 + (1 + x_111), x_111 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(x_113))) :|: x_113 >= 0, z = 1 + (1 + x_113)
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z = 1 + x_1, x_1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(x_110)) :|: z = 1 + (1 + x_110), x_110 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(x_19)) :|: z = 1 + (1 + x_19), x_19 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + x_1, x_1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(x_1) :|: z = 1 + x_1, x_1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(x_127))) :|: x_127 >= 0, z = 1 + x_127
   encode_activate(z) -{ 0 }-> activate(f(encArg(x_126))) :|: z = 1 + x_126, x_126 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(x_128))) :|: x_128 >= 0, z = 1 + x_128
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: x_1 >= 0, z = x_1
   encode_activate(z) -{ 0 }-> activate(1 + encArg(x_124)) :|: x_124 >= 0, z = 1 + x_124
   encode_activate(z) -{ 0 }-> activate(1 + encArg(x_125)) :|: z = 1 + x_125, x_125 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_f(z) -{ 0 }-> f(g(encArg(x_117))) :|: x_117 >= 0, z = 1 + x_117
   encode_f(z) -{ 0 }-> f(f(encArg(x_116))) :|: x_116 >= 0, z = 1 + x_116
   encode_f(z) -{ 0 }-> f(activate(encArg(x_118))) :|: z = 1 + x_118, x_118 >= 0
   encode_f(z) -{ 0 }-> f(1) :|: z = 1
   encode_f(z) -{ 1 }-> f(1) :|: z = 0
   encode_f(z) -{ 0 }-> f(0) :|: x_1 >= 0, z = x_1
   encode_f(z) -{ 0 }-> f(1 + encArg(x_114)) :|: x_114 >= 0, z = 1 + x_114
   encode_f(z) -{ 0 }-> f(1 + encArg(x_115)) :|: x_115 >= 0, z = 1 + x_115
   encode_f(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_g(z) -{ 0 }-> g(g(encArg(x_122))) :|: x_122 >= 0, z = 1 + x_122
   encode_g(z) -{ 0 }-> g(f(encArg(x_121))) :|: z = 1 + x_121, x_121 >= 0
   encode_g(z) -{ 0 }-> g(activate(encArg(x_123))) :|: x_123 >= 0, z = 1 + x_123
   encode_g(z) -{ 0 }-> g(1 + encArg(x_119)) :|: z = 1 + x_119, x_119 >= 0
   encode_g(z) -{ 0 }-> g(1 + encArg(x_120)) :|: x_120 >= 0, z = 1 + x_120
   encode_g(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: x_1 >= 0, z = x_1, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_n__f(z) -{ 0 }-> 1 + encArg(x_1) :|: x_1 >= 0, z = x_1
   encode_n__g(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_n__g(z) -{ 0 }-> 1 + encArg(x_1) :|: x_1 >= 0, z = x_1
   f(z) -{ 1 }-> f(1 + (1 + 1)) :|: z = 1 + 1
   f(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   g(z) -{ 1 }-> 1 + X :|: X >= 0, z = X


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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> g(f(z - 2)) :|: z - 2 >= 0
   activate(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> f(1) :|: 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 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: 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(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(1) :|: z = 1
   encode_f(z) -{ 1 }-> f(1) :|: 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 1 }-> f(1 + (1 + 1)) :|: z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0


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

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

   { encode_a }
   { f }
   { encode_n__a }
   { g }
   { a }
   { activate }
   { encArg }
   { encode_g }
   { encode_activate }
   { encode_n__g }
   { encode_f }
   { encode_n__f }

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> g(f(z - 2)) :|: z - 2 >= 0
   activate(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> f(1) :|: 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 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: 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(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(1) :|: z = 1
   encode_f(z) -{ 1 }-> f(1) :|: 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 1 }-> f(1 + (1 + 1)) :|: z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_a}, {f}, {encode_n__a}, {g}, {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> g(f(z - 2)) :|: z - 2 >= 0
   activate(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> f(1) :|: 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 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: 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(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(1) :|: z = 1
   encode_f(z) -{ 1 }-> f(1) :|: 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 1 }-> f(1 + (1 + 1)) :|: z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_a}, {f}, {encode_n__a}, {g}, {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}

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

(25) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> g(f(z - 2)) :|: z - 2 >= 0
   activate(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> f(1) :|: 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 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: 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(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(1) :|: z = 1
   encode_f(z) -{ 1 }-> f(1) :|: 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 1 }-> f(1 + (1 + 1)) :|: z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_a}, {f}, {encode_n__a}, {g}, {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: ?, size: O(1) [1]

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

(27) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> g(f(z - 2)) :|: z - 2 >= 0
   activate(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> f(1) :|: 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 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: 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(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(1) :|: z = 1
   encode_f(z) -{ 1 }-> f(1) :|: 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 1 }-> f(1 + (1 + 1)) :|: z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {f}, {encode_n__a}, {g}, {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> g(f(z - 2)) :|: z - 2 >= 0
   activate(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> f(1) :|: 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 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: 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(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(1) :|: z = 1
   encode_f(z) -{ 1 }-> f(1) :|: 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 1 }-> f(1 + (1 + 1)) :|: z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {f}, {encode_n__a}, {g}, {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]

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

(31) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> g(f(z - 2)) :|: z - 2 >= 0
   activate(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> f(1) :|: 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 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: 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(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(1) :|: z = 1
   encode_f(z) -{ 1 }-> f(1) :|: 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 1 }-> f(1 + (1 + 1)) :|: z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {f}, {encode_n__a}, {g}, {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: ?, size: O(n^1) [4 + z]

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

(33) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> g(f(z - 2)) :|: z - 2 >= 0
   activate(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> f(1) :|: 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 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: 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(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(1) :|: z = 1
   encode_f(z) -{ 1 }-> f(1) :|: 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 1 }-> f(1 + (1 + 1)) :|: z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_n__a}, {g}, {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 4 }-> g(s6) :|: s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_n__a}, {g}, {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]

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

(37) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 4 }-> g(s6) :|: s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_n__a}, {g}, {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: ?, size: O(1) [1]

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 4 }-> g(s6) :|: s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {g}, {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 4 }-> g(s6) :|: s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {g}, {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]

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

(43) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 4 }-> g(s6) :|: s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {g}, {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: ?, size: O(n^1) [1 + z]

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

(45) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 4 }-> g(s6) :|: s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]

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

(49) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {a}, {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: ?, size: O(1) [1]

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]

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

(55) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {activate}, {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: ?, size: O(n^1) [3 + z]

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> g(g(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1) :|: z = 1 + 1
   encArg(z) -{ 1 }-> activate(1) :|: z = 1 + 0
   encArg(z) -{ 0 }-> activate(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1) :|: z = 1
   encode_activate(z) -{ 1 }-> activate(1) :|: z = 0
   encode_activate(z) -{ 0 }-> activate(0) :|: z >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]

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

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encArg}, {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: ?, size: O(n^1) [1 + 4*z]

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

(63) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, 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(activate(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(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(activate(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> activate(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 0 }-> activate(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(activate(encArg(z - 1))) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> activate(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, 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(activate(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) -{ 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(activate(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_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]

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

(67) 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: 2 + 4*z

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_g}, {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]
  encode_g: runtime: ?, size: O(n^1) [2 + 4*z]

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

(69) 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: 73 + 112*z + 128*z^2

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]
  encode_g: runtime: O(n^2) [73 + 112*z + 128*z^2], size: O(n^1) [2 + 4*z]

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]
  encode_g: runtime: O(n^2) [73 + 112*z + 128*z^2], size: O(n^1) [2 + 4*z]

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

(73) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_activate}, {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]
  encode_g: runtime: O(n^2) [73 + 112*z + 128*z^2], size: O(n^1) [2 + 4*z]
  encode_activate: runtime: ?, size: O(n^1) [4 + 4*z]

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

(75) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]
  encode_g: runtime: O(n^2) [73 + 112*z + 128*z^2], size: O(n^1) [2 + 4*z]
  encode_activate: runtime: O(n^2) [224 + 176*z + 128*z^2], size: O(n^1) [4 + 4*z]

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]
  encode_g: runtime: O(n^2) [73 + 112*z + 128*z^2], size: O(n^1) [2 + 4*z]
  encode_activate: runtime: O(n^2) [224 + 176*z + 128*z^2], size: O(n^1) [4 + 4*z]

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

(79) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_n__g}, {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]
  encode_g: runtime: O(n^2) [73 + 112*z + 128*z^2], size: O(n^1) [2 + 4*z]
  encode_activate: runtime: O(n^2) [224 + 176*z + 128*z^2], size: O(n^1) [4 + 4*z]
  encode_n__g: runtime: ?, size: O(n^1) [2 + 4*z]

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

(81) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]
  encode_g: runtime: O(n^2) [73 + 112*z + 128*z^2], size: O(n^1) [2 + 4*z]
  encode_activate: runtime: O(n^2) [224 + 176*z + 128*z^2], size: O(n^1) [4 + 4*z]
  encode_n__g: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [2 + 4*z]

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]
  encode_g: runtime: O(n^2) [73 + 112*z + 128*z^2], size: O(n^1) [2 + 4*z]
  encode_activate: runtime: O(n^2) [224 + 176*z + 128*z^2], size: O(n^1) [4 + 4*z]
  encode_n__g: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [2 + 4*z]

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

(85) 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: 5 + 4*z

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_f}, {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]
  encode_g: runtime: O(n^2) [73 + 112*z + 128*z^2], size: O(n^1) [2 + 4*z]
  encode_activate: runtime: O(n^2) [224 + 176*z + 128*z^2], size: O(n^1) [4 + 4*z]
  encode_n__g: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [2 + 4*z]
  encode_f: runtime: ?, size: O(n^1) [5 + 4*z]

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

(87) 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: 80 + 112*z + 128*z^2

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]
  encode_g: runtime: O(n^2) [73 + 112*z + 128*z^2], size: O(n^1) [2 + 4*z]
  encode_activate: runtime: O(n^2) [224 + 176*z + 128*z^2], size: O(n^1) [4 + 4*z]
  encode_n__g: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [2 + 4*z]
  encode_f: runtime: O(n^2) [80 + 112*z + 128*z^2], size: O(n^1) [5 + 4*z]

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]
  encode_g: runtime: O(n^2) [73 + 112*z + 128*z^2], size: O(n^1) [2 + 4*z]
  encode_activate: runtime: O(n^2) [224 + 176*z + 128*z^2], size: O(n^1) [4 + 4*z]
  encode_n__g: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [2 + 4*z]
  encode_f: runtime: O(n^2) [80 + 112*z + 128*z^2], size: O(n^1) [5 + 4*z]

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

(91) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_n__f}
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]
  encode_g: runtime: O(n^2) [73 + 112*z + 128*z^2], size: O(n^1) [2 + 4*z]
  encode_activate: runtime: O(n^2) [224 + 176*z + 128*z^2], size: O(n^1) [4 + 4*z]
  encode_n__g: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [2 + 4*z]
  encode_f: runtime: O(n^2) [80 + 112*z + 128*z^2], size: O(n^1) [5 + 4*z]
  encode_n__f: runtime: ?, size: O(n^1) [2 + 4*z]

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

(93) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   activate(z) -{ 3 }-> s' :|: s' >= 0, s' <= z - 1 + 4, z - 1 >= 0
   activate(z) -{ 14 + 4*z }-> s16 :|: s14 >= 0, s14 <= z - 2 + 3, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15 + 1, z - 2 >= 0
   activate(z) -{ 5 }-> s7 :|: s7 >= 0, s7 <= s6 + 1, s6 >= 0, s6 <= z - 2 + 4, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   encArg(z) -{ 2 }-> s'' :|: s'' >= 0, s'' <= 1 + 4, z = 1 + 1
   encArg(z) -{ 2 }-> s1 :|: s1 >= 0, s1 <= 0 + 4, z - 1 >= 0
   encArg(z) -{ 23 }-> s12 :|: s12 >= 0, s12 <= 1 + 3, z = 1 + 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s19 :|: s18 >= 0, s18 <= 4 * (z - 2) + 1, s19 >= 0, s19 <= 1 + s18 + 4, z - 2 >= 0
   encArg(z) -{ 26 + -40*z + 32*z^2 }-> s22 :|: s20 >= 0, s20 <= 4 * (z - 2) + 1, s21 >= 0, s21 <= s20 + 4, s22 >= 0, s22 <= s21 + 4, z - 2 >= 0
   encArg(z) -{ 42 + 4*s23 + -40*z + 32*z^2 }-> s25 :|: s23 >= 0, s23 <= 4 * (z - 2) + 1, s24 >= 0, s24 <= s23 + 3, s25 >= 0, s25 <= s24 + 4, z - 2 >= 0
   encArg(z) -{ 44 + 4*s26 + -40*z + 32*z^2 }-> s27 :|: s26 >= 0, s26 <= 4 * (z - 2) + 1, s27 >= 0, s27 <= 1 + s26 + 3, z - 2 >= 0
   encArg(z) -{ 42 + 4*s29 + -40*z + 32*z^2 }-> s30 :|: s28 >= 0, s28 <= 4 * (z - 2) + 1, s29 >= 0, s29 <= s28 + 4, s30 >= 0, s30 <= s29 + 3, z - 2 >= 0
   encArg(z) -{ 58 + 4*s31 + 4*s32 + -40*z + 32*z^2 }-> s33 :|: s31 >= 0, s31 <= 4 * (z - 2) + 1, s32 >= 0, s32 <= s31 + 3, s33 >= 0, s33 <= s32 + 3, z - 2 >= 0
   encArg(z) -{ 3 }-> s4 :|: s4 >= 0, s4 <= 1 + 4, z = 1 + 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s54 :|: s52 >= 0, s52 <= 4 * (z - 2) + 1, s53 >= 0, s53 <= s52 + 1, s54 >= 0, s54 <= s53 + 4, z - 2 >= 0
   encArg(z) -{ 23 + -40*z + 32*z^2 }-> s56 :|: s55 >= 0, s55 <= 4 * (z - 2) + 1, s56 >= 0, s56 <= 1 + s55 + 1, z - 2 >= 0
   encArg(z) -{ 25 + -40*z + 32*z^2 }-> s59 :|: s57 >= 0, s57 <= 4 * (z - 2) + 1, s58 >= 0, s58 <= s57 + 4, s59 >= 0, s59 <= s58 + 1, z - 2 >= 0
   encArg(z) -{ 24 + -40*z + 32*z^2 }-> s62 :|: s60 >= 0, s60 <= 4 * (z - 2) + 1, s61 >= 0, s61 <= s60 + 1, s62 >= 0, s62 <= s61 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s63 + -40*z + 32*z^2 }-> s65 :|: s63 >= 0, s63 <= 4 * (z - 2) + 1, s64 >= 0, s64 <= s63 + 3, s65 >= 0, s65 <= s64 + 1, z - 2 >= 0
   encArg(z) -{ 41 + 4*s67 + -40*z + 32*z^2 }-> s68 :|: s66 >= 0, s66 <= 4 * (z - 2) + 1, s67 >= 0, s67 <= s66 + 1, s68 >= 0, s68 <= s67 + 3, z - 2 >= 0
   encArg(z) -{ 22 }-> s8 :|: s8 >= 0, s8 <= 1 + 3, z = 1 + 1
   encArg(z) -{ 18 }-> s9 :|: s9 >= 0, s9 <= 0 + 3, z - 1 >= 0
   encArg(z) -{ 0 }-> 1 :|: z = 1
   encArg(z) -{ 1 }-> 1 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 1 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   encArg(z) -{ 1 }-> 1 + X :|: z - 1 >= 0, X >= 0, 0 = X
   encArg(z) -{ 2 }-> 1 + X :|: z = 1 + 0, X >= 0, 1 = X
   encArg(z) -{ 14 + 24*z + 32*z^2 }-> 1 + s17 :|: s17 >= 0, s17 <= 4 * (z - 1) + 1, z - 1 >= 0
   encode_a -{ 1 }-> 1 :|: 
   encode_a -{ 0 }-> 0 :|: 
   encode_activate(z) -{ 22 }-> s10 :|: s10 >= 0, s10 <= 1 + 3, z = 1
   encode_activate(z) -{ 18 }-> s11 :|: s11 >= 0, s11 <= 0 + 3, z >= 0
   encode_activate(z) -{ 23 }-> s13 :|: s13 >= 0, s13 <= 1 + 3, z = 0
   encode_activate(z) -{ 36 + 4*s44 + 24*z + 32*z^2 }-> s45 :|: s44 >= 0, s44 <= 4 * (z - 1) + 1, s45 >= 0, s45 <= 1 + s44 + 3, z - 1 >= 0
   encode_activate(z) -{ 34 + 4*s47 + 24*z + 32*z^2 }-> s48 :|: s46 >= 0, s46 <= 4 * (z - 1) + 1, s47 >= 0, s47 <= s46 + 4, s48 >= 0, s48 <= s47 + 3, z - 1 >= 0
   encode_activate(z) -{ 50 + 4*s49 + 4*s50 + 24*z + 32*z^2 }-> s51 :|: s49 >= 0, s49 <= 4 * (z - 1) + 1, s50 >= 0, s50 <= s49 + 3, s51 >= 0, s51 <= s50 + 3, z - 1 >= 0
   encode_activate(z) -{ 33 + 4*s84 + 24*z + 32*z^2 }-> s85 :|: s83 >= 0, s83 <= 4 * (z - 1) + 1, s84 >= 0, s84 <= s83 + 1, s85 >= 0, s85 <= s84 + 3, z - 1 >= 0
   encode_activate(z) -{ 0 }-> 0 :|: z >= 0
   encode_f(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 1 + 4, z = 1
   encode_f(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 4, z >= 0
   encode_f(z) -{ 16 + 24*z + 32*z^2 }-> s35 :|: s34 >= 0, s34 <= 4 * (z - 1) + 1, s35 >= 0, s35 <= 1 + s34 + 4, z - 1 >= 0
   encode_f(z) -{ 18 + 24*z + 32*z^2 }-> s38 :|: s36 >= 0, s36 <= 4 * (z - 1) + 1, s37 >= 0, s37 <= s36 + 4, s38 >= 0, s38 <= s37 + 4, z - 1 >= 0
   encode_f(z) -{ 34 + 4*s39 + 24*z + 32*z^2 }-> s41 :|: s39 >= 0, s39 <= 4 * (z - 1) + 1, s40 >= 0, s40 <= s39 + 3, s41 >= 0, s41 <= s40 + 4, z - 1 >= 0
   encode_f(z) -{ 3 }-> s5 :|: s5 >= 0, s5 <= 1 + 4, z = 0
   encode_f(z) -{ 17 + 24*z + 32*z^2 }-> s71 :|: s69 >= 0, s69 <= 4 * (z - 1) + 1, s70 >= 0, s70 <= s69 + 1, s71 >= 0, s71 <= s70 + 4, z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 15 + 24*z + 32*z^2 }-> s73 :|: s72 >= 0, s72 <= 4 * (z - 1) + 1, s73 >= 0, s73 <= 1 + s72 + 1, z - 1 >= 0
   encode_g(z) -{ 17 + 24*z + 32*z^2 }-> s76 :|: s74 >= 0, s74 <= 4 * (z - 1) + 1, s75 >= 0, s75 <= s74 + 4, s76 >= 0, s76 <= s75 + 1, z - 1 >= 0
   encode_g(z) -{ 16 + 24*z + 32*z^2 }-> s79 :|: s77 >= 0, s77 <= 4 * (z - 1) + 1, s78 >= 0, s78 <= s77 + 1, s79 >= 0, s79 <= s78 + 1, z - 1 >= 0
   encode_g(z) -{ 33 + 4*s80 + 24*z + 32*z^2 }-> s82 :|: s80 >= 0, s80 <= 4 * (z - 1) + 1, s81 >= 0, s81 <= s80 + 3, s82 >= 0, s82 <= s81 + 1, z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> 1 + X :|: z = 1, X >= 0, 1 = X
   encode_g(z) -{ 1 }-> 1 + X :|: z >= 0, X >= 0, 0 = X
   encode_g(z) -{ 2 }-> 1 + X :|: z = 0, X >= 0, 1 = X
   encode_n__a -{ 0 }-> 1 :|: 
   encode_n__a -{ 0 }-> 0 :|: 
   encode_n__f(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__f(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s42 :|: s42 >= 0, s42 <= 4 * z + 1, z >= 0
   encode_n__g(z) -{ 0 }-> 0 :|: z >= 0
   encode_n__g(z) -{ 70 + 88*z + 32*z^2 }-> 1 + s43 :|: s43 >= 0, s43 <= 4 * z + 1, z >= 0
   f(z) -{ 3 }-> s :|: s >= 0, s <= 1 + (1 + 1) + 4, z = 1 + 1
   f(z) -{ 1 }-> 1 + z :|: z >= 0
   g(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: 
Previous analysis results are:
  encode_a: runtime: O(1) [1], size: O(1) [1]
  f: runtime: O(1) [2], size: O(n^1) [4 + z]
  encode_n__a: runtime: O(1) [0], size: O(1) [1]
  g: runtime: O(1) [1], size: O(n^1) [1 + z]
  a: runtime: O(1) [1], size: O(1) [1]
  activate: runtime: O(n^1) [18 + 4*z], size: O(n^1) [3 + z]
  encArg: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [1 + 4*z]
  encode_g: runtime: O(n^2) [73 + 112*z + 128*z^2], size: O(n^1) [2 + 4*z]
  encode_activate: runtime: O(n^2) [224 + 176*z + 128*z^2], size: O(n^1) [4 + 4*z]
  encode_n__g: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [2 + 4*z]
  encode_f: runtime: O(n^2) [80 + 112*z + 128*z^2], size: O(n^1) [5 + 4*z]
  encode_n__f: runtime: O(n^2) [70 + 88*z + 32*z^2], size: O(n^1) [2 + 4*z]

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

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

(96)
BOUNDS(1, n^2)

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

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

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

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:

   f(n__f(n__a)) -> f(n__g(n__f(n__a)))
   f(X) -> n__f(X)
   a -> n__a
   g(X) -> n__g(X)
   activate(n__f(X)) -> f(X)
   activate(n__a) -> a
   activate(n__g(X)) -> g(activate(X))
   activate(X) -> X

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

   encArg(n__f(x_1)) -> n__f(encArg(x_1))
   encArg(n__a) -> n__a
   encArg(n__g(x_1)) -> n__g(encArg(x_1))
   encArg(cons_f(x_1)) -> f(encArg(x_1))
   encArg(cons_a) -> a
   encArg(cons_g(x_1)) -> g(encArg(x_1))
   encArg(cons_activate(x_1)) -> activate(encArg(x_1))
   encode_f(x_1) -> f(encArg(x_1))
   encode_n__f(x_1) -> n__f(encArg(x_1))
   encode_n__a -> n__a
   encode_n__g(x_1) -> n__g(encArg(x_1))
   encode_a -> a
   encode_g(x_1) -> g(encArg(x_1))
   encode_activate(x_1) -> activate(encArg(x_1))

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

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

The rewrite sequence

activate(n__g(X)) ->^+ g(activate(X))

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

The pumping substitution is [X / n__g(X)].

The result substitution is [ ].




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

(100)
Complex Obligation (BEST)

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

(101)
Obligation:
Proved the lower bound n^1 for the following 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:

   f(n__f(n__a)) -> f(n__g(n__f(n__a)))
   f(X) -> n__f(X)
   a -> n__a
   g(X) -> n__g(X)
   activate(n__f(X)) -> f(X)
   activate(n__a) -> a
   activate(n__g(X)) -> g(activate(X))
   activate(X) -> X

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

   encArg(n__f(x_1)) -> n__f(encArg(x_1))
   encArg(n__a) -> n__a
   encArg(n__g(x_1)) -> n__g(encArg(x_1))
   encArg(cons_f(x_1)) -> f(encArg(x_1))
   encArg(cons_a) -> a
   encArg(cons_g(x_1)) -> g(encArg(x_1))
   encArg(cons_activate(x_1)) -> activate(encArg(x_1))
   encode_f(x_1) -> f(encArg(x_1))
   encode_n__f(x_1) -> n__f(encArg(x_1))
   encode_n__a -> n__a
   encode_n__g(x_1) -> n__g(encArg(x_1))
   encode_a -> a
   encode_g(x_1) -> g(encArg(x_1))
   encode_activate(x_1) -> activate(encArg(x_1))

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

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

(103)
BOUNDS(n^1, INF)

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

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

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:

   f(n__f(n__a)) -> f(n__g(n__f(n__a)))
   f(X) -> n__f(X)
   a -> n__a
   g(X) -> n__g(X)
   activate(n__f(X)) -> f(X)
   activate(n__a) -> a
   activate(n__g(X)) -> g(activate(X))
   activate(X) -> X

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

   encArg(n__f(x_1)) -> n__f(encArg(x_1))
   encArg(n__a) -> n__a
   encArg(n__g(x_1)) -> n__g(encArg(x_1))
   encArg(cons_f(x_1)) -> f(encArg(x_1))
   encArg(cons_a) -> a
   encArg(cons_g(x_1)) -> g(encArg(x_1))
   encArg(cons_activate(x_1)) -> activate(encArg(x_1))
   encode_f(x_1) -> f(encArg(x_1))
   encode_n__f(x_1) -> n__f(encArg(x_1))
   encode_n__a -> n__a
   encode_n__g(x_1) -> n__g(encArg(x_1))
   encode_a -> a
   encode_g(x_1) -> g(encArg(x_1))
   encode_activate(x_1) -> activate(encArg(x_1))

Rewrite Strategy: FULL