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


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


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


The Derivational Complexity (innermost) 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), 175 ms]
(4) CpxRelTRS
(5) NonCtorToCtorProof [UPPER BOUND(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), 327 ms]
    (18) CpxRNTS
    (19) SimplificationProof [BOTH BOUNDS(ID, ID), 6 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), 192 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), 862 ms]
    (32) CpxRNTS
    (33) IntTrsBoundProof [UPPER BOUND(ID), 349 ms]
    (34) CpxRNTS
    (35) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (36) CpxRNTS
    (37) IntTrsBoundProof [UPPER BOUND(ID), 46 ms]
    (38) CpxRNTS
    (39) IntTrsBoundProof [UPPER BOUND(ID), 2 ms]
    (40) CpxRNTS
    (41) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (42) CpxRNTS
    (43) IntTrsBoundProof [UPPER BOUND(ID), 149 ms]
    (44) CpxRNTS
    (45) IntTrsBoundProof [UPPER BOUND(ID), 66 ms]
    (46) CpxRNTS
    (47) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (48) CpxRNTS
    (49) IntTrsBoundProof [UPPER BOUND(ID), 771 ms]
    (50) CpxRNTS
    (51) IntTrsBoundProof [UPPER BOUND(ID), 390 ms]
    (52) CpxRNTS
    (53) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (54) CpxRNTS
    (55) IntTrsBoundProof [UPPER BOUND(ID), 371 ms]
    (56) CpxRNTS
    (57) IntTrsBoundProof [UPPER BOUND(ID), 58 ms]
    (58) CpxRNTS
    (59) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (60) CpxRNTS
    (61) IntTrsBoundProof [UPPER BOUND(ID), 170 ms]
    (62) CpxRNTS
    (63) IntTrsBoundProof [UPPER BOUND(ID), 3 ms]
    (64) CpxRNTS
    (65) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (66) CpxRNTS
    (67) IntTrsBoundProof [UPPER BOUND(ID), 147 ms]
    (68) CpxRNTS
    (69) IntTrsBoundProof [UPPER BOUND(ID), 2 ms]
    (70) CpxRNTS
    (71) FinalProof [FINISHED, 0 ms]
    (72) BOUNDS(1, n^2)
(73) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(74) CpxRelTRS
    (75) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (76) typed CpxTrs
    (77) OrderProof [LOWER BOUND(ID), 0 ms]
    (78) typed CpxTrs
    (79) RewriteLemmaProof [LOWER BOUND(ID), 185 ms]
    (80) proven lower bound
    (81) LowerBoundPropagationProof [FINISHED, 0 ms]
    (82) BOUNDS(n^1, INF)


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

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


The TRS R consists of the following rules:

   and(x, false) -> false
   and(x, not(false)) -> x
   not(not(x)) -> x
   implies(false, y) -> not(false)
   implies(x, false) -> not(x)
   implies(not(x), not(y)) -> implies(y, and(x, y))

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

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

   encArg(false) -> false
   encArg(cons_and(x_1, x_2)) -> and(encArg(x_1), encArg(x_2))
   encArg(cons_not(x_1)) -> not(encArg(x_1))
   encArg(cons_implies(x_1, x_2)) -> implies(encArg(x_1), encArg(x_2))
   encode_and(x_1, x_2) -> and(encArg(x_1), encArg(x_2))
   encode_false -> false
   encode_not(x_1) -> not(encArg(x_1))
   encode_implies(x_1, x_2) -> implies(encArg(x_1), encArg(x_2))


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

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


The TRS R consists of the following rules:

   and(x, false) -> false
   and(x, not(false)) -> x
   not(not(x)) -> x
   implies(false, y) -> not(false)
   implies(x, false) -> not(x)
   implies(not(x), not(y)) -> implies(y, and(x, y))

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

   encArg(false) -> false
   encArg(cons_and(x_1, x_2)) -> and(encArg(x_1), encArg(x_2))
   encArg(cons_not(x_1)) -> not(encArg(x_1))
   encArg(cons_implies(x_1, x_2)) -> implies(encArg(x_1), encArg(x_2))
   encode_and(x_1, x_2) -> and(encArg(x_1), encArg(x_2))
   encode_false -> false
   encode_not(x_1) -> not(encArg(x_1))
   encode_implies(x_1, x_2) -> implies(encArg(x_1), encArg(x_2))

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

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

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


