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


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


WORST_CASE(?, O(n^1))
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(1, n^1).

(0) DCpxTrs
(1) DerivationalComplexityToRuntimeComplexityProof [BOTH BOUNDS(ID, ID), 0 ms]
(2) CpxRelTRS
(3) SInnermostTerminationProof [BOTH CONCRETE BOUNDS(ID, ID), 254 ms]
(4) CpxRelTRS
(5) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
(6) CpxWeightedTrs
(7) CpxWeightedTrsRenamingProof [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), 129 ms]
(14) CpxTypedWeightedCompleteTrs
(15) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
(16) CpxRNTS
(17) InliningProof [UPPER BOUND(ID), 81 ms]
(18) CpxRNTS
(19) SimplificationProof [BOTH BOUNDS(ID, ID), 1 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), 152 ms]
(26) CpxRNTS
(27) IntTrsBoundProof [UPPER BOUND(ID), 24 ms]
(28) CpxRNTS
(29) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(30) CpxRNTS
(31) IntTrsBoundProof [UPPER BOUND(ID), 119 ms]
(32) CpxRNTS
(33) IntTrsBoundProof [UPPER BOUND(ID), 22 ms]
(34) CpxRNTS
(35) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(36) CpxRNTS
(37) IntTrsBoundProof [UPPER BOUND(ID), 108 ms]
(38) CpxRNTS
(39) IntTrsBoundProof [UPPER BOUND(ID), 55 ms]
(40) CpxRNTS
(41) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(42) CpxRNTS
(43) IntTrsBoundProof [UPPER BOUND(ID), 46 ms]
(44) CpxRNTS
(45) IntTrsBoundProof [UPPER BOUND(ID), 3 ms]
(46) CpxRNTS
(47) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(48) CpxRNTS
(49) IntTrsBoundProof [UPPER BOUND(ID), 150 ms]
(50) CpxRNTS
(51) IntTrsBoundProof [UPPER BOUND(ID), 41 ms]
(52) CpxRNTS
(53) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(54) CpxRNTS
(55) IntTrsBoundProof [UPPER BOUND(ID), 6296 ms]
(56) CpxRNTS
(57) IntTrsBoundProof [UPPER BOUND(ID), 472 ms]
(58) CpxRNTS
(59) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(60) CpxRNTS
(61) IntTrsBoundProof [UPPER BOUND(ID), 728 ms]
(62) CpxRNTS
(63) IntTrsBoundProof [UPPER BOUND(ID), 63 ms]
(64) CpxRNTS
(65) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(66) CpxRNTS
(67) IntTrsBoundProof [UPPER BOUND(ID), 739 ms]
(68) CpxRNTS
(69) IntTrsBoundProof [UPPER BOUND(ID), 73 ms]
(70) CpxRNTS
(71) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(72) CpxRNTS
(73) IntTrsBoundProof [UPPER BOUND(ID), 708 ms]
(74) CpxRNTS
(75) IntTrsBoundProof [UPPER BOUND(ID), 63 ms]
(76) CpxRNTS
(77) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(78) CpxRNTS
(79) IntTrsBoundProof [UPPER BOUND(ID), 1148 ms]
(80) CpxRNTS
(81) IntTrsBoundProof [UPPER BOUND(ID), 290 ms]
(82) CpxRNTS
(83) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(84) CpxRNTS
(85) IntTrsBoundProof [UPPER BOUND(ID), 727 ms]
(86) CpxRNTS
(87) IntTrsBoundProof [UPPER BOUND(ID), 62 ms]
(88) CpxRNTS
(89) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(90) CpxRNTS
(91) IntTrsBoundProof [UPPER BOUND(ID), 677 ms]
(92) CpxRNTS
(93) IntTrsBoundProof [UPPER BOUND(ID), 63 ms]
(94) CpxRNTS
(95) FinalProof [FINISHED, 0 ms]
(96) BOUNDS(1, n^1)


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

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