The TRS R consists of the following rules:

   and(x, false) -> false
   and(x, not(false)) -> x
   not(not(x)) -> x
   implies(false, y) -> not(false)
   implies(x, false) -> not(x)
   implies(not(x), not(y)) -> implies(y, and(x, y))

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

   encArg(false) -> false
   encArg(cons_and(x_1, x_2)) -> and(encArg(x_1), encArg(x_2))
   encArg(cons_not(x_1)) -> not(encArg(x_1))
   encArg(cons_implies(x_1, x_2)) -> implies(encArg(x_1), encArg(x_2))
   encode_and(x_1, x_2) -> and(encArg(x_1), encArg(x_2))
   encode_false -> false
   encode_not(x_1) -> not(encArg(x_1))
   encode_implies(x_1, x_2) -> implies(encArg(x_1), encArg(x_2))

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

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

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

   and(x, false) -> false
   implies(false, y) -> not(false)
   implies(x, false) -> not(x)
   and(x, c_not(false)) -> x
   not(c_not(x)) -> x
   implies(c_not(x), c_not(y)) -> implies(y, and(x, y))

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

   encArg(false) -> false
   encArg(cons_and(x_1, x_2)) -> and(encArg(x_1), encArg(x_2))
   encArg(cons_not(x_1)) -> not(encArg(x_1))
   encArg(cons_implies(x_1, x_2)) -> implies(encArg(x_1), encArg(x_2))
   encode_and(x_1, x_2) -> and(encArg(x_1), encArg(x_2))
   encode_false -> false
   encode_not(x_1) -> not(encArg(x_1))
   encode_implies(x_1, x_2) -> implies(encArg(x_1), encArg(x_2))
   not(x0) -> c_not(x0)

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:

   and(x, false) -> false [1]
   implies(false, y) -> not(false) [1]
   implies(x, false) -> not(x) [1]
   and(x, c_not(false)) -> x [1]
   not(c_not(x)) -> x [1]
   implies(c_not(x), c_not(y)) -> implies(y, and(x, y)) [1]
   encArg(false) -> false [0]
   encArg(cons_and(x_1, x_2)) -> and(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_not(x_1)) -> not(encArg(x_1)) [0]
   encArg(cons_implies(x_1, x_2)) -> implies(encArg(x_1), encArg(x_2)) [0]
   encode_and(x_1, x_2) -> and(encArg(x_1), encArg(x_2)) [0]
   encode_false -> false [0]
   encode_not(x_1) -> not(encArg(x_1)) [0]
   encode_implies(x_1, x_2) -> implies(encArg(x_1), encArg(x_2)) [0]
   not(x0) -> c_not(x0) [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:

   and(x, false) -> false [1]
   implies(false, y) -> not(false) [1]
   implies(x, false) -> not(x) [1]
   and(x, c_not(false)) -> x [1]
   not(c_not(x)) -> x [1]
   implies(c_not(x), c_not(y)) -> implies(y, and(x, y)) [1]
   encArg(false) -> false [0]
   encArg(cons_and(x_1, x_2)) -> and(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_not(x_1)) -> not(encArg(x_1)) [0]
   encArg(cons_implies(x_1, x_2)) -> implies(encArg(x_1), encArg(x_2)) [0]
   encode_and(x_1, x_2) -> and(encArg(x_1), encArg(x_2)) [0]
   encode_false -> false [0]
   encode_not(x_1) -> not(encArg(x_1)) [0]
   encode_implies(x_1, x_2) -> implies(encArg(x_1), encArg(x_2)) [0]
   not(x0) -> c_not(x0) [0]

The TRS has the following type information:
and :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
false :: false:c_not:cons_and:cons_not:cons_implies
implies :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
not :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
c_not :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
encArg :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
cons_and :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
cons_not :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
cons_implies :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
encode_and :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
encode_false :: false:c_not:cons_and:cons_not:cons_implies
encode_not :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
encode_implies :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies

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:

   and_2
   implies_2
   encArg_1
   encode_and_2
   encode_false
   encode_not_1
   encode_implies_2
   not_1

Due to the following rules being added:

   encArg(v0) -> false [0]
   encode_and(v0, v1) -> false [0]
   encode_false -> false [0]
   encode_not(v0) -> false [0]
   encode_implies(v0, v1) -> false [0]
   not(v0) -> false [0]
   and(v0, v1) -> false [0]
   implies(v0, v1) -> false [0]

And the following fresh constants: none

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

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

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

   and(x, false) -> false [1]
   implies(false, y) -> not(false) [1]
   implies(x, false) -> not(x) [1]
   and(x, c_not(false)) -> x [1]
   not(c_not(x)) -> x [1]
   implies(c_not(x), c_not(y)) -> implies(y, and(x, y)) [1]
   encArg(false) -> false [0]
   encArg(cons_and(x_1, x_2)) -> and(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_not(x_1)) -> not(encArg(x_1)) [0]
   encArg(cons_implies(x_1, x_2)) -> implies(encArg(x_1), encArg(x_2)) [0]
   encode_and(x_1, x_2) -> and(encArg(x_1), encArg(x_2)) [0]
   encode_false -> false [0]
   encode_not(x_1) -> not(encArg(x_1)) [0]
   encode_implies(x_1, x_2) -> implies(encArg(x_1), encArg(x_2)) [0]
   not(x0) -> c_not(x0) [0]
   encArg(v0) -> false [0]
   encode_and(v0, v1) -> false [0]
   encode_false -> false [0]
   encode_not(v0) -> false [0]
   encode_implies(v0, v1) -> false [0]
   not(v0) -> false [0]
   and(v0, v1) -> false [0]
   implies(v0, v1) -> false [0]

The TRS has the following type information:
and :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
false :: false:c_not:cons_and:cons_not:cons_implies
implies :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
not :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
c_not :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
encArg :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
cons_and :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
cons_not :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
cons_implies :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
encode_and :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
encode_false :: false:c_not:cons_and:cons_not:cons_implies
encode_not :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
encode_implies :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies

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:

   and(x, false) -> false [1]
   implies(false, y) -> not(false) [1]
   implies(x, false) -> not(x) [1]
   and(x, c_not(false)) -> x [1]
   not(c_not(x)) -> x [1]
   implies(c_not(x), c_not(false)) -> implies(false, false) [2]
   implies(c_not(x), c_not(c_not(false))) -> implies(c_not(false), x) [2]
   implies(c_not(x), c_not(y)) -> implies(y, false) [1]
   encArg(false) -> false [0]
   encArg(cons_and(x_1, x_2)) -> and(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_not(false)) -> not(false) [0]
   encArg(cons_not(cons_and(x_117, x_211))) -> not(and(encArg(x_117), encArg(x_211))) [0]
   encArg(cons_not(cons_not(x_118))) -> not(not(encArg(x_118))) [0]
   encArg(cons_not(cons_implies(x_119, x_212))) -> not(implies(encArg(x_119), encArg(x_212))) [0]
   encArg(cons_not(x_1)) -> not(false) [0]
   encArg(cons_implies(x_1, x_2)) -> implies(encArg(x_1), encArg(x_2)) [0]
   encode_and(x_1, x_2) -> and(encArg(x_1), encArg(x_2)) [0]
   encode_false -> false [0]
   encode_not(false) -> not(false) [0]
   encode_not(cons_and(x_156, x_237)) -> not(and(encArg(x_156), encArg(x_237))) [0]
   encode_not(cons_not(x_157)) -> not(not(encArg(x_157))) [0]
   encode_not(cons_implies(x_158, x_238)) -> not(implies(encArg(x_158), encArg(x_238))) [0]
   encode_not(x_1) -> not(false) [0]
   encode_implies(x_1, x_2) -> implies(encArg(x_1), encArg(x_2)) [0]
   not(x0) -> c_not(x0) [0]
   encArg(v0) -> false [0]
   encode_and(v0, v1) -> false [0]
   encode_false -> false [0]
   encode_not(v0) -> false [0]
   encode_implies(v0, v1) -> false [0]
   not(v0) -> false [0]
   and(v0, v1) -> false [0]
   implies(v0, v1) -> false [0]

The TRS has the following type information:
and :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
false :: false:c_not:cons_and:cons_not:cons_implies
implies :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
not :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
c_not :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
encArg :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
cons_and :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
cons_not :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
cons_implies :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
encode_and :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
encode_false :: false:c_not:cons_and:cons_not:cons_implies
encode_not :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies
encode_implies :: false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies -> false:c_not:cons_and:cons_not:cons_implies

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:

   false => 0

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

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

   and(z, z') -{ 1 }-> x :|: x >= 0, z' = 1 + 0, z = x
   and(z, z') -{ 1 }-> 0 :|: x >= 0, z = x, z' = 0
   and(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   encArg(z) -{ 0 }-> not(not(encArg(x_118))) :|: z = 1 + (1 + x_118), x_118 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> not(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> not(0) :|: z = 1 + x_1, x_1 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_and(z, z') -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, x_2 >= 0, z = x_1, z' = x_2
   encode_and(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, x_2 >= 0, z = x_1, z' = x_2
   encode_implies(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   encode_not(z) -{ 0 }-> not(not(encArg(x_157))) :|: z = 1 + x_157, x_157 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> not(0) :|: z = 0
   encode_not(z) -{ 0 }-> not(0) :|: x_1 >= 0, z = x_1
   encode_not(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   implies(z, z') -{ 1 }-> not(x) :|: x >= 0, z = x, z' = 0
   implies(z, z') -{ 1 }-> not(0) :|: y >= 0, z = 0, z' = y
   implies(z, z') -{ 1 }-> implies(y, 0) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   implies(z, z') -{ 2 }-> implies(0, 0) :|: x >= 0, z' = 1 + 0, z = 1 + x
   implies(z, z') -{ 2 }-> implies(1 + 0, x) :|: z' = 1 + (1 + 0), x >= 0, z = 1 + x
   implies(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   not(z) -{ 1 }-> x :|: x >= 0, z = 1 + x
   not(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   not(z) -{ 0 }-> 1 + x0 :|: z = x0, x0 >= 0


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

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

   and(z, z') -{ 1 }-> x :|: x >= 0, z' = 1 + 0, z = x
   and(z, z') -{ 1 }-> 0 :|: x >= 0, z = x, z' = 0
   and(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   not(z) -{ 1 }-> x :|: x >= 0, z = 1 + x
   not(z) -{ 0 }-> 1 + x0 :|: z = x0, x0 >= 0
   not(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0

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

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

   and(z, z') -{ 1 }-> x :|: x >= 0, z' = 1 + 0, z = x
   and(z, z') -{ 1 }-> 0 :|: x >= 0, z = x, z' = 0
   and(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   encArg(z) -{ 0 }-> not(not(encArg(x_118))) :|: z = 1 + (1 + x_118), x_118 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + x_1, x_1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + x_1, x_1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, x_2 >= 0, z = x_1, z' = x_2
   encode_and(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, x_2 >= 0, z = x_1, z' = x_2
   encode_implies(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   encode_not(z) -{ 0 }-> not(not(encArg(x_157))) :|: z = 1 + x_157, x_157 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: x_1 >= 0, z = x_1, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: x_1 >= 0, z = x_1, 0 = x0, x0 >= 0
   implies(z, z') -{ 2 }-> x' :|: x >= 0, z = x, z' = 0, x' >= 0, x = 1 + x'
   implies(z, z') -{ 1 }-> implies(y, 0) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   implies(z, z') -{ 2 }-> implies(0, 0) :|: x >= 0, z' = 1 + 0, z = 1 + x
   implies(z, z') -{ 2 }-> implies(1 + 0, x) :|: z' = 1 + (1 + 0), x >= 0, z = 1 + x
   implies(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   implies(z, z') -{ 1 }-> 0 :|: y >= 0, z = 0, z' = y, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: x >= 0, z = x, z' = 0, v0 >= 0, x = v0
   implies(z, z') -{ 1 }-> 1 + x0 :|: y >= 0, z = 0, z' = y, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: x >= 0, z = x, z' = 0, x = x0, x0 >= 0
   not(z) -{ 1 }-> x :|: x >= 0, z = 1 + x
   not(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   not(z) -{ 0 }-> 1 + x0 :|: z = x0, x0 >= 0


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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 2 }-> implies(0, 0) :|: z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 1 }-> implies(z' - 1, 0) :|: z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 2 }-> implies(1 + 0, z - 1) :|: z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0


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

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

   { not }
   { implies }
   { encode_false }
   { and }
   { encArg }
   { encode_not }
   { encode_and }
   { encode_implies }

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 2 }-> implies(0, 0) :|: z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 1 }-> implies(z' - 1, 0) :|: z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 2 }-> implies(1 + 0, z - 1) :|: z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {not}, {implies}, {encode_false}, {and}, {encArg}, {encode_not}, {encode_and}, {encode_implies}

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 2 }-> implies(0, 0) :|: z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 1 }-> implies(z' - 1, 0) :|: z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 2 }-> implies(1 + 0, z - 1) :|: z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {not}, {implies}, {encode_false}, {and}, {encArg}, {encode_not}, {encode_and}, {encode_implies}

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

(25) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 2 }-> implies(0, 0) :|: z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 1 }-> implies(z' - 1, 0) :|: z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 2 }-> implies(1 + 0, z - 1) :|: z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {not}, {implies}, {encode_false}, {and}, {encArg}, {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: ?, size: O(n^1) [1 + z]

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

(27) IntTrsBoundProof (UPPER BOUND(ID))

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 2 }-> implies(0, 0) :|: z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 1 }-> implies(z' - 1, 0) :|: z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 2 }-> implies(1 + 0, z - 1) :|: z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {implies}, {encode_false}, {and}, {encArg}, {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 2 }-> implies(0, 0) :|: z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 1 }-> implies(z' - 1, 0) :|: z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 2 }-> implies(1 + 0, z - 1) :|: z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {implies}, {encode_false}, {and}, {encArg}, {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]

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

(31) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 2 }-> implies(0, 0) :|: z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 1 }-> implies(z' - 1, 0) :|: z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 2 }-> implies(1 + 0, z - 1) :|: z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {implies}, {encode_false}, {and}, {encArg}, {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: ?, size: O(n^1) [1 + z + z']

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

(33) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 2 }-> implies(0, 0) :|: z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 1 }-> implies(z' - 1, 0) :|: z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 2 }-> implies(1 + 0, z - 1) :|: z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_false}, {and}, {encArg}, {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + 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:

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_false}, {and}, {encArg}, {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']

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

(37) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_false}, {and}, {encArg}, {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: ?, size: O(1) [0]

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {and}, {encArg}, {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {and}, {encArg}, {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]

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

(43) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {and}, {encArg}, {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]
  and: runtime: ?, size: O(n^1) [z]

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

(45) IntTrsBoundProof (UPPER BOUND(ID))

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encArg}, {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]
  and: runtime: O(1) [1], size: O(n^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:

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encArg}, {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]
  and: runtime: O(1) [1], size: O(n^1) [z]

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

(49) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encArg}, {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]
  and: runtime: O(1) [1], size: O(n^1) [z]
  encArg: runtime: ?, size: O(n^1) [1 + z]

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

(51) 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: 5*z + 2*z^2

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_119), encArg(x_212))) :|: x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 0 }-> not(and(encArg(x_117), encArg(x_211))) :|: x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 0 }-> implies(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> and(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 0 }-> and(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 0 }-> implies(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_158), encArg(x_238))) :|: z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 0 }-> not(and(encArg(x_156), encArg(x_237))) :|: x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]
  and: runtime: O(1) [1], size: O(n^1) [z]
  encArg: runtime: O(n^2) [5*z + 2*z^2], size: O(n^1) [1 + z]

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ -3*z + 2*z^2 }-> s15 :|: s13 >= 0, s13 <= z - 2 + 1, s14 >= 0, s14 <= s13 + 1, s15 >= 0, s15 <= s14 + 1, z - 2 >= 0
   encArg(z) -{ 6 + 2*s16 + 5*x_119 + 2*x_119^2 + 5*x_212 + 2*x_212^2 }-> s19 :|: s16 >= 0, s16 <= x_119 + 1, s17 >= 0, s17 <= x_212 + 1, s18 >= 0, s18 <= s16 + s17 + 1, s19 >= 0, s19 <= s18 + 1, x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 5 + 2*s1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s3 :|: s1 >= 0, s1 <= x_1 + 1, s2 >= 0, s2 <= x_2 + 1, s3 >= 0, s3 <= s1 + s2 + 1, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 2 + 5*x_117 + 2*x_117^2 + 5*x_211 + 2*x_211^2 }-> s30 :|: s27 >= 0, s27 <= x_117 + 1, s28 >= 0, s28 <= x_211 + 1, s29 >= 0, s29 <= s27, s30 >= 0, s30 <= s29 + 1, x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s9 :|: s7 >= 0, s7 <= x_1 + 1, s8 >= 0, s8 <= x_2 + 1, s9 >= 0, s9 <= s7, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 1 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s12 :|: s10 >= 0, s10 <= z + 1, s11 >= 0, s11 <= z' + 1, s12 >= 0, s12 <= s10, z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 5 + 2*s4 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s6 :|: s4 >= 0, s4 <= z + 1, s5 >= 0, s5 <= z' + 1, s6 >= 0, s6 <= s4 + s5 + 1, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ -1 + z + 2*z^2 }-> s22 :|: s20 >= 0, s20 <= z - 1 + 1, s21 >= 0, s21 <= s20 + 1, s22 >= 0, s22 <= s21 + 1, z - 1 >= 0
   encode_not(z) -{ 6 + 2*s23 + 5*x_158 + 2*x_158^2 + 5*x_238 + 2*x_238^2 }-> s26 :|: s23 >= 0, s23 <= x_158 + 1, s24 >= 0, s24 <= x_238 + 1, s25 >= 0, s25 <= s23 + s24 + 1, s26 >= 0, s26 <= s25 + 1, z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 2 + 5*x_156 + 2*x_156^2 + 5*x_237 + 2*x_237^2 }-> s34 :|: s31 >= 0, s31 <= x_156 + 1, s32 >= 0, s32 <= x_237 + 1, s33 >= 0, s33 <= s31, s34 >= 0, s34 <= s33 + 1, x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]
  and: runtime: O(1) [1], size: O(n^1) [z]
  encArg: runtime: O(n^2) [5*z + 2*z^2], size: O(n^1) [1 + z]

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

(55) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: encode_not
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:

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ -3*z + 2*z^2 }-> s15 :|: s13 >= 0, s13 <= z - 2 + 1, s14 >= 0, s14 <= s13 + 1, s15 >= 0, s15 <= s14 + 1, z - 2 >= 0
   encArg(z) -{ 6 + 2*s16 + 5*x_119 + 2*x_119^2 + 5*x_212 + 2*x_212^2 }-> s19 :|: s16 >= 0, s16 <= x_119 + 1, s17 >= 0, s17 <= x_212 + 1, s18 >= 0, s18 <= s16 + s17 + 1, s19 >= 0, s19 <= s18 + 1, x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 5 + 2*s1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s3 :|: s1 >= 0, s1 <= x_1 + 1, s2 >= 0, s2 <= x_2 + 1, s3 >= 0, s3 <= s1 + s2 + 1, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 2 + 5*x_117 + 2*x_117^2 + 5*x_211 + 2*x_211^2 }-> s30 :|: s27 >= 0, s27 <= x_117 + 1, s28 >= 0, s28 <= x_211 + 1, s29 >= 0, s29 <= s27, s30 >= 0, s30 <= s29 + 1, x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s9 :|: s7 >= 0, s7 <= x_1 + 1, s8 >= 0, s8 <= x_2 + 1, s9 >= 0, s9 <= s7, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 1 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s12 :|: s10 >= 0, s10 <= z + 1, s11 >= 0, s11 <= z' + 1, s12 >= 0, s12 <= s10, z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 5 + 2*s4 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s6 :|: s4 >= 0, s4 <= z + 1, s5 >= 0, s5 <= z' + 1, s6 >= 0, s6 <= s4 + s5 + 1, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ -1 + z + 2*z^2 }-> s22 :|: s20 >= 0, s20 <= z - 1 + 1, s21 >= 0, s21 <= s20 + 1, s22 >= 0, s22 <= s21 + 1, z - 1 >= 0
   encode_not(z) -{ 6 + 2*s23 + 5*x_158 + 2*x_158^2 + 5*x_238 + 2*x_238^2 }-> s26 :|: s23 >= 0, s23 <= x_158 + 1, s24 >= 0, s24 <= x_238 + 1, s25 >= 0, s25 <= s23 + s24 + 1, s26 >= 0, s26 <= s25 + 1, z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 2 + 5*x_156 + 2*x_156^2 + 5*x_237 + 2*x_237^2 }-> s34 :|: s31 >= 0, s31 <= x_156 + 1, s32 >= 0, s32 <= x_237 + 1, s33 >= 0, s33 <= s31, s34 >= 0, s34 <= s33 + 1, x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_not}, {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]
  and: runtime: O(1) [1], size: O(n^1) [z]
  encArg: runtime: O(n^2) [5*z + 2*z^2], size: O(n^1) [1 + z]
  encode_not: runtime: ?, size: O(n^1) [3 + z]

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ -3*z + 2*z^2 }-> s15 :|: s13 >= 0, s13 <= z - 2 + 1, s14 >= 0, s14 <= s13 + 1, s15 >= 0, s15 <= s14 + 1, z - 2 >= 0
   encArg(z) -{ 6 + 2*s16 + 5*x_119 + 2*x_119^2 + 5*x_212 + 2*x_212^2 }-> s19 :|: s16 >= 0, s16 <= x_119 + 1, s17 >= 0, s17 <= x_212 + 1, s18 >= 0, s18 <= s16 + s17 + 1, s19 >= 0, s19 <= s18 + 1, x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 5 + 2*s1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s3 :|: s1 >= 0, s1 <= x_1 + 1, s2 >= 0, s2 <= x_2 + 1, s3 >= 0, s3 <= s1 + s2 + 1, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 2 + 5*x_117 + 2*x_117^2 + 5*x_211 + 2*x_211^2 }-> s30 :|: s27 >= 0, s27 <= x_117 + 1, s28 >= 0, s28 <= x_211 + 1, s29 >= 0, s29 <= s27, s30 >= 0, s30 <= s29 + 1, x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s9 :|: s7 >= 0, s7 <= x_1 + 1, s8 >= 0, s8 <= x_2 + 1, s9 >= 0, s9 <= s7, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 1 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s12 :|: s10 >= 0, s10 <= z + 1, s11 >= 0, s11 <= z' + 1, s12 >= 0, s12 <= s10, z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 5 + 2*s4 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s6 :|: s4 >= 0, s4 <= z + 1, s5 >= 0, s5 <= z' + 1, s6 >= 0, s6 <= s4 + s5 + 1, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ -1 + z + 2*z^2 }-> s22 :|: s20 >= 0, s20 <= z - 1 + 1, s21 >= 0, s21 <= s20 + 1, s22 >= 0, s22 <= s21 + 1, z - 1 >= 0
   encode_not(z) -{ 6 + 2*s23 + 5*x_158 + 2*x_158^2 + 5*x_238 + 2*x_238^2 }-> s26 :|: s23 >= 0, s23 <= x_158 + 1, s24 >= 0, s24 <= x_238 + 1, s25 >= 0, s25 <= s23 + s24 + 1, s26 >= 0, s26 <= s25 + 1, z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 2 + 5*x_156 + 2*x_156^2 + 5*x_237 + 2*x_237^2 }-> s34 :|: s31 >= 0, s31 <= x_156 + 1, s32 >= 0, s32 <= x_237 + 1, s33 >= 0, s33 <= s31, s34 >= 0, s34 <= s33 + 1, x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]
  and: runtime: O(1) [1], size: O(n^1) [z]
  encArg: runtime: O(n^2) [5*z + 2*z^2], size: O(n^1) [1 + z]
  encode_not: runtime: O(n^2) [10 + 23*z + 10*z^2], 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:

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ -3*z + 2*z^2 }-> s15 :|: s13 >= 0, s13 <= z - 2 + 1, s14 >= 0, s14 <= s13 + 1, s15 >= 0, s15 <= s14 + 1, z - 2 >= 0
   encArg(z) -{ 6 + 2*s16 + 5*x_119 + 2*x_119^2 + 5*x_212 + 2*x_212^2 }-> s19 :|: s16 >= 0, s16 <= x_119 + 1, s17 >= 0, s17 <= x_212 + 1, s18 >= 0, s18 <= s16 + s17 + 1, s19 >= 0, s19 <= s18 + 1, x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 5 + 2*s1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s3 :|: s1 >= 0, s1 <= x_1 + 1, s2 >= 0, s2 <= x_2 + 1, s3 >= 0, s3 <= s1 + s2 + 1, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 2 + 5*x_117 + 2*x_117^2 + 5*x_211 + 2*x_211^2 }-> s30 :|: s27 >= 0, s27 <= x_117 + 1, s28 >= 0, s28 <= x_211 + 1, s29 >= 0, s29 <= s27, s30 >= 0, s30 <= s29 + 1, x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s9 :|: s7 >= 0, s7 <= x_1 + 1, s8 >= 0, s8 <= x_2 + 1, s9 >= 0, s9 <= s7, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 1 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s12 :|: s10 >= 0, s10 <= z + 1, s11 >= 0, s11 <= z' + 1, s12 >= 0, s12 <= s10, z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 5 + 2*s4 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s6 :|: s4 >= 0, s4 <= z + 1, s5 >= 0, s5 <= z' + 1, s6 >= 0, s6 <= s4 + s5 + 1, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ -1 + z + 2*z^2 }-> s22 :|: s20 >= 0, s20 <= z - 1 + 1, s21 >= 0, s21 <= s20 + 1, s22 >= 0, s22 <= s21 + 1, z - 1 >= 0
   encode_not(z) -{ 6 + 2*s23 + 5*x_158 + 2*x_158^2 + 5*x_238 + 2*x_238^2 }-> s26 :|: s23 >= 0, s23 <= x_158 + 1, s24 >= 0, s24 <= x_238 + 1, s25 >= 0, s25 <= s23 + s24 + 1, s26 >= 0, s26 <= s25 + 1, z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 2 + 5*x_156 + 2*x_156^2 + 5*x_237 + 2*x_237^2 }-> s34 :|: s31 >= 0, s31 <= x_156 + 1, s32 >= 0, s32 <= x_237 + 1, s33 >= 0, s33 <= s31, s34 >= 0, s34 <= s33 + 1, x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]
  and: runtime: O(1) [1], size: O(n^1) [z]
  encArg: runtime: O(n^2) [5*z + 2*z^2], size: O(n^1) [1 + z]
  encode_not: runtime: O(n^2) [10 + 23*z + 10*z^2], size: O(n^1) [3 + z]

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

(61) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ -3*z + 2*z^2 }-> s15 :|: s13 >= 0, s13 <= z - 2 + 1, s14 >= 0, s14 <= s13 + 1, s15 >= 0, s15 <= s14 + 1, z - 2 >= 0
   encArg(z) -{ 6 + 2*s16 + 5*x_119 + 2*x_119^2 + 5*x_212 + 2*x_212^2 }-> s19 :|: s16 >= 0, s16 <= x_119 + 1, s17 >= 0, s17 <= x_212 + 1, s18 >= 0, s18 <= s16 + s17 + 1, s19 >= 0, s19 <= s18 + 1, x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 5 + 2*s1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s3 :|: s1 >= 0, s1 <= x_1 + 1, s2 >= 0, s2 <= x_2 + 1, s3 >= 0, s3 <= s1 + s2 + 1, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 2 + 5*x_117 + 2*x_117^2 + 5*x_211 + 2*x_211^2 }-> s30 :|: s27 >= 0, s27 <= x_117 + 1, s28 >= 0, s28 <= x_211 + 1, s29 >= 0, s29 <= s27, s30 >= 0, s30 <= s29 + 1, x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s9 :|: s7 >= 0, s7 <= x_1 + 1, s8 >= 0, s8 <= x_2 + 1, s9 >= 0, s9 <= s7, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 1 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s12 :|: s10 >= 0, s10 <= z + 1, s11 >= 0, s11 <= z' + 1, s12 >= 0, s12 <= s10, z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 5 + 2*s4 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s6 :|: s4 >= 0, s4 <= z + 1, s5 >= 0, s5 <= z' + 1, s6 >= 0, s6 <= s4 + s5 + 1, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ -1 + z + 2*z^2 }-> s22 :|: s20 >= 0, s20 <= z - 1 + 1, s21 >= 0, s21 <= s20 + 1, s22 >= 0, s22 <= s21 + 1, z - 1 >= 0
   encode_not(z) -{ 6 + 2*s23 + 5*x_158 + 2*x_158^2 + 5*x_238 + 2*x_238^2 }-> s26 :|: s23 >= 0, s23 <= x_158 + 1, s24 >= 0, s24 <= x_238 + 1, s25 >= 0, s25 <= s23 + s24 + 1, s26 >= 0, s26 <= s25 + 1, z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 2 + 5*x_156 + 2*x_156^2 + 5*x_237 + 2*x_237^2 }-> s34 :|: s31 >= 0, s31 <= x_156 + 1, s32 >= 0, s32 <= x_237 + 1, s33 >= 0, s33 <= s31, s34 >= 0, s34 <= s33 + 1, x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_and}, {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]
  and: runtime: O(1) [1], size: O(n^1) [z]
  encArg: runtime: O(n^2) [5*z + 2*z^2], size: O(n^1) [1 + z]
  encode_not: runtime: O(n^2) [10 + 23*z + 10*z^2], size: O(n^1) [3 + z]
  encode_and: runtime: ?, size: O(n^1) [1 + z]

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