The TRS R consists of the following rules:

   not(x) -> xor(x, true)
   implies(x, y) -> xor(and(x, y), xor(x, true))
   or(x, y) -> xor(and(x, y), xor(x, y))
   =(x, y) -> xor(x, xor(y, true))

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(xor(x_1, x_2)) -> xor(encArg(x_1), encArg(x_2))
   encArg(true) -> true
   encArg(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))
   encArg(cons_or(x_1, x_2)) -> or(encArg(x_1), encArg(x_2))
   encArg(cons_=(x_1, x_2)) -> =(encArg(x_1), encArg(x_2))
   encode_not(x_1) -> not(encArg(x_1))
   encode_xor(x_1, x_2) -> xor(encArg(x_1), encArg(x_2))
   encode_true -> true
   encode_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_or(x_1, x_2) -> or(encArg(x_1), encArg(x_2))
   encode_=(x_1, x_2) -> =(encArg(x_1), encArg(x_2))


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

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


The TRS R consists of the following rules:

   not(x) -> xor(x, true)
   implies(x, y) -> xor(and(x, y), xor(x, true))
   or(x, y) -> xor(and(x, y), xor(x, y))
   =(x, y) -> xor(x, xor(y, true))

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

   encArg(xor(x_1, x_2)) -> xor(encArg(x_1), encArg(x_2))
   encArg(true) -> true
   encArg(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))
   encArg(cons_or(x_1, x_2)) -> or(encArg(x_1), encArg(x_2))
   encArg(cons_=(x_1, x_2)) -> =(encArg(x_1), encArg(x_2))
   encode_not(x_1) -> not(encArg(x_1))
   encode_xor(x_1, x_2) -> xor(encArg(x_1), encArg(x_2))
   encode_true -> true
   encode_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_or(x_1, x_2) -> or(encArg(x_1), encArg(x_2))
   encode_=(x_1, x_2) -> =(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(1, n^1).


The TRS R consists of the following rules:

   not(x) -> xor(x, true)
   implies(x, y) -> xor(and(x, y), xor(x, true))
   or(x, y) -> xor(and(x, y), xor(x, y))
   =(x, y) -> xor(x, xor(y, true))

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

   encArg(xor(x_1, x_2)) -> xor(encArg(x_1), encArg(x_2))
   encArg(true) -> true
   encArg(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))
   encArg(cons_or(x_1, x_2)) -> or(encArg(x_1), encArg(x_2))
   encArg(cons_=(x_1, x_2)) -> =(encArg(x_1), encArg(x_2))
   encode_not(x_1) -> not(encArg(x_1))
   encode_xor(x_1, x_2) -> xor(encArg(x_1), encArg(x_2))
   encode_true -> true
   encode_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_or(x_1, x_2) -> or(encArg(x_1), encArg(x_2))
   encode_=(x_1, x_2) -> =(encArg(x_1), encArg(x_2))

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

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

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


The TRS R consists of the following rules:

   not(x) -> xor(x, true) [1]
   implies(x, y) -> xor(and(x, y), xor(x, true)) [1]
   or(x, y) -> xor(and(x, y), xor(x, y)) [1]
   =(x, y) -> xor(x, xor(y, true)) [1]
   encArg(xor(x_1, x_2)) -> xor(encArg(x_1), encArg(x_2)) [0]
   encArg(true) -> true [0]
   encArg(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]
   encArg(cons_or(x_1, x_2)) -> or(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_=(x_1, x_2)) -> =(encArg(x_1), encArg(x_2)) [0]
   encode_not(x_1) -> not(encArg(x_1)) [0]
   encode_xor(x_1, x_2) -> xor(encArg(x_1), encArg(x_2)) [0]
   encode_true -> true [0]
   encode_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_or(x_1, x_2) -> or(encArg(x_1), encArg(x_2)) [0]
   encode_=(x_1, x_2) -> =(encArg(x_1), encArg(x_2)) [0]

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

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