(63) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ -3*z + 2*z^2 }-> s15 :|: s13 >= 0, s13 <= z - 2 + 1, s14 >= 0, s14 <= s13 + 1, s15 >= 0, s15 <= s14 + 1, z - 2 >= 0
   encArg(z) -{ 6 + 2*s16 + 5*x_119 + 2*x_119^2 + 5*x_212 + 2*x_212^2 }-> s19 :|: s16 >= 0, s16 <= x_119 + 1, s17 >= 0, s17 <= x_212 + 1, s18 >= 0, s18 <= s16 + s17 + 1, s19 >= 0, s19 <= s18 + 1, x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 5 + 2*s1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s3 :|: s1 >= 0, s1 <= x_1 + 1, s2 >= 0, s2 <= x_2 + 1, s3 >= 0, s3 <= s1 + s2 + 1, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 2 + 5*x_117 + 2*x_117^2 + 5*x_211 + 2*x_211^2 }-> s30 :|: s27 >= 0, s27 <= x_117 + 1, s28 >= 0, s28 <= x_211 + 1, s29 >= 0, s29 <= s27, s30 >= 0, s30 <= s29 + 1, x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s9 :|: s7 >= 0, s7 <= x_1 + 1, s8 >= 0, s8 <= x_2 + 1, s9 >= 0, s9 <= s7, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 1 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s12 :|: s10 >= 0, s10 <= z + 1, s11 >= 0, s11 <= z' + 1, s12 >= 0, s12 <= s10, z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 5 + 2*s4 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s6 :|: s4 >= 0, s4 <= z + 1, s5 >= 0, s5 <= z' + 1, s6 >= 0, s6 <= s4 + s5 + 1, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ -1 + z + 2*z^2 }-> s22 :|: s20 >= 0, s20 <= z - 1 + 1, s21 >= 0, s21 <= s20 + 1, s22 >= 0, s22 <= s21 + 1, z - 1 >= 0
   encode_not(z) -{ 6 + 2*s23 + 5*x_158 + 2*x_158^2 + 5*x_238 + 2*x_238^2 }-> s26 :|: s23 >= 0, s23 <= x_158 + 1, s24 >= 0, s24 <= x_238 + 1, s25 >= 0, s25 <= s23 + s24 + 1, s26 >= 0, s26 <= s25 + 1, z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 2 + 5*x_156 + 2*x_156^2 + 5*x_237 + 2*x_237^2 }-> s34 :|: s31 >= 0, s31 <= x_156 + 1, s32 >= 0, s32 <= x_237 + 1, s33 >= 0, s33 <= s31, s34 >= 0, s34 <= s33 + 1, x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]
  and: runtime: O(1) [1], size: O(n^1) [z]
  encArg: runtime: O(n^2) [5*z + 2*z^2], size: O(n^1) [1 + z]
  encode_not: runtime: O(n^2) [10 + 23*z + 10*z^2], size: O(n^1) [3 + z]
  encode_and: runtime: O(n^2) [1 + 5*z + 2*z^2 + 5*z' + 2*z'^2], size: O(n^1) [1 + 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:

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ -3*z + 2*z^2 }-> s15 :|: s13 >= 0, s13 <= z - 2 + 1, s14 >= 0, s14 <= s13 + 1, s15 >= 0, s15 <= s14 + 1, z - 2 >= 0
   encArg(z) -{ 6 + 2*s16 + 5*x_119 + 2*x_119^2 + 5*x_212 + 2*x_212^2 }-> s19 :|: s16 >= 0, s16 <= x_119 + 1, s17 >= 0, s17 <= x_212 + 1, s18 >= 0, s18 <= s16 + s17 + 1, s19 >= 0, s19 <= s18 + 1, x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 5 + 2*s1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s3 :|: s1 >= 0, s1 <= x_1 + 1, s2 >= 0, s2 <= x_2 + 1, s3 >= 0, s3 <= s1 + s2 + 1, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 2 + 5*x_117 + 2*x_117^2 + 5*x_211 + 2*x_211^2 }-> s30 :|: s27 >= 0, s27 <= x_117 + 1, s28 >= 0, s28 <= x_211 + 1, s29 >= 0, s29 <= s27, s30 >= 0, s30 <= s29 + 1, x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s9 :|: s7 >= 0, s7 <= x_1 + 1, s8 >= 0, s8 <= x_2 + 1, s9 >= 0, s9 <= s7, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 1 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s12 :|: s10 >= 0, s10 <= z + 1, s11 >= 0, s11 <= z' + 1, s12 >= 0, s12 <= s10, z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 5 + 2*s4 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s6 :|: s4 >= 0, s4 <= z + 1, s5 >= 0, s5 <= z' + 1, s6 >= 0, s6 <= s4 + s5 + 1, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ -1 + z + 2*z^2 }-> s22 :|: s20 >= 0, s20 <= z - 1 + 1, s21 >= 0, s21 <= s20 + 1, s22 >= 0, s22 <= s21 + 1, z - 1 >= 0
   encode_not(z) -{ 6 + 2*s23 + 5*x_158 + 2*x_158^2 + 5*x_238 + 2*x_238^2 }-> s26 :|: s23 >= 0, s23 <= x_158 + 1, s24 >= 0, s24 <= x_238 + 1, s25 >= 0, s25 <= s23 + s24 + 1, s26 >= 0, s26 <= s25 + 1, z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 2 + 5*x_156 + 2*x_156^2 + 5*x_237 + 2*x_237^2 }-> s34 :|: s31 >= 0, s31 <= x_156 + 1, s32 >= 0, s32 <= x_237 + 1, s33 >= 0, s33 <= s31, s34 >= 0, s34 <= s33 + 1, x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]
  and: runtime: O(1) [1], size: O(n^1) [z]
  encArg: runtime: O(n^2) [5*z + 2*z^2], size: O(n^1) [1 + z]
  encode_not: runtime: O(n^2) [10 + 23*z + 10*z^2], size: O(n^1) [3 + z]
  encode_and: runtime: O(n^2) [1 + 5*z + 2*z^2 + 5*z' + 2*z'^2], size: O(n^1) [1 + z]

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

(67) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ -3*z + 2*z^2 }-> s15 :|: s13 >= 0, s13 <= z - 2 + 1, s14 >= 0, s14 <= s13 + 1, s15 >= 0, s15 <= s14 + 1, z - 2 >= 0
   encArg(z) -{ 6 + 2*s16 + 5*x_119 + 2*x_119^2 + 5*x_212 + 2*x_212^2 }-> s19 :|: s16 >= 0, s16 <= x_119 + 1, s17 >= 0, s17 <= x_212 + 1, s18 >= 0, s18 <= s16 + s17 + 1, s19 >= 0, s19 <= s18 + 1, x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 5 + 2*s1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s3 :|: s1 >= 0, s1 <= x_1 + 1, s2 >= 0, s2 <= x_2 + 1, s3 >= 0, s3 <= s1 + s2 + 1, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 2 + 5*x_117 + 2*x_117^2 + 5*x_211 + 2*x_211^2 }-> s30 :|: s27 >= 0, s27 <= x_117 + 1, s28 >= 0, s28 <= x_211 + 1, s29 >= 0, s29 <= s27, s30 >= 0, s30 <= s29 + 1, x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s9 :|: s7 >= 0, s7 <= x_1 + 1, s8 >= 0, s8 <= x_2 + 1, s9 >= 0, s9 <= s7, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 1 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s12 :|: s10 >= 0, s10 <= z + 1, s11 >= 0, s11 <= z' + 1, s12 >= 0, s12 <= s10, z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 5 + 2*s4 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s6 :|: s4 >= 0, s4 <= z + 1, s5 >= 0, s5 <= z' + 1, s6 >= 0, s6 <= s4 + s5 + 1, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ -1 + z + 2*z^2 }-> s22 :|: s20 >= 0, s20 <= z - 1 + 1, s21 >= 0, s21 <= s20 + 1, s22 >= 0, s22 <= s21 + 1, z - 1 >= 0
   encode_not(z) -{ 6 + 2*s23 + 5*x_158 + 2*x_158^2 + 5*x_238 + 2*x_238^2 }-> s26 :|: s23 >= 0, s23 <= x_158 + 1, s24 >= 0, s24 <= x_238 + 1, s25 >= 0, s25 <= s23 + s24 + 1, s26 >= 0, s26 <= s25 + 1, z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 2 + 5*x_156 + 2*x_156^2 + 5*x_237 + 2*x_237^2 }-> s34 :|: s31 >= 0, s31 <= x_156 + 1, s32 >= 0, s32 <= x_237 + 1, s33 >= 0, s33 <= s31, s34 >= 0, s34 <= s33 + 1, x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {encode_implies}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]
  and: runtime: O(1) [1], size: O(n^1) [z]
  encArg: runtime: O(n^2) [5*z + 2*z^2], size: O(n^1) [1 + z]
  encode_not: runtime: O(n^2) [10 + 23*z + 10*z^2], size: O(n^1) [3 + z]
  encode_and: runtime: O(n^2) [1 + 5*z + 2*z^2 + 5*z' + 2*z'^2], size: O(n^1) [1 + z]
  encode_implies: runtime: ?, size: O(n^1) [3 + z + z']

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

(69) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   and(z, z') -{ 1 }-> z :|: z >= 0, z' = 1 + 0
   and(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encArg(z) -{ -3*z + 2*z^2 }-> s15 :|: s13 >= 0, s13 <= z - 2 + 1, s14 >= 0, s14 <= s13 + 1, s15 >= 0, s15 <= s14 + 1, z - 2 >= 0
   encArg(z) -{ 6 + 2*s16 + 5*x_119 + 2*x_119^2 + 5*x_212 + 2*x_212^2 }-> s19 :|: s16 >= 0, s16 <= x_119 + 1, s17 >= 0, s17 <= x_212 + 1, s18 >= 0, s18 <= s16 + s17 + 1, s19 >= 0, s19 <= s18 + 1, x_212 >= 0, z = 1 + (1 + x_119 + x_212), x_119 >= 0
   encArg(z) -{ 5 + 2*s1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s3 :|: s1 >= 0, s1 <= x_1 + 1, s2 >= 0, s2 <= x_2 + 1, s3 >= 0, s3 <= s1 + s2 + 1, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 2 + 5*x_117 + 2*x_117^2 + 5*x_211 + 2*x_211^2 }-> s30 :|: s27 >= 0, s27 <= x_117 + 1, s28 >= 0, s28 <= x_211 + 1, s29 >= 0, s29 <= s27, s30 >= 0, s30 <= s29 + 1, x_117 >= 0, z = 1 + (1 + x_117 + x_211), x_211 >= 0
   encArg(z) -{ 1 + 5*x_1 + 2*x_1^2 + 5*x_2 + 2*x_2^2 }-> s9 :|: s7 >= 0, s7 <= x_1 + 1, s8 >= 0, s8 <= x_2 + 1, s9 >= 0, s9 <= s7, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 1 + 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, 0 = v0
   encArg(z) -{ 0 }-> 1 + x0 :|: z = 1 + 0, 0 = x0, x0 >= 0
   encArg(z) -{ 0 }-> 1 + x0 :|: z - 1 >= 0, 0 = x0, x0 >= 0
   encode_and(z, z') -{ 1 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s12 :|: s10 >= 0, s10 <= z + 1, s11 >= 0, s11 <= z' + 1, s12 >= 0, s12 <= s10, z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_false -{ 0 }-> 0 :|: 
   encode_implies(z, z') -{ 5 + 2*s4 + 5*z + 2*z^2 + 5*z' + 2*z'^2 }-> s6 :|: s4 >= 0, s4 <= z + 1, s5 >= 0, s5 <= z' + 1, s6 >= 0, s6 <= s4 + s5 + 1, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ -1 + z + 2*z^2 }-> s22 :|: s20 >= 0, s20 <= z - 1 + 1, s21 >= 0, s21 <= s20 + 1, s22 >= 0, s22 <= s21 + 1, z - 1 >= 0
   encode_not(z) -{ 6 + 2*s23 + 5*x_158 + 2*x_158^2 + 5*x_238 + 2*x_238^2 }-> s26 :|: s23 >= 0, s23 <= x_158 + 1, s24 >= 0, s24 <= x_238 + 1, s25 >= 0, s25 <= s23 + s24 + 1, s26 >= 0, s26 <= s25 + 1, z = 1 + x_158 + x_238, x_158 >= 0, x_238 >= 0
   encode_not(z) -{ 2 + 5*x_156 + 2*x_156^2 + 5*x_237 + 2*x_237^2 }-> s34 :|: s31 >= 0, s31 <= x_156 + 1, s32 >= 0, s32 <= x_237 + 1, s33 >= 0, s33 <= s31, s34 >= 0, s34 <= s33 + 1, x_237 >= 0, x_156 >= 0, z = 1 + x_156 + x_237
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 0 }-> 0 :|: z = 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0, v0 >= 0, 0 = v0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z = 0, 0 = x0, x0 >= 0
   encode_not(z) -{ 0 }-> 1 + x0 :|: z >= 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 7 }-> s :|: s >= 0, s <= 0 + 0 + 1, z - 1 >= 0, z' = 1 + 0
   implies(z, z') -{ 9 }-> s' :|: s' >= 0, s' <= 1 + 0 + (z - 1) + 1, z' = 1 + (1 + 0), z - 1 >= 0
   implies(z, z') -{ 4 + 2*z' }-> s'' :|: s'' >= 0, s'' <= z' - 1 + 0 + 1, z - 1 >= 0, z' - 1 >= 0
   implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0, v0 >= 0, 0 = v0
   implies(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   implies(z, z') -{ 2 }-> z - 1 :|: z >= 0, z' = 0, z - 1 >= 0
   implies(z, z') -{ 1 }-> 1 + x0 :|: z' >= 0, z = 0, 0 = x0, x0 >= 0
   implies(z, z') -{ 1 }-> 1 + z :|: z >= 0, z' = 0
   not(z) -{ 0 }-> 0 :|: z >= 0
   not(z) -{ 1 }-> z - 1 :|: z - 1 >= 0
   not(z) -{ 0 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: 
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(n^1) [5 + 2*z], size: O(n^1) [1 + z + z']
  encode_false: runtime: O(1) [0], size: O(1) [0]
  and: runtime: O(1) [1], size: O(n^1) [z]
  encArg: runtime: O(n^2) [5*z + 2*z^2], size: O(n^1) [1 + z]
  encode_not: runtime: O(n^2) [10 + 23*z + 10*z^2], size: O(n^1) [3 + z]
  encode_and: runtime: O(n^2) [1 + 5*z + 2*z^2 + 5*z' + 2*z'^2], size: O(n^1) [1 + z]
  encode_implies: runtime: O(n^2) [7 + 7*z + 2*z^2 + 5*z' + 2*z'^2], size: O(n^1) [3 + z + z']

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

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

(72)
BOUNDS(1, n^2)

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

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

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


The TRS R consists of the following rules:

   and(x, false) -> false
   and(x, not(false)) -> x
   not(not(x)) -> x
   implies(false, y) -> not(false)
   implies(x, false) -> not(x)
   implies(not(x), not(y)) -> implies(y, and(x, y))

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

   encArg(false) -> false
   encArg(cons_and(x_1, x_2)) -> and(encArg(x_1), encArg(x_2))
   encArg(cons_not(x_1)) -> not(encArg(x_1))
   encArg(cons_implies(x_1, x_2)) -> implies(encArg(x_1), encArg(x_2))
   encode_and(x_1, x_2) -> and(encArg(x_1), encArg(x_2))
   encode_false -> false
   encode_not(x_1) -> not(encArg(x_1))
   encode_implies(x_1, x_2) -> implies(encArg(x_1), encArg(x_2))

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

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

(76)
Obligation:
Innermost TRS:
Rules:
and(x, false) -> false
and(x, not(false)) -> x
not(not(x)) -> x
implies(false, y) -> not(false)
implies(x, false) -> not(x)
implies(not(x), not(y)) -> implies(y, and(x, y))
encArg(false) -> false
encArg(cons_and(x_1, x_2)) -> and(encArg(x_1), encArg(x_2))
encArg(cons_not(x_1)) -> not(encArg(x_1))
encArg(cons_implies(x_1, x_2)) -> implies(encArg(x_1), encArg(x_2))
encode_and(x_1, x_2) -> and(encArg(x_1), encArg(x_2))
encode_false -> false
encode_not(x_1) -> not(encArg(x_1))
encode_implies(x_1, x_2) -> implies(encArg(x_1), encArg(x_2))

Types:
and :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
false :: false:cons_and:cons_not:cons_implies
not :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
implies :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
encArg :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
cons_and :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
cons_not :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
cons_implies :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
encode_and :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
encode_false :: false:cons_and:cons_not:cons_implies
encode_not :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
encode_implies :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
hole_false:cons_and:cons_not:cons_implies1_0 :: false:cons_and:cons_not:cons_implies
gen_false:cons_and:cons_not:cons_implies2_0 :: Nat -> false:cons_and:cons_not:cons_implies

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

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

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

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

(78)
Obligation:
Innermost TRS:
Rules:
and(x, false) -> false
and(x, not(false)) -> x
not(not(x)) -> x
implies(false, y) -> not(false)
implies(x, false) -> not(x)
implies(not(x), not(y)) -> implies(y, and(x, y))
encArg(false) -> false
encArg(cons_and(x_1, x_2)) -> and(encArg(x_1), encArg(x_2))
encArg(cons_not(x_1)) -> not(encArg(x_1))
encArg(cons_implies(x_1, x_2)) -> implies(encArg(x_1), encArg(x_2))
encode_and(x_1, x_2) -> and(encArg(x_1), encArg(x_2))
encode_false -> false
encode_not(x_1) -> not(encArg(x_1))
encode_implies(x_1, x_2) -> implies(encArg(x_1), encArg(x_2))

Types:
and :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
false :: false:cons_and:cons_not:cons_implies
not :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
implies :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
encArg :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
cons_and :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
cons_not :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
cons_implies :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
encode_and :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
encode_false :: false:cons_and:cons_not:cons_implies
encode_not :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
encode_implies :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
hole_false:cons_and:cons_not:cons_implies1_0 :: false:cons_and:cons_not:cons_implies
gen_false:cons_and:cons_not:cons_implies2_0 :: Nat -> false:cons_and:cons_not:cons_implies


Generator Equations:
gen_false:cons_and:cons_not:cons_implies2_0(0) <=> false
gen_false:cons_and:cons_not:cons_implies2_0(+(x, 1)) <=> cons_and(false, gen_false:cons_and:cons_not:cons_implies2_0(x))


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

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

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

(79) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
encArg(gen_false:cons_and:cons_not:cons_implies2_0(n17_0)) -> gen_false:cons_and:cons_not:cons_implies2_0(0), rt in Omega(n17_0)

Induction Base:
encArg(gen_false:cons_and:cons_not:cons_implies2_0(0)) ->_R^Omega(0)
false

Induction Step:
encArg(gen_false:cons_and:cons_not:cons_implies2_0(+(n17_0, 1))) ->_R^Omega(0)
and(encArg(false), encArg(gen_false:cons_and:cons_not:cons_implies2_0(n17_0))) ->_R^Omega(0)
and(false, encArg(gen_false:cons_and:cons_not:cons_implies2_0(n17_0))) ->_IH
and(false, gen_false:cons_and:cons_not:cons_implies2_0(0)) ->_R^Omega(1)
false

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

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

Innermost TRS:
Rules:
and(x, false) -> false
and(x, not(false)) -> x
not(not(x)) -> x
implies(false, y) -> not(false)
implies(x, false) -> not(x)
implies(not(x), not(y)) -> implies(y, and(x, y))
encArg(false) -> false
encArg(cons_and(x_1, x_2)) -> and(encArg(x_1), encArg(x_2))
encArg(cons_not(x_1)) -> not(encArg(x_1))
encArg(cons_implies(x_1, x_2)) -> implies(encArg(x_1), encArg(x_2))
encode_and(x_1, x_2) -> and(encArg(x_1), encArg(x_2))
encode_false -> false
encode_not(x_1) -> not(encArg(x_1))
encode_implies(x_1, x_2) -> implies(encArg(x_1), encArg(x_2))

Types:
and :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
false :: false:cons_and:cons_not:cons_implies
not :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
implies :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
encArg :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
cons_and :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
cons_not :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
cons_implies :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
encode_and :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
encode_false :: false:cons_and:cons_not:cons_implies
encode_not :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
encode_implies :: false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies -> false:cons_and:cons_not:cons_implies
hole_false:cons_and:cons_not:cons_implies1_0 :: false:cons_and:cons_not:cons_implies
gen_false:cons_and:cons_not:cons_implies2_0 :: Nat -> false:cons_and:cons_not:cons_implies


Generator Equations:
gen_false:cons_and:cons_not:cons_implies2_0(0) <=> false
gen_false:cons_and:cons_not:cons_implies2_0(+(x, 1)) <=> cons_and(false, gen_false:cons_and:cons_not:cons_implies2_0(x))


The following defined symbols remain to be analysed:
encArg
----------------------------------------

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

(82)
BOUNDS(n^1, INF)