= => eq

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

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


The TRS R consists of the following rules:

   not(x) -> xor(x, true) [1]
   implies(x, y) -> xor(and(x, y), xor(x, true)) [1]
   or(x, y) -> xor(and(x, y), xor(x, y)) [1]
   eq(x, y) -> xor(x, xor(y, true)) [1]
   encArg(xor(x_1, x_2)) -> xor(encArg(x_1), encArg(x_2)) [0]
   encArg(true) -> true [0]
   encArg(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]
   encArg(cons_or(x_1, x_2)) -> or(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_=(x_1, x_2)) -> eq(encArg(x_1), encArg(x_2)) [0]
   encode_not(x_1) -> not(encArg(x_1)) [0]
   encode_xor(x_1, x_2) -> xor(encArg(x_1), encArg(x_2)) [0]
   encode_true -> true [0]
   encode_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_or(x_1, x_2) -> or(encArg(x_1), encArg(x_2)) [0]
   encode_=(x_1, x_2) -> eq(encArg(x_1), encArg(x_2)) [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:

   not(x) -> xor(x, true) [1]
   implies(x, y) -> xor(and(x, y), xor(x, true)) [1]
   or(x, y) -> xor(and(x, y), xor(x, y)) [1]
   eq(x, y) -> xor(x, xor(y, true)) [1]
   encArg(xor(x_1, x_2)) -> xor(encArg(x_1), encArg(x_2)) [0]
   encArg(true) -> true [0]
   encArg(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]
   encArg(cons_or(x_1, x_2)) -> or(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_=(x_1, x_2)) -> eq(encArg(x_1), encArg(x_2)) [0]
   encode_not(x_1) -> not(encArg(x_1)) [0]
   encode_xor(x_1, x_2) -> xor(encArg(x_1), encArg(x_2)) [0]
   encode_true -> true [0]
   encode_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_or(x_1, x_2) -> or(encArg(x_1), encArg(x_2)) [0]
   encode_=(x_1, x_2) -> eq(encArg(x_1), encArg(x_2)) [0]

The TRS has the following type information:
not :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
xor :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
true :: true:xor:and:cons_not:cons_implies:cons_or:cons_=
implies :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
and :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
or :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
eq :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encArg :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
cons_not :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
cons_implies :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
cons_or :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
cons_= :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_not :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_xor :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_true :: true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_implies :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_and :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_or :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_= :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=

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:

   eq_2
   implies_2
   not_1
   or_2
   encArg_1
   encode_not_1
   encode_xor_2
   encode_true
   encode_implies_2
   encode_and_2
   encode_or_2
   encode_=_2

Due to the following rules being added:

   encArg(v0) -> true [0]
   encode_not(v0) -> true [0]
   encode_xor(v0, v1) -> true [0]
   encode_true -> true [0]
   encode_implies(v0, v1) -> true [0]
   encode_and(v0, v1) -> true [0]
   encode_or(v0, v1) -> true [0]
   encode_=(v0, v1) -> true [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:

   not(x) -> xor(x, true) [1]
   implies(x, y) -> xor(and(x, y), xor(x, true)) [1]
   or(x, y) -> xor(and(x, y), xor(x, y)) [1]
   eq(x, y) -> xor(x, xor(y, true)) [1]
   encArg(xor(x_1, x_2)) -> xor(encArg(x_1), encArg(x_2)) [0]
   encArg(true) -> true [0]
   encArg(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]
   encArg(cons_or(x_1, x_2)) -> or(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_=(x_1, x_2)) -> eq(encArg(x_1), encArg(x_2)) [0]
   encode_not(x_1) -> not(encArg(x_1)) [0]
   encode_xor(x_1, x_2) -> xor(encArg(x_1), encArg(x_2)) [0]
   encode_true -> true [0]
   encode_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_or(x_1, x_2) -> or(encArg(x_1), encArg(x_2)) [0]
   encode_=(x_1, x_2) -> eq(encArg(x_1), encArg(x_2)) [0]
   encArg(v0) -> true [0]
   encode_not(v0) -> true [0]
   encode_xor(v0, v1) -> true [0]
   encode_true -> true [0]
   encode_implies(v0, v1) -> true [0]
   encode_and(v0, v1) -> true [0]
   encode_or(v0, v1) -> true [0]
   encode_=(v0, v1) -> true [0]

The TRS has the following type information:
not :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
xor :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
true :: true:xor:and:cons_not:cons_implies:cons_or:cons_=
implies :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
and :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
or :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
eq :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encArg :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
cons_not :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
cons_implies :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
cons_or :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
cons_= :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_not :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_xor :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_true :: true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_implies :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_and :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_or :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_= :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=

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:

   not(x) -> xor(x, true) [1]
   implies(x, y) -> xor(and(x, y), xor(x, true)) [1]
   or(x, y) -> xor(and(x, y), xor(x, y)) [1]
   eq(x, y) -> xor(x, xor(y, true)) [1]
   encArg(xor(x_1, x_2)) -> xor(encArg(x_1), encArg(x_2)) [0]
   encArg(true) -> true [0]
   encArg(and(x_1, x_2)) -> and(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_not(xor(x_1', x_2'))) -> not(xor(encArg(x_1'), encArg(x_2'))) [0]
   encArg(cons_not(true)) -> not(true) [0]
   encArg(cons_not(and(x_1'', x_2''))) -> not(and(encArg(x_1''), encArg(x_2''))) [0]
   encArg(cons_not(cons_not(x_11))) -> not(not(encArg(x_11))) [0]
   encArg(cons_not(cons_implies(x_12, x_21))) -> not(implies(encArg(x_12), encArg(x_21))) [0]
   encArg(cons_not(cons_or(x_13, x_22))) -> not(or(encArg(x_13), encArg(x_22))) [0]
   encArg(cons_not(cons_=(x_14, x_23))) -> not(eq(encArg(x_14), encArg(x_23))) [0]
   encArg(cons_not(x_1)) -> not(true) [0]
   encArg(cons_implies(x_1, x_2)) -> implies(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_or(x_1, x_2)) -> or(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_=(x_1, x_2)) -> eq(encArg(x_1), encArg(x_2)) [0]
   encode_not(xor(x_1167, x_2139)) -> not(xor(encArg(x_1167), encArg(x_2139))) [0]
   encode_not(true) -> not(true) [0]
   encode_not(and(x_1168, x_2140)) -> not(and(encArg(x_1168), encArg(x_2140))) [0]
   encode_not(cons_not(x_1169)) -> not(not(encArg(x_1169))) [0]
   encode_not(cons_implies(x_1170, x_2141)) -> not(implies(encArg(x_1170), encArg(x_2141))) [0]
   encode_not(cons_or(x_1171, x_2142)) -> not(or(encArg(x_1171), encArg(x_2142))) [0]
   encode_not(cons_=(x_1172, x_2143)) -> not(eq(encArg(x_1172), encArg(x_2143))) [0]
   encode_not(x_1) -> not(true) [0]
   encode_xor(x_1, x_2) -> xor(encArg(x_1), encArg(x_2)) [0]
   encode_true -> true [0]
   encode_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_or(x_1, x_2) -> or(encArg(x_1), encArg(x_2)) [0]
   encode_=(x_1, x_2) -> eq(encArg(x_1), encArg(x_2)) [0]
   encArg(v0) -> true [0]
   encode_not(v0) -> true [0]
   encode_xor(v0, v1) -> true [0]
   encode_true -> true [0]
   encode_implies(v0, v1) -> true [0]
   encode_and(v0, v1) -> true [0]
   encode_or(v0, v1) -> true [0]
   encode_=(v0, v1) -> true [0]

The TRS has the following type information:
not :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
xor :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
true :: true:xor:and:cons_not:cons_implies:cons_or:cons_=
implies :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
and :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
or :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
eq :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encArg :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
cons_not :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
cons_implies :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
cons_or :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
cons_= :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_not :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_xor :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_true :: true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_implies :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_and :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_or :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=
encode_= :: true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_= -> true:xor:and:cons_not:cons_implies:cons_or:cons_=

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:

   true => 0

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(x_11))) :|: x_11 >= 0, z = 1 + (1 + x_11)
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> not(0) :|: z = 1 + x_1, x_1 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, x_2 >= 0, z = x_1, z' = x_2
   encode_=(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   encode_and(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   encode_and(z, z') -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, x_2 >= 0, z = x_1, z' = x_2
   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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(x_1169))) :|: x_1169 >= 0, z = 1 + x_1169
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(0) :|: z = 0
   encode_not(z) -{ 0 }-> not(0) :|: x_1 >= 0, z = x_1
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_or(z, z') -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, x_2 >= 0, z = x_1, z' = x_2
   encode_or(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   encode_xor(z, z') -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, x_2 >= 0, z = x_1, z' = x_2
   eq(z, z') -{ 1 }-> 1 + x + (1 + y + 0) :|: x >= 0, y >= 0, z = x, z' = y
   implies(z, z') -{ 1 }-> 1 + (1 + x + y) + (1 + x + 0) :|: x >= 0, y >= 0, z = x, z' = y
   not(z) -{ 1 }-> 1 + x + 0 :|: x >= 0, z = x
   or(z, z') -{ 1 }-> 1 + (1 + x + y) + (1 + x + y) :|: x >= 0, y >= 0, z = x, z' = y


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

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

   not(z) -{ 1 }-> 1 + x + 0 :|: x >= 0, z = x
   implies(z, z') -{ 1 }-> 1 + (1 + x + y) + (1 + x + 0) :|: x >= 0, y >= 0, z = x, z' = y
   or(z, z') -{ 1 }-> 1 + (1 + x + y) + (1 + x + y) :|: x >= 0, y >= 0, z = x, z' = y
   eq(z, z') -{ 1 }-> 1 + x + (1 + y + 0) :|: x >= 0, y >= 0, z = x, z' = y

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(x_11))) :|: x_11 >= 0, z = 1 + (1 + x_11)
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + x_1, x_1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, x_2 >= 0, z = x_1, z' = x_2
   encode_=(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   encode_and(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   encode_and(z, z') -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, x_2 >= 0, z = x_1, z' = x_2
   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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(x_1169))) :|: x_1169 >= 0, z = 1 + x_1169
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: x_1 >= 0, z = x_1, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, x_2 >= 0, z = x_1, z' = x_2
   encode_or(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   encode_xor(z, z') -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, x_2 >= 0, z = x_1, z' = x_2
   eq(z, z') -{ 1 }-> 1 + x + (1 + y + 0) :|: x >= 0, y >= 0, z = x, z' = y
   implies(z, z') -{ 1 }-> 1 + (1 + x + y) + (1 + x + 0) :|: x >= 0, y >= 0, z = x, z' = y
   not(z) -{ 1 }-> 1 + x + 0 :|: x >= 0, z = x
   or(z, z') -{ 1 }-> 1 + (1 + x + y) + (1 + x + y) :|: x >= 0, y >= 0, z = x, z' = y


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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0


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

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

   { not }
   { implies }
   { eq }
   { encode_true }
   { or }
   { encArg }
   { encode_= }
   { encode_or }
   { encode_implies }
   { encode_not }
   { encode_and }
   { encode_xor }

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {not}, {implies}, {eq}, {encode_true}, {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {not}, {implies}, {eq}, {encode_true}, {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {not}, {implies}, {eq}, {encode_true}, {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
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:

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {implies}, {eq}, {encode_true}, {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
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:

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {implies}, {eq}, {encode_true}, {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]

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

(31) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {implies}, {eq}, {encode_true}, {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: ?, size: O(n^1) [3 + 2*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(1) with polynomial bound: 1

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {eq}, {encode_true}, {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*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:

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {eq}, {encode_true}, {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']

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

(37) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {eq}, {encode_true}, {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: ?, size: O(n^1) [2 + z + z']

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_true}, {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_true}, {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']

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

(43) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_true}, {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: ?, size: O(1) [0]

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

(45) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]

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

(49) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {or}, {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: ?, size: O(n^1) [3 + 2*z + 2*z']

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*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:

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']

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

(55) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using KoAT for: encArg
after applying outer abstraction to obtain an ITS,
resulting in: EXP with polynomial bound: ?

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encArg}, {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: ?, size: EXP

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 0 }-> or(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 0 }-> not(or(encArg(x_13), encArg(x_22))) :|: x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 0 }-> not(not(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> not(implies(encArg(x_12), encArg(x_21))) :|: z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 0 }-> not(eq(encArg(x_14), encArg(x_23))) :|: z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1') + encArg(x_2')) :|: z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 0 }-> not(1 + encArg(x_1'') + encArg(x_2'')) :|: x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 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 }-> eq(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) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encArg(z) -{ 0 }-> 1 + encArg(x_1) + encArg(x_2) :|: x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encode_=(z, z') -{ 0 }-> eq(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 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(or(encArg(x_1171), encArg(x_2142))) :|: z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 0 }-> not(not(encArg(z - 1))) :|: z - 1 >= 0
   encode_not(z) -{ 0 }-> not(implies(encArg(x_1170), encArg(x_2141))) :|: z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 0 }-> not(eq(encArg(x_1172), encArg(x_2143))) :|: z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1167) + encArg(x_2139)) :|: x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 0 }-> not(1 + encArg(x_1168) + encArg(x_2140)) :|: x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 0 }-> or(encArg(z), encArg(z')) :|: z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 0 }-> 1 + encArg(z) + encArg(z') :|: z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP

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

(61) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_=}, {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: ?, size: INF

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

(63) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF

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

(67) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_or}, {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_or: runtime: ?, size: INF

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

(69) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_or: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_or: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF

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

(73) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_implies}, {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_or: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_implies: runtime: ?, size: INF

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

(75) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_or: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_implies: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_or: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_implies: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF

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

(79) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_not}, {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_or: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_implies: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_not: runtime: ?, size: INF

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

(81) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_or: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_implies: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_not: runtime: O(n^1) [2 + 2*z], size: INF

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_or: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_implies: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_not: runtime: O(n^1) [2 + 2*z], size: INF

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

(85) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_and}, {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_or: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_implies: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_not: runtime: O(n^1) [2 + 2*z], size: INF
  encode_and: runtime: ?, size: INF

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

(87) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_or: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_implies: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_not: runtime: O(n^1) [2 + 2*z], size: INF
  encode_and: runtime: O(n^1) [2 + 2*z + 2*z'], size: INF

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_or: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_implies: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_not: runtime: O(n^1) [2 + 2*z], size: INF
  encode_and: runtime: O(n^1) [2 + 2*z + 2*z'], size: INF

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

(91) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {encode_xor}
Previous analysis results are:
  not: runtime: O(1) [1], size: O(n^1) [1 + z]
  implies: runtime: O(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_or: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_implies: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_not: runtime: O(n^1) [2 + 2*z], size: INF
  encode_and: runtime: O(n^1) [2 + 2*z + 2*z'], size: INF
  encode_xor: runtime: ?, size: INF

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

(93) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ -1 + 2*z }-> s12 :|: s10 >= 0, s10 <= inf8, s11 >= 0, s11 <= s10 + 1, s12 >= 0, s12 <= s11 + 1, z - 2 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s24 :|: s22 >= 0, s22 <= inf14, s23 >= 0, s23 <= inf15, s24 >= 0, s24 <= 2 * s22 + s23 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_12 + 2*x_21 }-> s31 :|: s28 >= 0, s28 <= inf18, s29 >= 0, s29 <= inf19, s30 >= 0, s30 <= 2 * s28 + s29 + 3, s31 >= 0, s31 <= s30 + 1, z = 1 + (1 + x_12 + x_21), x_12 >= 0, x_21 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s38 :|: s36 >= 0, s36 <= inf22, s37 >= 0, s37 <= inf23, s38 >= 0, s38 <= 2 * s36 + 2 * s37 + 3, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_13 + 2*x_22 }-> s45 :|: s42 >= 0, s42 <= inf26, s43 >= 0, s43 <= inf27, s44 >= 0, s44 <= 2 * s42 + 2 * s43 + 3, s45 >= 0, s45 <= s44 + 1, x_13 >= 0, z = 1 + (1 + x_13 + x_22), x_22 >= 0
   encArg(z) -{ 3 + 2*x_1 + 2*x_2 }-> s52 :|: s50 >= 0, s50 <= inf30, s51 >= 0, s51 <= inf31, s52 >= 0, s52 <= s50 + s51 + 2, x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 4 + 2*x_14 + 2*x_23 }-> s59 :|: s56 >= 0, s56 <= inf34, s57 >= 0, s57 <= inf35, s58 >= 0, s58 <= s56 + s57 + 2, s59 >= 0, s59 <= s58 + 1, z = 1 + (1 + x_14 + x_23), x_14 >= 0, x_23 >= 0
   encArg(z) -{ 3 + 2*x_1' + 2*x_2' }-> s6 :|: s4 >= 0, s4 <= inf4, s5 >= 0, s5 <= inf5, s6 >= 0, s6 <= 1 + s4 + s5 + 1, z = 1 + (1 + x_1' + x_2'), x_2' >= 0, x_1' >= 0
   encArg(z) -{ 3 + 2*x_1'' + 2*x_2'' }-> s9 :|: s7 >= 0, s7 <= inf6, s8 >= 0, s8 <= inf7, s9 >= 0, s9 <= 1 + s7 + s8 + 1, x_1'' >= 0, z = 1 + (1 + x_1'' + x_2''), x_2'' >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 2 + 2*x_1 + 2*x_2 }-> 1 + s + s' :|: s >= 0, s <= inf, s' >= 0, s' <= inf', x_1 >= 0, z = 1 + x_1 + x_2, x_2 >= 0
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z = 1 + 0, x >= 0, 0 = x
   encArg(z) -{ 1 }-> 1 + x + 0 :|: z - 1 >= 0, x >= 0, 0 = x
   encode_=(z, z') -{ 3 + 2*z + 2*z' }-> s55 :|: s53 >= 0, s53 <= inf32, s54 >= 0, s54 <= inf33, s55 >= 0, s55 <= s53 + s54 + 2, z >= 0, z' >= 0
   encode_=(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_and(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s2 + s3 :|: s2 >= 0, s2 <= inf2, s3 >= 0, s3 <= inf3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 3 + 2*z + 2*z' }-> s27 :|: s25 >= 0, s25 <= inf16, s26 >= 0, s26 <= inf17, s27 >= 0, s27 <= 2 * s25 + s26 + 3, z >= 0, z' >= 0
   encode_implies(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_not(z) -{ 3 + 2*x_1167 + 2*x_2139 }-> s15 :|: s13 >= 0, s13 <= inf9, s14 >= 0, s14 <= inf10, s15 >= 0, s15 <= 1 + s13 + s14 + 1, x_2139 >= 0, x_1167 >= 0, z = 1 + x_1167 + x_2139
   encode_not(z) -{ 3 + 2*x_1168 + 2*x_2140 }-> s18 :|: s16 >= 0, s16 <= inf11, s17 >= 0, s17 <= inf12, s18 >= 0, s18 <= 1 + s16 + s17 + 1, x_1168 >= 0, z = 1 + x_1168 + x_2140, x_2140 >= 0
   encode_not(z) -{ 1 + 2*z }-> s21 :|: s19 >= 0, s19 <= inf13, s20 >= 0, s20 <= s19 + 1, s21 >= 0, s21 <= s20 + 1, z - 1 >= 0
   encode_not(z) -{ 4 + 2*x_1170 + 2*x_2141 }-> s35 :|: s32 >= 0, s32 <= inf20, s33 >= 0, s33 <= inf21, s34 >= 0, s34 <= 2 * s32 + s33 + 3, s35 >= 0, s35 <= s34 + 1, z = 1 + x_1170 + x_2141, x_2141 >= 0, x_1170 >= 0
   encode_not(z) -{ 4 + 2*x_1171 + 2*x_2142 }-> s49 :|: s46 >= 0, s46 <= inf28, s47 >= 0, s47 <= inf29, s48 >= 0, s48 <= 2 * s46 + 2 * s47 + 3, s49 >= 0, s49 <= s48 + 1, z = 1 + x_1171 + x_2142, x_1171 >= 0, x_2142 >= 0
   encode_not(z) -{ 4 + 2*x_1172 + 2*x_2143 }-> s63 :|: s60 >= 0, s60 <= inf36, s61 >= 0, s61 <= inf37, s62 >= 0, s62 <= s60 + s61 + 2, s63 >= 0, s63 <= s62 + 1, z = 1 + x_1172 + x_2143, x_2143 >= 0, x_1172 >= 0
   encode_not(z) -{ 0 }-> 0 :|: z >= 0
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z = 0, x >= 0, 0 = x
   encode_not(z) -{ 1 }-> 1 + x + 0 :|: z >= 0, x >= 0, 0 = x
   encode_or(z, z') -{ 3 + 2*z + 2*z' }-> s41 :|: s39 >= 0, s39 <= inf24, s40 >= 0, s40 <= inf25, s41 >= 0, s41 <= 2 * s39 + 2 * s40 + 3, z >= 0, z' >= 0
   encode_or(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_true -{ 0 }-> 0 :|: 
   encode_xor(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   encode_xor(z, z') -{ 2 + 2*z + 2*z' }-> 1 + s'' + s1 :|: s'' >= 0, s'' <= inf'', s1 >= 0, s1 <= inf1, z >= 0, z' >= 0
   eq(z, z') -{ 1 }-> 1 + z + (1 + z' + 0) :|: z >= 0, z' >= 0
   implies(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + 0) :|: z >= 0, z' >= 0
   not(z) -{ 1 }-> 1 + z + 0 :|: z >= 0
   or(z, z') -{ 1 }-> 1 + (1 + z + z') + (1 + z + z') :|: z >= 0, 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(1) [1], size: O(n^1) [3 + 2*z + z']
  eq: runtime: O(1) [1], size: O(n^1) [2 + z + z']
  encode_true: runtime: O(1) [0], size: O(1) [0]
  or: runtime: O(1) [1], size: O(n^1) [3 + 2*z + 2*z']
  encArg: runtime: O(n^1) [1 + 2*z], size: EXP
  encode_=: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_or: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_implies: runtime: O(n^1) [3 + 2*z + 2*z'], size: INF
  encode_not: runtime: O(n^1) [2 + 2*z], size: INF
  encode_and: runtime: O(n^1) [2 + 2*z + 2*z'], size: INF
  encode_xor: runtime: O(n^1) [2 + 2*z + 2*z'], size: INF

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

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

(96)
BOUNDS(1, n^1)