WORST_CASE(?,O(n^2))
proof of input_kcDYRkIQOG.trs
# AProVE Commit ID: 5b976082cb74a395683ed8cc7acf94bd611ab29f fuhs 20230524 unpublished


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

(0) CpxRelTRS
(1) SInnermostTerminationProof [BOTH CONCRETE BOUNDS(ID, ID), 397 ms]
(2) CpxRelTRS
(3) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(4) CdtProblem
(5) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
(6) CdtProblem
(7) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
(8) CdtProblem
(9) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
(10) CdtProblem
(11) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
(12) CpxRelTRS
(13) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
(14) CpxWeightedTrs
(15) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
(16) CpxTypedWeightedTrs
(17) CompletionProof [UPPER BOUND(ID), 0 ms]
(18) CpxTypedWeightedCompleteTrs
(19) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
(20) CpxTypedWeightedCompleteTrs
(21) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
(22) CpxRNTS
(23) InliningProof [UPPER BOUND(ID), 1309 ms]
(24) CpxRNTS
(25) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
(26) CpxRNTS
(27) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
(28) CpxRNTS
(29) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(30) CpxRNTS
(31) IntTrsBoundProof [UPPER BOUND(ID), 421 ms]
(32) CpxRNTS
(33) IntTrsBoundProof [UPPER BOUND(ID), 96 ms]
(34) CpxRNTS
(35) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(36) CpxRNTS
(37) IntTrsBoundProof [UPPER BOUND(ID), 240 ms]
(38) CpxRNTS
(39) IntTrsBoundProof [UPPER BOUND(ID), 53 ms]
(40) CpxRNTS
(41) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(42) CpxRNTS
(43) IntTrsBoundProof [UPPER BOUND(ID), 238 ms]
(44) CpxRNTS
(45) IntTrsBoundProof [UPPER BOUND(ID), 75 ms]
(46) CpxRNTS
(47) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(48) CpxRNTS
(49) IntTrsBoundProof [UPPER BOUND(ID), 3475 ms]
(50) CpxRNTS
(51) IntTrsBoundProof [UPPER BOUND(ID), 1021 ms]
(52) CpxRNTS
(53) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(54) CpxRNTS
(55) IntTrsBoundProof [UPPER BOUND(ID), 919 ms]
(56) CpxRNTS
(57) IntTrsBoundProof [UPPER BOUND(ID), 628 ms]
(58) CpxRNTS
(59) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(60) CpxRNTS
(61) IntTrsBoundProof [UPPER BOUND(ID), 270 ms]
(62) CpxRNTS
(63) IntTrsBoundProof [UPPER BOUND(ID), 105 ms]
(64) CpxRNTS
(65) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(66) CpxRNTS
(67) IntTrsBoundProof [UPPER BOUND(ID), 1883 ms]
(68) CpxRNTS
(69) IntTrsBoundProof [UPPER BOUND(ID), 582 ms]
(70) CpxRNTS
(71) FinalProof [FINISHED, 0 ms]
(72) BOUNDS(1, n^2)


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

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


The TRS R consists of the following rules:

   prefix(Cons(x', xs'), Cons(x, xs)) -> and(!EQ(x', x), prefix(xs', xs))
   domatch(Cons(x, xs), Nil, n) -> Nil
   domatch(Nil, Nil, n) -> Cons(n, Nil)
   prefix(Cons(x, xs), Nil) -> False
   prefix(Nil, cs) -> True
   domatch(patcs, Cons(x, xs), n) -> domatch[Ite](prefix(patcs, Cons(x, xs)), patcs, Cons(x, xs), n)
   eqNatList(Cons(x, xs), Cons(y, ys)) -> eqNatList[Ite](!EQ(x, y), y, ys, x, xs)
   eqNatList(Cons(x, xs), Nil) -> False
   eqNatList(Nil, Cons(y, ys)) -> False
   eqNatList(Nil, Nil) -> True
   notEmpty(Cons(x, xs)) -> True
   notEmpty(Nil) -> False
   strmatch(patstr, str) -> domatch(patstr, str, Nil)

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

   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   !EQ(S(x), S(y)) -> !EQ(x, y)
   !EQ(0, S(y)) -> False
   !EQ(S(x), 0) -> False
   !EQ(0, 0) -> True
   domatch[Ite](False, patcs, Cons(x, xs), n) -> domatch(patcs, xs, Cons(n, Cons(Nil, Nil)))
   domatch[Ite](True, patcs, Cons(x, xs), n) -> Cons(n, domatch(patcs, xs, Cons(n, Cons(Nil, Nil))))
   eqNatList[Ite](False, y, ys, x, xs) -> False
   eqNatList[Ite](True, y, ys, x, xs) -> eqNatList(xs, ys)

Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

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

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


The TRS R consists of the following rules:

   prefix(Cons(x', xs'), Cons(x, xs)) -> and(!EQ(x', x), prefix(xs', xs))
   domatch(Cons(x, xs), Nil, n) -> Nil
   domatch(Nil, Nil, n) -> Cons(n, Nil)
   prefix(Cons(x, xs), Nil) -> False
   prefix(Nil, cs) -> True
   domatch(patcs, Cons(x, xs), n) -> domatch[Ite](prefix(patcs, Cons(x, xs)), patcs, Cons(x, xs), n)
   eqNatList(Cons(x, xs), Cons(y, ys)) -> eqNatList[Ite](!EQ(x, y), y, ys, x, xs)
   eqNatList(Cons(x, xs), Nil) -> False
   eqNatList(Nil, Cons(y, ys)) -> False
   eqNatList(Nil, Nil) -> True
   notEmpty(Cons(x, xs)) -> True
   notEmpty(Nil) -> False
   strmatch(patstr, str) -> domatch(patstr, str, Nil)

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

   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   !EQ(S(x), S(y)) -> !EQ(x, y)
   !EQ(0, S(y)) -> False
   !EQ(S(x), 0) -> False
   !EQ(0, 0) -> True
   domatch[Ite](False, patcs, Cons(x, xs), n) -> domatch(patcs, xs, Cons(n, Cons(Nil, Nil)))
   domatch[Ite](True, patcs, Cons(x, xs), n) -> Cons(n, domatch(patcs, xs, Cons(n, Cons(Nil, Nil))))
   eqNatList[Ite](False, y, ys, x, xs) -> False
   eqNatList[Ite](True, y, ys, x, xs) -> eqNatList(xs, ys)

Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(3) CpxTrsToCdtProof (UPPER BOUND(ID))
Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT
----------------------------------------

(4)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   domatch[Ite](False, z0, Cons(z1, z2), z3) -> domatch(z0, z2, Cons(z3, Cons(Nil, Nil)))
   domatch[Ite](True, z0, Cons(z1, z2), z3) -> Cons(z3, domatch(z0, z2, Cons(z3, Cons(Nil, Nil))))
   eqNatList[Ite](False, z0, z1, z2, z3) -> False
   eqNatList[Ite](True, z0, z1, z2, z3) -> eqNatList(z3, z1)
   prefix(Cons(z0, z1), Cons(z2, z3)) -> and(!EQ(z0, z2), prefix(z1, z3))
   prefix(Cons(z0, z1), Nil) -> False
   prefix(Nil, z0) -> True
   domatch(Cons(z0, z1), Nil, z2) -> Nil
   domatch(Nil, Nil, z0) -> Cons(z0, Nil)
   domatch(z0, Cons(z1, z2), z3) -> domatch[Ite](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3)
   eqNatList(Cons(z0, z1), Cons(z2, z3)) -> eqNatList[Ite](!EQ(z0, z2), z2, z3, z0, z1)
   eqNatList(Cons(z0, z1), Nil) -> False
   eqNatList(Nil, Cons(z0, z1)) -> False
   eqNatList(Nil, Nil) -> True
   notEmpty(Cons(z0, z1)) -> True
   notEmpty(Nil) -> False
   strmatch(z0, z1) -> domatch(z0, z1, Nil)
Tuples:
   AND(False, False) -> c
   AND(True, False) -> c1
   AND(False, True) -> c2
   AND(True, True) -> c3
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   !EQ'(0, S(z0)) -> c5
   !EQ'(S(z0), 0) -> c6
   !EQ'(0, 0) -> c7
   DOMATCH[ITE](False, z0, Cons(z1, z2), z3) -> c8(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil))))
   DOMATCH[ITE](True, z0, Cons(z1, z2), z3) -> c9(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil))))
   EQNATLIST[ITE](False, z0, z1, z2, z3) -> c10
   EQNATLIST[ITE](True, z0, z1, z2, z3) -> c11(EQNATLIST(z3, z1))
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c12(AND(!EQ(z0, z2), prefix(z1, z3)), !EQ'(z0, z2))
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c13(AND(!EQ(z0, z2), prefix(z1, z3)), PREFIX(z1, z3))
   PREFIX(Cons(z0, z1), Nil) -> c14
   PREFIX(Nil, z0) -> c15
   DOMATCH(Cons(z0, z1), Nil, z2) -> c16
   DOMATCH(Nil, Nil, z0) -> c17
   DOMATCH(z0, Cons(z1, z2), z3) -> c18(DOMATCH[ITE](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3), PREFIX(z0, Cons(z1, z2)))
   EQNATLIST(Cons(z0, z1), Cons(z2, z3)) -> c19(EQNATLIST[ITE](!EQ(z0, z2), z2, z3, z0, z1), !EQ'(z0, z2))
   EQNATLIST(Cons(z0, z1), Nil) -> c20
   EQNATLIST(Nil, Cons(z0, z1)) -> c21
   EQNATLIST(Nil, Nil) -> c22
   NOTEMPTY(Cons(z0, z1)) -> c23
   NOTEMPTY(Nil) -> c24
   STRMATCH(z0, z1) -> c25(DOMATCH(z0, z1, Nil))
S tuples:
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c12(AND(!EQ(z0, z2), prefix(z1, z3)), !EQ'(z0, z2))
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c13(AND(!EQ(z0, z2), prefix(z1, z3)), PREFIX(z1, z3))
   PREFIX(Cons(z0, z1), Nil) -> c14
   PREFIX(Nil, z0) -> c15
   DOMATCH(Cons(z0, z1), Nil, z2) -> c16
   DOMATCH(Nil, Nil, z0) -> c17
   DOMATCH(z0, Cons(z1, z2), z3) -> c18(DOMATCH[ITE](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3), PREFIX(z0, Cons(z1, z2)))
   EQNATLIST(Cons(z0, z1), Cons(z2, z3)) -> c19(EQNATLIST[ITE](!EQ(z0, z2), z2, z3, z0, z1), !EQ'(z0, z2))
   EQNATLIST(Cons(z0, z1), Nil) -> c20
   EQNATLIST(Nil, Cons(z0, z1)) -> c21
   EQNATLIST(Nil, Nil) -> c22
   NOTEMPTY(Cons(z0, z1)) -> c23
   NOTEMPTY(Nil) -> c24
   STRMATCH(z0, z1) -> c25(DOMATCH(z0, z1, Nil))
K tuples:none
Defined Rule Symbols:   prefix_2, domatch_3, eqNatList_2, notEmpty_1, strmatch_2, and_2, !EQ_2, domatch[Ite]_4, eqNatList[Ite]_5

Defined Pair Symbols:   AND_2, !EQ'_2, DOMATCH[ITE]_4, EQNATLIST[ITE]_5, PREFIX_2, DOMATCH_3, EQNATLIST_2, NOTEMPTY_1, STRMATCH_2

Compound Symbols:   c, c1, c2, c3, c4_1, c5, c6, c7, c8_1, c9_1, c10, c11_1, c12_2, c13_2, c14, c15, c16, c17, c18_2, c19_2, c20, c21, c22, c23, c24, c25_1


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

(5) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   STRMATCH(z0, z1) -> c25(DOMATCH(z0, z1, Nil))
Removed 12 trailing nodes:
   AND(True, True) -> c3
   AND(False, False) -> c
   !EQ'(0, S(z0)) -> c5
   PREFIX(Nil, z0) -> c15
   EQNATLIST[ITE](False, z0, z1, z2, z3) -> c10
   AND(False, True) -> c2
   AND(True, False) -> c1
   NOTEMPTY(Cons(z0, z1)) -> c23
   NOTEMPTY(Nil) -> c24
   PREFIX(Cons(z0, z1), Nil) -> c14
   !EQ'(S(z0), 0) -> c6
   !EQ'(0, 0) -> c7

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

(6)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   domatch[Ite](False, z0, Cons(z1, z2), z3) -> domatch(z0, z2, Cons(z3, Cons(Nil, Nil)))
   domatch[Ite](True, z0, Cons(z1, z2), z3) -> Cons(z3, domatch(z0, z2, Cons(z3, Cons(Nil, Nil))))
   eqNatList[Ite](False, z0, z1, z2, z3) -> False
   eqNatList[Ite](True, z0, z1, z2, z3) -> eqNatList(z3, z1)
   prefix(Cons(z0, z1), Cons(z2, z3)) -> and(!EQ(z0, z2), prefix(z1, z3))
   prefix(Cons(z0, z1), Nil) -> False
   prefix(Nil, z0) -> True
   domatch(Cons(z0, z1), Nil, z2) -> Nil
   domatch(Nil, Nil, z0) -> Cons(z0, Nil)
   domatch(z0, Cons(z1, z2), z3) -> domatch[Ite](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3)
   eqNatList(Cons(z0, z1), Cons(z2, z3)) -> eqNatList[Ite](!EQ(z0, z2), z2, z3, z0, z1)
   eqNatList(Cons(z0, z1), Nil) -> False
   eqNatList(Nil, Cons(z0, z1)) -> False
   eqNatList(Nil, Nil) -> True
   notEmpty(Cons(z0, z1)) -> True
   notEmpty(Nil) -> False
   strmatch(z0, z1) -> domatch(z0, z1, Nil)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   DOMATCH[ITE](False, z0, Cons(z1, z2), z3) -> c8(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil))))
   DOMATCH[ITE](True, z0, Cons(z1, z2), z3) -> c9(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil))))
   EQNATLIST[ITE](True, z0, z1, z2, z3) -> c11(EQNATLIST(z3, z1))
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c12(AND(!EQ(z0, z2), prefix(z1, z3)), !EQ'(z0, z2))
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c13(AND(!EQ(z0, z2), prefix(z1, z3)), PREFIX(z1, z3))
   DOMATCH(Cons(z0, z1), Nil, z2) -> c16
   DOMATCH(Nil, Nil, z0) -> c17
   DOMATCH(z0, Cons(z1, z2), z3) -> c18(DOMATCH[ITE](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3), PREFIX(z0, Cons(z1, z2)))
   EQNATLIST(Cons(z0, z1), Cons(z2, z3)) -> c19(EQNATLIST[ITE](!EQ(z0, z2), z2, z3, z0, z1), !EQ'(z0, z2))
   EQNATLIST(Cons(z0, z1), Nil) -> c20
   EQNATLIST(Nil, Cons(z0, z1)) -> c21
   EQNATLIST(Nil, Nil) -> c22
S tuples:
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c12(AND(!EQ(z0, z2), prefix(z1, z3)), !EQ'(z0, z2))
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c13(AND(!EQ(z0, z2), prefix(z1, z3)), PREFIX(z1, z3))
   DOMATCH(Cons(z0, z1), Nil, z2) -> c16
   DOMATCH(Nil, Nil, z0) -> c17
   DOMATCH(z0, Cons(z1, z2), z3) -> c18(DOMATCH[ITE](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3), PREFIX(z0, Cons(z1, z2)))
   EQNATLIST(Cons(z0, z1), Cons(z2, z3)) -> c19(EQNATLIST[ITE](!EQ(z0, z2), z2, z3, z0, z1), !EQ'(z0, z2))
   EQNATLIST(Cons(z0, z1), Nil) -> c20
   EQNATLIST(Nil, Cons(z0, z1)) -> c21
   EQNATLIST(Nil, Nil) -> c22
K tuples:none
Defined Rule Symbols:   prefix_2, domatch_3, eqNatList_2, notEmpty_1, strmatch_2, and_2, !EQ_2, domatch[Ite]_4, eqNatList[Ite]_5

Defined Pair Symbols:   !EQ'_2, DOMATCH[ITE]_4, EQNATLIST[ITE]_5, PREFIX_2, DOMATCH_3, EQNATLIST_2

Compound Symbols:   c4_1, c8_1, c9_1, c11_1, c12_2, c13_2, c16, c17, c18_2, c19_2, c20, c21, c22


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

(7) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(8)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   domatch[Ite](False, z0, Cons(z1, z2), z3) -> domatch(z0, z2, Cons(z3, Cons(Nil, Nil)))
   domatch[Ite](True, z0, Cons(z1, z2), z3) -> Cons(z3, domatch(z0, z2, Cons(z3, Cons(Nil, Nil))))
   eqNatList[Ite](False, z0, z1, z2, z3) -> False
   eqNatList[Ite](True, z0, z1, z2, z3) -> eqNatList(z3, z1)
   prefix(Cons(z0, z1), Cons(z2, z3)) -> and(!EQ(z0, z2), prefix(z1, z3))
   prefix(Cons(z0, z1), Nil) -> False
   prefix(Nil, z0) -> True
   domatch(Cons(z0, z1), Nil, z2) -> Nil
   domatch(Nil, Nil, z0) -> Cons(z0, Nil)
   domatch(z0, Cons(z1, z2), z3) -> domatch[Ite](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3)
   eqNatList(Cons(z0, z1), Cons(z2, z3)) -> eqNatList[Ite](!EQ(z0, z2), z2, z3, z0, z1)
   eqNatList(Cons(z0, z1), Nil) -> False
   eqNatList(Nil, Cons(z0, z1)) -> False
   eqNatList(Nil, Nil) -> True
   notEmpty(Cons(z0, z1)) -> True
   notEmpty(Nil) -> False
   strmatch(z0, z1) -> domatch(z0, z1, Nil)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   DOMATCH[ITE](False, z0, Cons(z1, z2), z3) -> c8(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil))))
   DOMATCH[ITE](True, z0, Cons(z1, z2), z3) -> c9(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil))))
   EQNATLIST[ITE](True, z0, z1, z2, z3) -> c11(EQNATLIST(z3, z1))
   DOMATCH(Cons(z0, z1), Nil, z2) -> c16
   DOMATCH(Nil, Nil, z0) -> c17
   DOMATCH(z0, Cons(z1, z2), z3) -> c18(DOMATCH[ITE](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3), PREFIX(z0, Cons(z1, z2)))
   EQNATLIST(Cons(z0, z1), Cons(z2, z3)) -> c19(EQNATLIST[ITE](!EQ(z0, z2), z2, z3, z0, z1), !EQ'(z0, z2))
   EQNATLIST(Cons(z0, z1), Nil) -> c20
   EQNATLIST(Nil, Cons(z0, z1)) -> c21
   EQNATLIST(Nil, Nil) -> c22
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c12(!EQ'(z0, z2))
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c13(PREFIX(z1, z3))
S tuples:
   DOMATCH(Cons(z0, z1), Nil, z2) -> c16
   DOMATCH(Nil, Nil, z0) -> c17
   DOMATCH(z0, Cons(z1, z2), z3) -> c18(DOMATCH[ITE](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3), PREFIX(z0, Cons(z1, z2)))
   EQNATLIST(Cons(z0, z1), Cons(z2, z3)) -> c19(EQNATLIST[ITE](!EQ(z0, z2), z2, z3, z0, z1), !EQ'(z0, z2))
   EQNATLIST(Cons(z0, z1), Nil) -> c20
   EQNATLIST(Nil, Cons(z0, z1)) -> c21
   EQNATLIST(Nil, Nil) -> c22
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c12(!EQ'(z0, z2))
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c13(PREFIX(z1, z3))
K tuples:none
Defined Rule Symbols:   prefix_2, domatch_3, eqNatList_2, notEmpty_1, strmatch_2, and_2, !EQ_2, domatch[Ite]_4, eqNatList[Ite]_5

Defined Pair Symbols:   !EQ'_2, DOMATCH[ITE]_4, EQNATLIST[ITE]_5, DOMATCH_3, EQNATLIST_2, PREFIX_2

Compound Symbols:   c4_1, c8_1, c9_1, c11_1, c16, c17, c18_2, c19_2, c20, c21, c22, c12_1, c13_1


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

(9) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   domatch[Ite](False, z0, Cons(z1, z2), z3) -> domatch(z0, z2, Cons(z3, Cons(Nil, Nil)))
   domatch[Ite](True, z0, Cons(z1, z2), z3) -> Cons(z3, domatch(z0, z2, Cons(z3, Cons(Nil, Nil))))
   eqNatList[Ite](False, z0, z1, z2, z3) -> False
   eqNatList[Ite](True, z0, z1, z2, z3) -> eqNatList(z3, z1)
   domatch(Cons(z0, z1), Nil, z2) -> Nil
   domatch(Nil, Nil, z0) -> Cons(z0, Nil)
   domatch(z0, Cons(z1, z2), z3) -> domatch[Ite](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3)
   eqNatList(Cons(z0, z1), Cons(z2, z3)) -> eqNatList[Ite](!EQ(z0, z2), z2, z3, z0, z1)
   eqNatList(Cons(z0, z1), Nil) -> False
   eqNatList(Nil, Cons(z0, z1)) -> False
   eqNatList(Nil, Nil) -> True
   notEmpty(Cons(z0, z1)) -> True
   notEmpty(Nil) -> False
   strmatch(z0, z1) -> domatch(z0, z1, Nil)

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

(10)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   prefix(Cons(z0, z1), Cons(z2, z3)) -> and(!EQ(z0, z2), prefix(z1, z3))
   prefix(Nil, z0) -> True
   prefix(Cons(z0, z1), Nil) -> False
   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   DOMATCH[ITE](False, z0, Cons(z1, z2), z3) -> c8(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil))))
   DOMATCH[ITE](True, z0, Cons(z1, z2), z3) -> c9(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil))))
   EQNATLIST[ITE](True, z0, z1, z2, z3) -> c11(EQNATLIST(z3, z1))
   DOMATCH(Cons(z0, z1), Nil, z2) -> c16
   DOMATCH(Nil, Nil, z0) -> c17
   DOMATCH(z0, Cons(z1, z2), z3) -> c18(DOMATCH[ITE](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3), PREFIX(z0, Cons(z1, z2)))
   EQNATLIST(Cons(z0, z1), Cons(z2, z3)) -> c19(EQNATLIST[ITE](!EQ(z0, z2), z2, z3, z0, z1), !EQ'(z0, z2))
   EQNATLIST(Cons(z0, z1), Nil) -> c20
   EQNATLIST(Nil, Cons(z0, z1)) -> c21
   EQNATLIST(Nil, Nil) -> c22
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c12(!EQ'(z0, z2))
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c13(PREFIX(z1, z3))
S tuples:
   DOMATCH(Cons(z0, z1), Nil, z2) -> c16
   DOMATCH(Nil, Nil, z0) -> c17
   DOMATCH(z0, Cons(z1, z2), z3) -> c18(DOMATCH[ITE](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3), PREFIX(z0, Cons(z1, z2)))
   EQNATLIST(Cons(z0, z1), Cons(z2, z3)) -> c19(EQNATLIST[ITE](!EQ(z0, z2), z2, z3, z0, z1), !EQ'(z0, z2))
   EQNATLIST(Cons(z0, z1), Nil) -> c20
   EQNATLIST(Nil, Cons(z0, z1)) -> c21
   EQNATLIST(Nil, Nil) -> c22
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c12(!EQ'(z0, z2))
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c13(PREFIX(z1, z3))
K tuples:none
Defined Rule Symbols:   prefix_2, and_2, !EQ_2

Defined Pair Symbols:   !EQ'_2, DOMATCH[ITE]_4, EQNATLIST[ITE]_5, DOMATCH_3, EQNATLIST_2, PREFIX_2

Compound Symbols:   c4_1, c8_1, c9_1, c11_1, c16, c17, c18_2, c19_2, c20, c21, c22, c12_1, c13_1


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

(11) CdtToCpxRelTrsProof (BOTH BOUNDS(ID, ID))
Converted S to standard rules, and D \ S as well as R to relative rules.
----------------------------------------

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


The TRS R consists of the following rules:

   DOMATCH(Cons(z0, z1), Nil, z2) -> c16
   DOMATCH(Nil, Nil, z0) -> c17
   DOMATCH(z0, Cons(z1, z2), z3) -> c18(DOMATCH[ITE](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3), PREFIX(z0, Cons(z1, z2)))
   EQNATLIST(Cons(z0, z1), Cons(z2, z3)) -> c19(EQNATLIST[ITE](!EQ(z0, z2), z2, z3, z0, z1), !EQ'(z0, z2))
   EQNATLIST(Cons(z0, z1), Nil) -> c20
   EQNATLIST(Nil, Cons(z0, z1)) -> c21
   EQNATLIST(Nil, Nil) -> c22
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c12(!EQ'(z0, z2))
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c13(PREFIX(z1, z3))

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

   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   DOMATCH[ITE](False, z0, Cons(z1, z2), z3) -> c8(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil))))
   DOMATCH[ITE](True, z0, Cons(z1, z2), z3) -> c9(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil))))
   EQNATLIST[ITE](True, z0, z1, z2, z3) -> c11(EQNATLIST(z3, z1))
   prefix(Cons(z0, z1), Cons(z2, z3)) -> and(!EQ(z0, z2), prefix(z1, z3))
   prefix(Nil, z0) -> True
   prefix(Cons(z0, z1), Nil) -> False
   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True

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

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

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


The TRS R consists of the following rules:

   DOMATCH(Cons(z0, z1), Nil, z2) -> c16 [1]
   DOMATCH(Nil, Nil, z0) -> c17 [1]
   DOMATCH(z0, Cons(z1, z2), z3) -> c18(DOMATCH[ITE](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3), PREFIX(z0, Cons(z1, z2))) [1]
   EQNATLIST(Cons(z0, z1), Cons(z2, z3)) -> c19(EQNATLIST[ITE](!EQ(z0, z2), z2, z3, z0, z1), !EQ'(z0, z2)) [1]
   EQNATLIST(Cons(z0, z1), Nil) -> c20 [1]
   EQNATLIST(Nil, Cons(z0, z1)) -> c21 [1]
   EQNATLIST(Nil, Nil) -> c22 [1]
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c12(!EQ'(z0, z2)) [1]
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c13(PREFIX(z1, z3)) [1]
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1)) [0]
   DOMATCH[ITE](False, z0, Cons(z1, z2), z3) -> c8(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil)))) [0]
   DOMATCH[ITE](True, z0, Cons(z1, z2), z3) -> c9(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil)))) [0]
   EQNATLIST[ITE](True, z0, z1, z2, z3) -> c11(EQNATLIST(z3, z1)) [0]
   prefix(Cons(z0, z1), Cons(z2, z3)) -> and(!EQ(z0, z2), prefix(z1, z3)) [0]
   prefix(Nil, z0) -> True [0]
   prefix(Cons(z0, z1), Nil) -> False [0]
   and(False, False) -> False [0]
   and(True, False) -> False [0]
   and(False, True) -> False [0]
   and(True, True) -> True [0]
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1) [0]
   !EQ(0, S(z0)) -> False [0]
   !EQ(S(z0), 0) -> False [0]
   !EQ(0, 0) -> True [0]

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

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

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

   DOMATCH(Cons(z0, z1), Nil, z2) -> c16 [1]
   DOMATCH(Nil, Nil, z0) -> c17 [1]
   DOMATCH(z0, Cons(z1, z2), z3) -> c18(DOMATCH[ITE](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3), PREFIX(z0, Cons(z1, z2))) [1]
   EQNATLIST(Cons(z0, z1), Cons(z2, z3)) -> c19(EQNATLIST[ITE](!EQ(z0, z2), z2, z3, z0, z1), !EQ'(z0, z2)) [1]
   EQNATLIST(Cons(z0, z1), Nil) -> c20 [1]
   EQNATLIST(Nil, Cons(z0, z1)) -> c21 [1]
   EQNATLIST(Nil, Nil) -> c22 [1]
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c12(!EQ'(z0, z2)) [1]
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c13(PREFIX(z1, z3)) [1]
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1)) [0]
   DOMATCH[ITE](False, z0, Cons(z1, z2), z3) -> c8(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil)))) [0]
   DOMATCH[ITE](True, z0, Cons(z1, z2), z3) -> c9(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil)))) [0]
   EQNATLIST[ITE](True, z0, z1, z2, z3) -> c11(EQNATLIST(z3, z1)) [0]
   prefix(Cons(z0, z1), Cons(z2, z3)) -> and(!EQ(z0, z2), prefix(z1, z3)) [0]
   prefix(Nil, z0) -> True [0]
   prefix(Cons(z0, z1), Nil) -> False [0]
   and(False, False) -> False [0]
   and(True, False) -> False [0]
   and(False, True) -> False [0]
   and(True, True) -> True [0]
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1) [0]
   !EQ(0, S(z0)) -> False [0]
   !EQ(S(z0), 0) -> False [0]
   !EQ(0, 0) -> True [0]

The TRS has the following type information:
DOMATCH :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> c16:c17:c18
Cons :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0
Nil :: Cons:Nil:S:0
c16 :: c16:c17:c18
c17 :: c16:c17:c18
c18 :: c8:c9 -> c12:c13 -> c16:c17:c18
DOMATCH[ITE] :: False:True -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> c8:c9
prefix :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> False:True
PREFIX :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> c12:c13
EQNATLIST :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> c19:c20:c21:c22
c19 :: c11 -> c4 -> c19:c20:c21:c22
EQNATLIST[ITE] :: False:True -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> c11
!EQ :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> False:True
!EQ' :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> c4
c20 :: c19:c20:c21:c22
c21 :: c19:c20:c21:c22
c22 :: c19:c20:c21:c22
c12 :: c4 -> c12:c13
c13 :: c12:c13 -> c12:c13
S :: Cons:Nil:S:0 -> Cons:Nil:S:0
c4 :: c4 -> c4
False :: False:True
c8 :: c16:c17:c18 -> c8:c9
True :: False:True
c9 :: c16:c17:c18 -> c8:c9
c11 :: c19:c20:c21:c22 -> c11
and :: False:True -> False:True -> False:True
0 :: Cons:Nil:S:0

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

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

   DOMATCH_3
   EQNATLIST_2
   PREFIX_2

(c) The following functions are completely defined:

   !EQ'_2
   DOMATCH[ITE]_4
   EQNATLIST[ITE]_5
   prefix_2
   and_2
   !EQ_2

Due to the following rules being added:

   !EQ'(v0, v1) -> const3 [0]
   DOMATCH[ITE](v0, v1, v2, v3) -> const [0]
   EQNATLIST[ITE](v0, v1, v2, v3, v4) -> const2 [0]
   prefix(v0, v1) -> null_prefix [0]
   and(v0, v1) -> null_and [0]
   !EQ(v0, v1) -> null_!EQ [0]

And the following fresh constants:    const3, const, const2, null_prefix, null_and, null_!EQ, const1

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

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

   DOMATCH(Cons(z0, z1), Nil, z2) -> c16 [1]
   DOMATCH(Nil, Nil, z0) -> c17 [1]
   DOMATCH(z0, Cons(z1, z2), z3) -> c18(DOMATCH[ITE](prefix(z0, Cons(z1, z2)), z0, Cons(z1, z2), z3), PREFIX(z0, Cons(z1, z2))) [1]
   EQNATLIST(Cons(z0, z1), Cons(z2, z3)) -> c19(EQNATLIST[ITE](!EQ(z0, z2), z2, z3, z0, z1), !EQ'(z0, z2)) [1]
   EQNATLIST(Cons(z0, z1), Nil) -> c20 [1]
   EQNATLIST(Nil, Cons(z0, z1)) -> c21 [1]
   EQNATLIST(Nil, Nil) -> c22 [1]
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c12(!EQ'(z0, z2)) [1]
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c13(PREFIX(z1, z3)) [1]
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1)) [0]
   DOMATCH[ITE](False, z0, Cons(z1, z2), z3) -> c8(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil)))) [0]
   DOMATCH[ITE](True, z0, Cons(z1, z2), z3) -> c9(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil)))) [0]
   EQNATLIST[ITE](True, z0, z1, z2, z3) -> c11(EQNATLIST(z3, z1)) [0]
   prefix(Cons(z0, z1), Cons(z2, z3)) -> and(!EQ(z0, z2), prefix(z1, z3)) [0]
   prefix(Nil, z0) -> True [0]
   prefix(Cons(z0, z1), Nil) -> False [0]
   and(False, False) -> False [0]
   and(True, False) -> False [0]
   and(False, True) -> False [0]
   and(True, True) -> True [0]
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1) [0]
   !EQ(0, S(z0)) -> False [0]
   !EQ(S(z0), 0) -> False [0]
   !EQ(0, 0) -> True [0]
   !EQ'(v0, v1) -> const3 [0]
   DOMATCH[ITE](v0, v1, v2, v3) -> const [0]
   EQNATLIST[ITE](v0, v1, v2, v3, v4) -> const2 [0]
   prefix(v0, v1) -> null_prefix [0]
   and(v0, v1) -> null_and [0]
   !EQ(v0, v1) -> null_!EQ [0]

The TRS has the following type information:
DOMATCH :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> c16:c17:c18
Cons :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0
Nil :: Cons:Nil:S:0
c16 :: c16:c17:c18
c17 :: c16:c17:c18
c18 :: c8:c9:const -> c12:c13 -> c16:c17:c18
DOMATCH[ITE] :: False:True:null_prefix:null_and:null_!EQ -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> c8:c9:const
prefix :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> False:True:null_prefix:null_and:null_!EQ
PREFIX :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> c12:c13
EQNATLIST :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> c19:c20:c21:c22
c19 :: c11:const2 -> c4:const3 -> c19:c20:c21:c22
EQNATLIST[ITE] :: False:True:null_prefix:null_and:null_!EQ -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> c11:const2
!EQ :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> False:True:null_prefix:null_and:null_!EQ
!EQ' :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> c4:const3
c20 :: c19:c20:c21:c22
c21 :: c19:c20:c21:c22
c22 :: c19:c20:c21:c22
c12 :: c4:const3 -> c12:c13
c13 :: c12:c13 -> c12:c13
S :: Cons:Nil:S:0 -> Cons:Nil:S:0
c4 :: c4:const3 -> c4:const3
False :: False:True:null_prefix:null_and:null_!EQ
c8 :: c16:c17:c18 -> c8:c9:const
True :: False:True:null_prefix:null_and:null_!EQ
c9 :: c16:c17:c18 -> c8:c9:const
c11 :: c19:c20:c21:c22 -> c11:const2
and :: False:True:null_prefix:null_and:null_!EQ -> False:True:null_prefix:null_and:null_!EQ -> False:True:null_prefix:null_and:null_!EQ
0 :: Cons:Nil:S:0
const3 :: c4:const3
const :: c8:c9:const
const2 :: c11:const2
null_prefix :: False:True:null_prefix:null_and:null_!EQ
null_and :: False:True:null_prefix:null_and:null_!EQ
null_!EQ :: False:True:null_prefix:null_and:null_!EQ
const1 :: c12:c13

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

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

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

   DOMATCH(Cons(z0, z1), Nil, z2) -> c16 [1]
   DOMATCH(Nil, Nil, z0) -> c17 [1]
   DOMATCH(Cons(z0', z1'), Cons(z1, z2), z3) -> c18(DOMATCH[ITE](and(!EQ(z0', z1), prefix(z1', z2)), Cons(z0', z1'), Cons(z1, z2), z3), PREFIX(Cons(z0', z1'), Cons(z1, z2))) [1]
   DOMATCH(Nil, Cons(z1, z2), z3) -> c18(DOMATCH[ITE](True, Nil, Cons(z1, z2), z3), PREFIX(Nil, Cons(z1, z2))) [1]
   DOMATCH(z0, Cons(z1, z2), z3) -> c18(DOMATCH[ITE](null_prefix, z0, Cons(z1, z2), z3), PREFIX(z0, Cons(z1, z2))) [1]
   EQNATLIST(Cons(S(z0''), z1), Cons(S(z1''), z3)) -> c19(EQNATLIST[ITE](!EQ(z0'', z1''), S(z1''), z3, S(z0''), z1), !EQ'(S(z0''), S(z1''))) [1]
   EQNATLIST(Cons(0, z1), Cons(S(z01), z3)) -> c19(EQNATLIST[ITE](False, S(z01), z3, 0, z1), !EQ'(0, S(z01))) [1]
   EQNATLIST(Cons(S(z02), z1), Cons(0, z3)) -> c19(EQNATLIST[ITE](False, 0, z3, S(z02), z1), !EQ'(S(z02), 0)) [1]
   EQNATLIST(Cons(0, z1), Cons(0, z3)) -> c19(EQNATLIST[ITE](True, 0, z3, 0, z1), !EQ'(0, 0)) [1]
   EQNATLIST(Cons(z0, z1), Cons(z2, z3)) -> c19(EQNATLIST[ITE](null_!EQ, z2, z3, z0, z1), !EQ'(z0, z2)) [1]
   EQNATLIST(Cons(z0, z1), Nil) -> c20 [1]
   EQNATLIST(Nil, Cons(z0, z1)) -> c21 [1]
   EQNATLIST(Nil, Nil) -> c22 [1]
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c12(!EQ'(z0, z2)) [1]
   PREFIX(Cons(z0, z1), Cons(z2, z3)) -> c13(PREFIX(z1, z3)) [1]
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1)) [0]
   DOMATCH[ITE](False, z0, Cons(z1, z2), z3) -> c8(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil)))) [0]
   DOMATCH[ITE](True, z0, Cons(z1, z2), z3) -> c9(DOMATCH(z0, z2, Cons(z3, Cons(Nil, Nil)))) [0]
   EQNATLIST[ITE](True, z0, z1, z2, z3) -> c11(EQNATLIST(z3, z1)) [0]
   prefix(Cons(S(z03), Cons(z06, z12)), Cons(S(z11), Cons(z2', z3'))) -> and(!EQ(z03, z11), and(!EQ(z06, z2'), prefix(z12, z3'))) [0]
   prefix(Cons(S(z03), Nil), Cons(S(z11), z3)) -> and(!EQ(z03, z11), True) [0]
   prefix(Cons(S(z03), Cons(z07, z13)), Cons(S(z11), Nil)) -> and(!EQ(z03, z11), False) [0]
   prefix(Cons(S(z03), z1), Cons(S(z11), z3)) -> and(!EQ(z03, z11), null_prefix) [0]
   prefix(Cons(0, Cons(z08, z14)), Cons(S(z04), Cons(z2'', z3''))) -> and(False, and(!EQ(z08, z2''), prefix(z14, z3''))) [0]
   prefix(Cons(0, Nil), Cons(S(z04), z3)) -> and(False, True) [0]
   prefix(Cons(0, Cons(z09, z15)), Cons(S(z04), Nil)) -> and(False, False) [0]
   prefix(Cons(0, z1), Cons(S(z04), z3)) -> and(False, null_prefix) [0]
   prefix(Cons(S(z05), Cons(z010, z16)), Cons(0, Cons(z21, z31))) -> and(False, and(!EQ(z010, z21), prefix(z16, z31))) [0]
   prefix(Cons(S(z05), Nil), Cons(0, z3)) -> and(False, True) [0]
   prefix(Cons(S(z05), Cons(z011, z17)), Cons(0, Nil)) -> and(False, False) [0]
   prefix(Cons(S(z05), z1), Cons(0, z3)) -> and(False, null_prefix) [0]
   prefix(Cons(0, Cons(z012, z18)), Cons(0, Cons(z22, z32))) -> and(True, and(!EQ(z012, z22), prefix(z18, z32))) [0]
   prefix(Cons(0, Nil), Cons(0, z3)) -> and(True, True) [0]
   prefix(Cons(0, Cons(z013, z19)), Cons(0, Nil)) -> and(True, False) [0]
   prefix(Cons(0, z1), Cons(0, z3)) -> and(True, null_prefix) [0]
   prefix(Cons(z0, Cons(z014, z110)), Cons(z2, Cons(z23, z33))) -> and(null_!EQ, and(!EQ(z014, z23), prefix(z110, z33))) [0]
   prefix(Cons(z0, Nil), Cons(z2, z3)) -> and(null_!EQ, True) [0]
   prefix(Cons(z0, Cons(z015, z111)), Cons(z2, Nil)) -> and(null_!EQ, False) [0]
   prefix(Cons(z0, z1), Cons(z2, z3)) -> and(null_!EQ, null_prefix) [0]
   prefix(Nil, z0) -> True [0]
   prefix(Cons(z0, z1), Nil) -> False [0]
   and(False, False) -> False [0]
   and(True, False) -> False [0]
   and(False, True) -> False [0]
   and(True, True) -> True [0]
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1) [0]
   !EQ(0, S(z0)) -> False [0]
   !EQ(S(z0), 0) -> False [0]
   !EQ(0, 0) -> True [0]
   !EQ'(v0, v1) -> const3 [0]
   DOMATCH[ITE](v0, v1, v2, v3) -> const [0]
   EQNATLIST[ITE](v0, v1, v2, v3, v4) -> const2 [0]
   prefix(v0, v1) -> null_prefix [0]
   and(v0, v1) -> null_and [0]
   !EQ(v0, v1) -> null_!EQ [0]

The TRS has the following type information:
DOMATCH :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> c16:c17:c18
Cons :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0
Nil :: Cons:Nil:S:0
c16 :: c16:c17:c18
c17 :: c16:c17:c18
c18 :: c8:c9:const -> c12:c13 -> c16:c17:c18
DOMATCH[ITE] :: False:True:null_prefix:null_and:null_!EQ -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> c8:c9:const
prefix :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> False:True:null_prefix:null_and:null_!EQ
PREFIX :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> c12:c13
EQNATLIST :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> c19:c20:c21:c22
c19 :: c11:const2 -> c4:const3 -> c19:c20:c21:c22
EQNATLIST[ITE] :: False:True:null_prefix:null_and:null_!EQ -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> Cons:Nil:S:0 -> c11:const2
!EQ :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> False:True:null_prefix:null_and:null_!EQ
!EQ' :: Cons:Nil:S:0 -> Cons:Nil:S:0 -> c4:const3
c20 :: c19:c20:c21:c22
c21 :: c19:c20:c21:c22
c22 :: c19:c20:c21:c22
c12 :: c4:const3 -> c12:c13
c13 :: c12:c13 -> c12:c13
S :: Cons:Nil:S:0 -> Cons:Nil:S:0
c4 :: c4:const3 -> c4:const3
False :: False:True:null_prefix:null_and:null_!EQ
c8 :: c16:c17:c18 -> c8:c9:const
True :: False:True:null_prefix:null_and:null_!EQ
c9 :: c16:c17:c18 -> c8:c9:const
c11 :: c19:c20:c21:c22 -> c11:const2
and :: False:True:null_prefix:null_and:null_!EQ -> False:True:null_prefix:null_and:null_!EQ -> False:True:null_prefix:null_and:null_!EQ
0 :: Cons:Nil:S:0
const3 :: c4:const3
const :: c8:c9:const
const2 :: c11:const2
null_prefix :: False:True:null_prefix:null_and:null_!EQ
null_and :: False:True:null_prefix:null_and:null_!EQ
null_!EQ :: False:True:null_prefix:null_and:null_!EQ
const1 :: c12:c13

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

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

   Nil => 1
   c16 => 0
   c17 => 1
   c20 => 0
   c21 => 1
   c22 => 2
   False => 1
   True => 2
   0 => 0
   const3 => 0
   const => 0
   const2 => 0
   null_prefix => 0
   null_and => 0
   null_!EQ => 0
   const1 => 0

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

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

   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z0 >= 0, z' = 1 + z0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z = 1 + z0, z0 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   !EQ(z, z') -{ 0 }-> !EQ(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   !EQ'(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   !EQ'(z, z') -{ 0 }-> 1 + !EQ'(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' = z0, z0 >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z'' = z2, z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z2 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(!EQ(z0', z1), prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z3) + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z'' = z3, z = 1 + z0' + z1', z2 >= 0, z3 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z3) + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z'' = z3, z2 >= 0, z3 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z0, 1 + z1 + z2, z3) + PREFIX(z0, 1 + z1 + z2) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z'' = z3, z2 >= 0, z3 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z4 = v3, v2 >= 0, v3 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z0, z2, 1 + z3 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z0 >= 0, z4 = z3, z' = z0, z2 >= 0, z3 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z0, z2, 1 + z3 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z0 >= 0, z4 = z3, z' = z0, z2 >= 0, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z3, 0, z1) + !EQ'(0, 0) :|: z1 >= 0, z = 1 + 0 + z1, z' = 1 + 0 + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z3, 1 + z02, z1) + !EQ'(1 + z02, 0) :|: z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' = 1 + 0 + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z1) + !EQ'(0, 1 + z01) :|: z1 >= 0, z01 >= 0, z = 1 + 0 + z1, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](!EQ(z0'', z1''), 1 + z1'', z3, 1 + z0'', z1) + !EQ'(1 + z0'', 1 + z1'') :|: z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z5 = v4, v0 >= 0, v4 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z4 = v3, v2 >= 0, v3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z3, z1) :|: z = 2, z1 >= 0, z0 >= 0, z5 = z3, z' = z0, z2 >= 0, z3 >= 0, z'' = z1, z4 = z2
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   prefix(z, z') -{ 0 }-> and(2, and(!EQ(z012, z22), prefix(z18, z32))) :|: z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(2, 2) :|: z = 1 + 0 + 1, z' = 1 + 0 + z3, z3 >= 0
   prefix(z, z') -{ 0 }-> and(2, 1) :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0
   prefix(z, z') -{ 0 }-> and(2, 0) :|: z1 >= 0, z = 1 + 0 + z1, z' = 1 + 0 + z3, z3 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(!EQ(z010, z21), prefix(z16, z31))) :|: z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(!EQ(z08, z2''), prefix(z14, z3''))) :|: z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(1, 2) :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0
   prefix(z, z') -{ 0 }-> and(1, 2) :|: z = 1 + (1 + z05) + 1, z' = 1 + 0 + z3, z05 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(1, 1) :|: z04 >= 0, z15 >= 0, z09 >= 0, z' = 1 + (1 + z04) + 1, z = 1 + 0 + (1 + z09 + z15)
   prefix(z, z') -{ 0 }-> and(1, 1) :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0
   prefix(z, z') -{ 0 }-> and(1, 0) :|: z04 >= 0, z1 >= 0, z = 1 + 0 + z1, z' = 1 + (1 + z04) + z3, z3 >= 0
   prefix(z, z') -{ 0 }-> and(1, 0) :|: z1 >= 0, z = 1 + (1 + z05) + z1, z' = 1 + 0 + z3, z05 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(!EQ(z014, z23), prefix(z110, z33))) :|: z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> and(0, 2) :|: z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + 1, z2 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(0, 1) :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z' = 1 + z2 + 1, z0 >= 0, z111 >= 0, z2 >= 0
   prefix(z, z') -{ 0 }-> and(0, 0) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), and(!EQ(z06, z2'), prefix(z12, z3'))) :|: z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), 2) :|: z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0, z = 1 + (1 + z03) + 1
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), 1) :|: z11 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z' = 1 + (1 + z11) + 1, z13 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), 0) :|: z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z0 >= 0, z' = z0
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1


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

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

   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1

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

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

   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z0 >= 0, z' = 1 + z0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z = 1 + z0, z0 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   !EQ(z, z') -{ 0 }-> !EQ(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   !EQ'(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   !EQ'(z, z') -{ 0 }-> 1 + !EQ'(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' = z0, z0 >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z'' = z2, z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z2 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(!EQ(z0', z1), prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z3) + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z'' = z3, z = 1 + z0' + z1', z2 >= 0, z3 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z3) + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z'' = z3, z2 >= 0, z3 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z0, 1 + z1 + z2, z3) + PREFIX(z0, 1 + z1 + z2) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z'' = z3, z2 >= 0, z3 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z4 = v3, v2 >= 0, v3 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z0, z2, 1 + z3 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z0 >= 0, z4 = z3, z' = z0, z2 >= 0, z3 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z0, z2, 1 + z3 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z0 >= 0, z4 = z3, z' = z0, z2 >= 0, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z3, 0, z1) + !EQ'(0, 0) :|: z1 >= 0, z = 1 + 0 + z1, z' = 1 + 0 + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z3, 1 + z02, z1) + !EQ'(1 + z02, 0) :|: z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' = 1 + 0 + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z1) + !EQ'(0, 1 + z01) :|: z1 >= 0, z01 >= 0, z = 1 + 0 + z1, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](!EQ(z0'', z1''), 1 + z1'', z3, 1 + z0'', z1) + !EQ'(1 + z0'', 1 + z1'') :|: z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z5 = v4, v0 >= 0, v4 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z4 = v3, v2 >= 0, v3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z3, z1) :|: z = 2, z1 >= 0, z0 >= 0, z5 = z3, z' = z0, z2 >= 0, z3 >= 0, z'' = z1, z4 = z2
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   prefix(z, z') -{ 0 }-> and(2, and(!EQ(z012, z22), prefix(z18, z32))) :|: z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(!EQ(z010, z21), prefix(z16, z31))) :|: z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(!EQ(z08, z2''), prefix(z14, z3''))) :|: z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(!EQ(z014, z23), prefix(z110, z33))) :|: z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), and(!EQ(z06, z2'), prefix(z12, z3'))) :|: z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), 2) :|: z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0, z = 1 + (1 + z03) + 1
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), 1) :|: z11 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z' = 1 + (1 + z11) + 1, z13 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), 0) :|: z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z0 >= 0, z' = z0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' = 1 + 0 + z3, z3 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z15 >= 0, z09 >= 0, z' = 1 + (1 + z04) + 1, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + 1, z' = 1 + 0 + z3, z05 >= 0, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z15 >= 0, z09 >= 0, z' = 1 + (1 + z04) + 1, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z1 >= 0, z = 1 + 0 + z1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + 1, z' = 1 + 0 + z3, z05 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z' = 1 + 0 + z3, z05 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' = 1 + 0 + z3, z3 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + 0 + z1, z' = 1 + 0 + z3, z3 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + 1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z' = 1 + z2 + 1, z0 >= 0, z111 >= 0, z2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1


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

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

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

   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ(z, z') -{ 0 }-> !EQ(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + !EQ'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(!EQ(z0', z1), prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z' - 1, 0, z - 1) + !EQ'(0, 0) :|: z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z' - 1, 1 + z02, z1) + !EQ'(1 + z02, 0) :|: z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z - 1) + !EQ'(0, 1 + z01) :|: z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](!EQ(z0'', z1''), 1 + z1'', z3, 1 + z0'', z1) + !EQ'(1 + z0'', 1 + z1'') :|: z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z5, z'') :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> and(2, and(!EQ(z012, z22), prefix(z18, z32))) :|: z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(!EQ(z010, z21), prefix(z16, z31))) :|: z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(!EQ(z08, z2''), prefix(z14, z3''))) :|: z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(!EQ(z014, z23), prefix(z110, z33))) :|: z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), and(!EQ(z06, z2'), prefix(z12, z3'))) :|: z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), 0) :|: z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z' - 3), 1) :|: z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z - 3, z11), 2) :|: z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1


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

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

   { !EQ }
   { and }
   { !EQ' }
   { EQNATLIST[ITE], EQNATLIST }
   { prefix }
   { PREFIX }
   { DOMATCH, DOMATCH[ITE] }

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

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

   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ(z, z') -{ 0 }-> !EQ(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + !EQ'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(!EQ(z0', z1), prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z' - 1, 0, z - 1) + !EQ'(0, 0) :|: z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z' - 1, 1 + z02, z1) + !EQ'(1 + z02, 0) :|: z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z - 1) + !EQ'(0, 1 + z01) :|: z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](!EQ(z0'', z1''), 1 + z1'', z3, 1 + z0'', z1) + !EQ'(1 + z0'', 1 + z1'') :|: z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z5, z'') :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> and(2, and(!EQ(z012, z22), prefix(z18, z32))) :|: z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(!EQ(z010, z21), prefix(z16, z31))) :|: z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(!EQ(z08, z2''), prefix(z14, z3''))) :|: z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(!EQ(z014, z23), prefix(z110, z33))) :|: z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), and(!EQ(z06, z2'), prefix(z12, z3'))) :|: z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), 0) :|: z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z' - 3), 1) :|: z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z - 3, z11), 2) :|: z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {!EQ}, {and}, {!EQ'}, {EQNATLIST[ITE],EQNATLIST}, {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}

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

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

   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ(z, z') -{ 0 }-> !EQ(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + !EQ'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(!EQ(z0', z1), prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z' - 1, 0, z - 1) + !EQ'(0, 0) :|: z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z' - 1, 1 + z02, z1) + !EQ'(1 + z02, 0) :|: z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z - 1) + !EQ'(0, 1 + z01) :|: z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](!EQ(z0'', z1''), 1 + z1'', z3, 1 + z0'', z1) + !EQ'(1 + z0'', 1 + z1'') :|: z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z5, z'') :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> and(2, and(!EQ(z012, z22), prefix(z18, z32))) :|: z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(!EQ(z010, z21), prefix(z16, z31))) :|: z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(!EQ(z08, z2''), prefix(z14, z3''))) :|: z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(!EQ(z014, z23), prefix(z110, z33))) :|: z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), and(!EQ(z06, z2'), prefix(z12, z3'))) :|: z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), 0) :|: z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z' - 3), 1) :|: z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z - 3, z11), 2) :|: z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {!EQ}, {and}, {!EQ'}, {EQNATLIST[ITE],EQNATLIST}, {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}

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

(31) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ(z, z') -{ 0 }-> !EQ(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + !EQ'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(!EQ(z0', z1), prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z' - 1, 0, z - 1) + !EQ'(0, 0) :|: z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z' - 1, 1 + z02, z1) + !EQ'(1 + z02, 0) :|: z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z - 1) + !EQ'(0, 1 + z01) :|: z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](!EQ(z0'', z1''), 1 + z1'', z3, 1 + z0'', z1) + !EQ'(1 + z0'', 1 + z1'') :|: z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z5, z'') :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> and(2, and(!EQ(z012, z22), prefix(z18, z32))) :|: z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(!EQ(z010, z21), prefix(z16, z31))) :|: z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(!EQ(z08, z2''), prefix(z14, z3''))) :|: z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(!EQ(z014, z23), prefix(z110, z33))) :|: z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), and(!EQ(z06, z2'), prefix(z12, z3'))) :|: z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), 0) :|: z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z' - 3), 1) :|: z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z - 3, z11), 2) :|: z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {!EQ}, {and}, {!EQ'}, {EQNATLIST[ITE],EQNATLIST}, {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: ?, size: O(1) [2]

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

(33) 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: 0

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

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

   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ(z, z') -{ 0 }-> !EQ(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + !EQ'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(!EQ(z0', z1), prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z' - 1, 0, z - 1) + !EQ'(0, 0) :|: z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z' - 1, 1 + z02, z1) + !EQ'(1 + z02, 0) :|: z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z - 1) + !EQ'(0, 1 + z01) :|: z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](!EQ(z0'', z1''), 1 + z1'', z3, 1 + z0'', z1) + !EQ'(1 + z0'', 1 + z1'') :|: z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z5, z'') :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> and(2, and(!EQ(z012, z22), prefix(z18, z32))) :|: z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(!EQ(z010, z21), prefix(z16, z31))) :|: z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(!EQ(z08, z2''), prefix(z14, z3''))) :|: z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(!EQ(z014, z23), prefix(z110, z33))) :|: z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), and(!EQ(z06, z2'), prefix(z12, z3'))) :|: z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z11), 0) :|: z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z03, z' - 3), 1) :|: z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> and(!EQ(z - 3, z11), 2) :|: z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {and}, {!EQ'}, {EQNATLIST[ITE],EQNATLIST}, {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + !EQ'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(s'', prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](s, 1 + z1'', z3, 1 + z0'', z1) + !EQ'(1 + z0'', 1 + z1'') :|: s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z' - 1, 0, z - 1) + !EQ'(0, 0) :|: z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z' - 1, 1 + z02, z1) + !EQ'(1 + z02, 0) :|: z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z - 1) + !EQ'(0, 1 + z01) :|: z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z5, z'') :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> and(s1, and(s2, prefix(z12, z3'))) :|: s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(s3, 2) :|: s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(s4, 1) :|: s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> and(s5, 0) :|: s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(2, and(s8, prefix(z18, z32))) :|: s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s6, prefix(z14, z3''))) :|: s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s7, prefix(z16, z31))) :|: s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(s9, prefix(z110, z33))) :|: s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {and}, {!EQ'}, {EQNATLIST[ITE],EQNATLIST}, {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]

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

(37) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + !EQ'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(s'', prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](s, 1 + z1'', z3, 1 + z0'', z1) + !EQ'(1 + z0'', 1 + z1'') :|: s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z' - 1, 0, z - 1) + !EQ'(0, 0) :|: z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z' - 1, 1 + z02, z1) + !EQ'(1 + z02, 0) :|: z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z - 1) + !EQ'(0, 1 + z01) :|: z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z5, z'') :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> and(s1, and(s2, prefix(z12, z3'))) :|: s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(s3, 2) :|: s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(s4, 1) :|: s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> and(s5, 0) :|: s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(2, and(s8, prefix(z18, z32))) :|: s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s6, prefix(z14, z3''))) :|: s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s7, prefix(z16, z31))) :|: s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(s9, prefix(z110, z33))) :|: s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {and}, {!EQ'}, {EQNATLIST[ITE],EQNATLIST}, {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: ?, size: O(1) [2]

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + !EQ'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(s'', prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](s, 1 + z1'', z3, 1 + z0'', z1) + !EQ'(1 + z0'', 1 + z1'') :|: s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z' - 1, 0, z - 1) + !EQ'(0, 0) :|: z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z' - 1, 1 + z02, z1) + !EQ'(1 + z02, 0) :|: z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z - 1) + !EQ'(0, 1 + z01) :|: z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z5, z'') :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> and(s1, and(s2, prefix(z12, z3'))) :|: s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(s3, 2) :|: s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(s4, 1) :|: s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> and(s5, 0) :|: s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(2, and(s8, prefix(z18, z32))) :|: s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s6, prefix(z14, z3''))) :|: s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s7, prefix(z16, z31))) :|: s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(s9, prefix(z110, z33))) :|: s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {!EQ'}, {EQNATLIST[ITE],EQNATLIST}, {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + !EQ'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(s'', prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](s, 1 + z1'', z3, 1 + z0'', z1) + !EQ'(1 + z0'', 1 + z1'') :|: s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z' - 1, 0, z - 1) + !EQ'(0, 0) :|: z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z' - 1, 1 + z02, z1) + !EQ'(1 + z02, 0) :|: z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z - 1) + !EQ'(0, 1 + z01) :|: z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z5, z'') :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(s1, and(s2, prefix(z12, z3'))) :|: s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(2, and(s8, prefix(z18, z32))) :|: s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s6, prefix(z14, z3''))) :|: s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s7, prefix(z16, z31))) :|: s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(s9, prefix(z110, z33))) :|: s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {!EQ'}, {EQNATLIST[ITE],EQNATLIST}, {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]

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

(43) 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: z'

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + !EQ'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(s'', prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](s, 1 + z1'', z3, 1 + z0'', z1) + !EQ'(1 + z0'', 1 + z1'') :|: s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z' - 1, 0, z - 1) + !EQ'(0, 0) :|: z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z' - 1, 1 + z02, z1) + !EQ'(1 + z02, 0) :|: z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z - 1) + !EQ'(0, 1 + z01) :|: z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z5, z'') :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(s1, and(s2, prefix(z12, z3'))) :|: s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(2, and(s8, prefix(z18, z32))) :|: s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s6, prefix(z14, z3''))) :|: s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s7, prefix(z16, z31))) :|: s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(s9, prefix(z110, z33))) :|: s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {!EQ'}, {EQNATLIST[ITE],EQNATLIST}, {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]
  !EQ': runtime: ?, size: O(n^1) [z']

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

(45) 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: 0

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + !EQ'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(s'', prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](s, 1 + z1'', z3, 1 + z0'', z1) + !EQ'(1 + z0'', 1 + z1'') :|: s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z' - 1, 0, z - 1) + !EQ'(0, 0) :|: z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z' - 1, 1 + z02, z1) + !EQ'(1 + z02, 0) :|: z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z - 1) + !EQ'(0, 1 + z01) :|: z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z5, z'') :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + !EQ'(z0, z2) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(s1, and(s2, prefix(z12, z3'))) :|: s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(2, and(s8, prefix(z18, z32))) :|: s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s6, prefix(z14, z3''))) :|: s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s7, prefix(z16, z31))) :|: s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(s9, prefix(z110, z33))) :|: s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {EQNATLIST[ITE],EQNATLIST}, {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]
  !EQ': runtime: O(1) [0], size: O(n^1) [z']

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

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + s19 :|: s19 >= 0, s19 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(s'', prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](s, 1 + z1'', z3, 1 + z0'', z1) + s13 :|: s13 >= 0, s13 <= 1 + z1'', s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z' - 1, 0, z - 1) + s16 :|: s16 >= 0, s16 <= 0, z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z' - 1, 1 + z02, z1) + s15 :|: s15 >= 0, s15 <= 0, z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z - 1) + s14 :|: s14 >= 0, s14 <= 1 + z01, z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + s17 :|: s17 >= 0, s17 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z5, z'') :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + s18 :|: s18 >= 0, s18 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(s1, and(s2, prefix(z12, z3'))) :|: s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(2, and(s8, prefix(z18, z32))) :|: s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s6, prefix(z14, z3''))) :|: s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s7, prefix(z16, z31))) :|: s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(s9, prefix(z110, z33))) :|: s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {EQNATLIST[ITE],EQNATLIST}, {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]
  !EQ': runtime: O(1) [0], size: O(n^1) [z']

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

(49) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + s19 :|: s19 >= 0, s19 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(s'', prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](s, 1 + z1'', z3, 1 + z0'', z1) + s13 :|: s13 >= 0, s13 <= 1 + z1'', s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z' - 1, 0, z - 1) + s16 :|: s16 >= 0, s16 <= 0, z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z' - 1, 1 + z02, z1) + s15 :|: s15 >= 0, s15 <= 0, z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z - 1) + s14 :|: s14 >= 0, s14 <= 1 + z01, z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + s17 :|: s17 >= 0, s17 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z5, z'') :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + s18 :|: s18 >= 0, s18 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(s1, and(s2, prefix(z12, z3'))) :|: s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(2, and(s8, prefix(z18, z32))) :|: s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s6, prefix(z14, z3''))) :|: s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s7, prefix(z16, z31))) :|: s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(s9, prefix(z110, z33))) :|: s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {EQNATLIST[ITE],EQNATLIST}, {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]
  !EQ': runtime: O(1) [0], size: O(n^1) [z']
  EQNATLIST[ITE]: runtime: ?, size: O(n^1) [3 + 2*z'']
  EQNATLIST: runtime: ?, size: O(n^1) [4*z']

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using KoAT for: EQNATLIST[ITE]
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 8 + 10*z5

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

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + s19 :|: s19 >= 0, s19 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(s'', prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](s, 1 + z1'', z3, 1 + z0'', z1) + s13 :|: s13 >= 0, s13 <= 1 + z1'', s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](2, 0, z' - 1, 0, z - 1) + s16 :|: s16 >= 0, s16 <= 0, z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 0, z' - 1, 1 + z02, z1) + s15 :|: s15 >= 0, s15 <= 0, z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](1, 1 + z01, z3, 0, z - 1) + s14 :|: s14 >= 0, s14 <= 1 + z01, z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 1 }-> 1 + EQNATLIST[ITE](0, z2, z3, z0, z1) + s17 :|: s17 >= 0, s17 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 1 + EQNATLIST(z5, z'') :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + s18 :|: s18 >= 0, s18 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(s1, and(s2, prefix(z12, z3'))) :|: s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(2, and(s8, prefix(z18, z32))) :|: s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s6, prefix(z14, z3''))) :|: s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s7, prefix(z16, z31))) :|: s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(s9, prefix(z110, z33))) :|: s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]
  !EQ': runtime: O(1) [0], size: O(n^1) [z']
  EQNATLIST[ITE]: runtime: O(n^1) [8 + 10*z5], size: O(n^1) [3 + 2*z'']
  EQNATLIST: runtime: O(n^1) [11 + 10*z], size: O(n^1) [4*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:

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + s19 :|: s19 >= 0, s19 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(s'', prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s20 + s13 :|: s20 >= 0, s20 <= 2 * z3 + 3, s13 >= 0, s13 <= 1 + z1'', s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s21 + s14 :|: s21 >= 0, s21 <= 2 * z3 + 3, s14 >= 0, s14 <= 1 + z01, z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s22 + s15 :|: s22 >= 0, s22 <= 2 * (z' - 1) + 3, s15 >= 0, s15 <= 0, z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s23 + s16 :|: s23 >= 0, s23 <= 2 * (z' - 1) + 3, s16 >= 0, s16 <= 0, z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s24 + s17 :|: s24 >= 0, s24 <= 2 * z3 + 3, s17 >= 0, s17 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 11 + 10*z5 }-> 1 + s25 :|: s25 >= 0, s25 <= 4 * z'', z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + s18 :|: s18 >= 0, s18 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(s1, and(s2, prefix(z12, z3'))) :|: s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(2, and(s8, prefix(z18, z32))) :|: s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s6, prefix(z14, z3''))) :|: s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s7, prefix(z16, z31))) :|: s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(s9, prefix(z110, z33))) :|: s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]
  !EQ': runtime: O(1) [0], size: O(n^1) [z']
  EQNATLIST[ITE]: runtime: O(n^1) [8 + 10*z5], size: O(n^1) [3 + 2*z'']
  EQNATLIST: runtime: O(n^1) [11 + 10*z], size: O(n^1) [4*z']

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

(55) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + s19 :|: s19 >= 0, s19 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(s'', prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s20 + s13 :|: s20 >= 0, s20 <= 2 * z3 + 3, s13 >= 0, s13 <= 1 + z1'', s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s21 + s14 :|: s21 >= 0, s21 <= 2 * z3 + 3, s14 >= 0, s14 <= 1 + z01, z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s22 + s15 :|: s22 >= 0, s22 <= 2 * (z' - 1) + 3, s15 >= 0, s15 <= 0, z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s23 + s16 :|: s23 >= 0, s23 <= 2 * (z' - 1) + 3, s16 >= 0, s16 <= 0, z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s24 + s17 :|: s24 >= 0, s24 <= 2 * z3 + 3, s17 >= 0, s17 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 11 + 10*z5 }-> 1 + s25 :|: s25 >= 0, s25 <= 4 * z'', z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + s18 :|: s18 >= 0, s18 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(s1, and(s2, prefix(z12, z3'))) :|: s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(2, and(s8, prefix(z18, z32))) :|: s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s6, prefix(z14, z3''))) :|: s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s7, prefix(z16, z31))) :|: s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(s9, prefix(z110, z33))) :|: s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {prefix}, {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]
  !EQ': runtime: O(1) [0], size: O(n^1) [z']
  EQNATLIST[ITE]: runtime: O(n^1) [8 + 10*z5], size: O(n^1) [3 + 2*z'']
  EQNATLIST: runtime: O(n^1) [11 + 10*z], size: O(n^1) [4*z']
  prefix: runtime: ?, size: O(1) [2]

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + s19 :|: s19 >= 0, s19 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](and(s'', prefix(z1', z2)), 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s20 + s13 :|: s20 >= 0, s20 <= 2 * z3 + 3, s13 >= 0, s13 <= 1 + z1'', s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s21 + s14 :|: s21 >= 0, s21 <= 2 * z3 + 3, s14 >= 0, s14 <= 1 + z01, z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s22 + s15 :|: s22 >= 0, s22 <= 2 * (z' - 1) + 3, s15 >= 0, s15 <= 0, z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s23 + s16 :|: s23 >= 0, s23 <= 2 * (z' - 1) + 3, s16 >= 0, s16 <= 0, z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s24 + s17 :|: s24 >= 0, s24 <= 2 * z3 + 3, s17 >= 0, s17 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 11 + 10*z5 }-> 1 + s25 :|: s25 >= 0, s25 <= 4 * z'', z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + s18 :|: s18 >= 0, s18 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> and(s1, and(s2, prefix(z12, z3'))) :|: s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> and(2, and(s8, prefix(z18, z32))) :|: s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s6, prefix(z14, z3''))) :|: s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> and(1, and(s7, prefix(z16, z31))) :|: s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> and(0, and(s9, prefix(z110, z33))) :|: s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]
  !EQ': runtime: O(1) [0], size: O(n^1) [z']
  EQNATLIST[ITE]: runtime: O(n^1) [8 + 10*z5], size: O(n^1) [3 + 2*z'']
  EQNATLIST: runtime: O(n^1) [11 + 10*z], size: O(n^1) [4*z']
  prefix: runtime: O(1) [0], size: O(1) [2]

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + s19 :|: s19 >= 0, s19 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](s27, 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s26 >= 0, s26 <= 2, s27 >= 0, s27 <= 2, s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s20 + s13 :|: s20 >= 0, s20 <= 2 * z3 + 3, s13 >= 0, s13 <= 1 + z1'', s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s21 + s14 :|: s21 >= 0, s21 <= 2 * z3 + 3, s14 >= 0, s14 <= 1 + z01, z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s22 + s15 :|: s22 >= 0, s22 <= 2 * (z' - 1) + 3, s15 >= 0, s15 <= 0, z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s23 + s16 :|: s23 >= 0, s23 <= 2 * (z' - 1) + 3, s16 >= 0, s16 <= 0, z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s24 + s17 :|: s24 >= 0, s24 <= 2 * z3 + 3, s17 >= 0, s17 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 11 + 10*z5 }-> 1 + s25 :|: s25 >= 0, s25 <= 4 * z'', z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + s18 :|: s18 >= 0, s18 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s30 :|: s28 >= 0, s28 <= 2, s29 >= 0, s29 <= 2, s30 >= 0, s30 <= 2, s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> s33 :|: s31 >= 0, s31 <= 2, s32 >= 0, s32 <= 2, s33 >= 0, s33 <= 2, s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> s36 :|: s34 >= 0, s34 <= 2, s35 >= 0, s35 <= 2, s36 >= 0, s36 <= 2, s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> s39 :|: s37 >= 0, s37 <= 2, s38 >= 0, s38 <= 2, s39 >= 0, s39 <= 2, s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> s42 :|: s40 >= 0, s40 <= 2, s41 >= 0, s41 <= 2, s42 >= 0, s42 <= 2, s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]
  !EQ': runtime: O(1) [0], size: O(n^1) [z']
  EQNATLIST[ITE]: runtime: O(n^1) [8 + 10*z5], size: O(n^1) [3 + 2*z'']
  EQNATLIST: runtime: O(n^1) [11 + 10*z], size: O(n^1) [4*z']
  prefix: runtime: O(1) [0], size: O(1) [2]

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

(61) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + s19 :|: s19 >= 0, s19 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](s27, 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s26 >= 0, s26 <= 2, s27 >= 0, s27 <= 2, s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s20 + s13 :|: s20 >= 0, s20 <= 2 * z3 + 3, s13 >= 0, s13 <= 1 + z1'', s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s21 + s14 :|: s21 >= 0, s21 <= 2 * z3 + 3, s14 >= 0, s14 <= 1 + z01, z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s22 + s15 :|: s22 >= 0, s22 <= 2 * (z' - 1) + 3, s15 >= 0, s15 <= 0, z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s23 + s16 :|: s23 >= 0, s23 <= 2 * (z' - 1) + 3, s16 >= 0, s16 <= 0, z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s24 + s17 :|: s24 >= 0, s24 <= 2 * z3 + 3, s17 >= 0, s17 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 11 + 10*z5 }-> 1 + s25 :|: s25 >= 0, s25 <= 4 * z'', z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + s18 :|: s18 >= 0, s18 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s30 :|: s28 >= 0, s28 <= 2, s29 >= 0, s29 <= 2, s30 >= 0, s30 <= 2, s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> s33 :|: s31 >= 0, s31 <= 2, s32 >= 0, s32 <= 2, s33 >= 0, s33 <= 2, s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> s36 :|: s34 >= 0, s34 <= 2, s35 >= 0, s35 <= 2, s36 >= 0, s36 <= 2, s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> s39 :|: s37 >= 0, s37 <= 2, s38 >= 0, s38 <= 2, s39 >= 0, s39 <= 2, s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> s42 :|: s40 >= 0, s40 <= 2, s41 >= 0, s41 <= 2, s42 >= 0, s42 <= 2, s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {PREFIX}, {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]
  !EQ': runtime: O(1) [0], size: O(n^1) [z']
  EQNATLIST[ITE]: runtime: O(n^1) [8 + 10*z5], size: O(n^1) [3 + 2*z'']
  EQNATLIST: runtime: O(n^1) [11 + 10*z], size: O(n^1) [4*z']
  prefix: runtime: O(1) [0], size: O(1) [2]
  PREFIX: runtime: ?, size: O(n^1) [z']

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

(63) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + s19 :|: s19 >= 0, s19 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](s27, 1 + z0' + z1', 1 + z1 + z2, z'') + PREFIX(1 + z0' + z1', 1 + z1 + z2) :|: s26 >= 0, s26 <= 2, s27 >= 0, s27 <= 2, s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + PREFIX(1, 1 + z1 + z2) :|: z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + PREFIX(z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s20 + s13 :|: s20 >= 0, s20 <= 2 * z3 + 3, s13 >= 0, s13 <= 1 + z1'', s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s21 + s14 :|: s21 >= 0, s21 <= 2 * z3 + 3, s14 >= 0, s14 <= 1 + z01, z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s22 + s15 :|: s22 >= 0, s22 <= 2 * (z' - 1) + 3, s15 >= 0, s15 <= 0, z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s23 + s16 :|: s23 >= 0, s23 <= 2 * (z' - 1) + 3, s16 >= 0, s16 <= 0, z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s24 + s17 :|: s24 >= 0, s24 <= 2 * z3 + 3, s17 >= 0, s17 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 11 + 10*z5 }-> 1 + s25 :|: s25 >= 0, s25 <= 4 * z'', z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + s18 :|: s18 >= 0, s18 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + PREFIX(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s30 :|: s28 >= 0, s28 <= 2, s29 >= 0, s29 <= 2, s30 >= 0, s30 <= 2, s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> s33 :|: s31 >= 0, s31 <= 2, s32 >= 0, s32 <= 2, s33 >= 0, s33 <= 2, s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> s36 :|: s34 >= 0, s34 <= 2, s35 >= 0, s35 <= 2, s36 >= 0, s36 <= 2, s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> s39 :|: s37 >= 0, s37 <= 2, s38 >= 0, s38 <= 2, s39 >= 0, s39 <= 2, s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> s42 :|: s40 >= 0, s40 <= 2, s41 >= 0, s41 <= 2, s42 >= 0, s42 <= 2, s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]
  !EQ': runtime: O(1) [0], size: O(n^1) [z']
  EQNATLIST[ITE]: runtime: O(n^1) [8 + 10*z5], size: O(n^1) [3 + 2*z'']
  EQNATLIST: runtime: O(n^1) [11 + 10*z], size: O(n^1) [4*z']
  prefix: runtime: O(1) [0], size: O(1) [2]
  PREFIX: runtime: O(n^1) [2 + z'], size: O(n^1) [z']

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

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + s19 :|: s19 >= 0, s19 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 4 + z1 + z2 }-> 1 + DOMATCH[ITE](s27, 1 + z0' + z1', 1 + z1 + z2, z'') + s46 :|: s46 >= 0, s46 <= 1 + z1 + z2, s26 >= 0, s26 <= 2, s27 >= 0, s27 <= 2, s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 4 + z1 + z2 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + s43 :|: s43 >= 0, s43 <= 1 + z1 + z2, z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 4 + z1 + z2 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + s44 :|: s44 >= 0, s44 <= 1 + z1 + z2, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s20 + s13 :|: s20 >= 0, s20 <= 2 * z3 + 3, s13 >= 0, s13 <= 1 + z1'', s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s21 + s14 :|: s21 >= 0, s21 <= 2 * z3 + 3, s14 >= 0, s14 <= 1 + z01, z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s22 + s15 :|: s22 >= 0, s22 <= 2 * (z' - 1) + 3, s15 >= 0, s15 <= 0, z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s23 + s16 :|: s23 >= 0, s23 <= 2 * (z' - 1) + 3, s16 >= 0, s16 <= 0, z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s24 + s17 :|: s24 >= 0, s24 <= 2 * z3 + 3, s17 >= 0, s17 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 11 + 10*z5 }-> 1 + s25 :|: s25 >= 0, s25 <= 4 * z'', z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + s18 :|: s18 >= 0, s18 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 3 + z3 }-> 1 + s45 :|: s45 >= 0, s45 <= z3, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s30 :|: s28 >= 0, s28 <= 2, s29 >= 0, s29 <= 2, s30 >= 0, s30 <= 2, s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> s33 :|: s31 >= 0, s31 <= 2, s32 >= 0, s32 <= 2, s33 >= 0, s33 <= 2, s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> s36 :|: s34 >= 0, s34 <= 2, s35 >= 0, s35 <= 2, s36 >= 0, s36 <= 2, s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> s39 :|: s37 >= 0, s37 <= 2, s38 >= 0, s38 <= 2, s39 >= 0, s39 <= 2, s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> s42 :|: s40 >= 0, s40 <= 2, s41 >= 0, s41 <= 2, s42 >= 0, s42 <= 2, s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]
  !EQ': runtime: O(1) [0], size: O(n^1) [z']
  EQNATLIST[ITE]: runtime: O(n^1) [8 + 10*z5], size: O(n^1) [3 + 2*z'']
  EQNATLIST: runtime: O(n^1) [11 + 10*z], size: O(n^1) [4*z']
  prefix: runtime: O(1) [0], size: O(1) [2]
  PREFIX: runtime: O(n^1) [2 + z'], size: O(n^1) [z']

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

(67) IntTrsBoundProof (UPPER BOUND(ID))

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

Computed SIZE bound using KoAT for: DOMATCH[ITE]
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 8 + 6*z'' + 2*z''^2

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + s19 :|: s19 >= 0, s19 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 4 + z1 + z2 }-> 1 + DOMATCH[ITE](s27, 1 + z0' + z1', 1 + z1 + z2, z'') + s46 :|: s46 >= 0, s46 <= 1 + z1 + z2, s26 >= 0, s26 <= 2, s27 >= 0, s27 <= 2, s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 4 + z1 + z2 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + s43 :|: s43 >= 0, s43 <= 1 + z1 + z2, z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 4 + z1 + z2 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + s44 :|: s44 >= 0, s44 <= 1 + z1 + z2, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s20 + s13 :|: s20 >= 0, s20 <= 2 * z3 + 3, s13 >= 0, s13 <= 1 + z1'', s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s21 + s14 :|: s21 >= 0, s21 <= 2 * z3 + 3, s14 >= 0, s14 <= 1 + z01, z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s22 + s15 :|: s22 >= 0, s22 <= 2 * (z' - 1) + 3, s15 >= 0, s15 <= 0, z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s23 + s16 :|: s23 >= 0, s23 <= 2 * (z' - 1) + 3, s16 >= 0, s16 <= 0, z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s24 + s17 :|: s24 >= 0, s24 <= 2 * z3 + 3, s17 >= 0, s17 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 11 + 10*z5 }-> 1 + s25 :|: s25 >= 0, s25 <= 4 * z'', z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + s18 :|: s18 >= 0, s18 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 3 + z3 }-> 1 + s45 :|: s45 >= 0, s45 <= z3, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s30 :|: s28 >= 0, s28 <= 2, s29 >= 0, s29 <= 2, s30 >= 0, s30 <= 2, s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> s33 :|: s31 >= 0, s31 <= 2, s32 >= 0, s32 <= 2, s33 >= 0, s33 <= 2, s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> s36 :|: s34 >= 0, s34 <= 2, s35 >= 0, s35 <= 2, s36 >= 0, s36 <= 2, s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> s39 :|: s37 >= 0, s37 <= 2, s38 >= 0, s38 <= 2, s39 >= 0, s39 <= 2, s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> s42 :|: s40 >= 0, s40 <= 2, s41 >= 0, s41 <= 2, s42 >= 0, s42 <= 2, s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: {DOMATCH,DOMATCH[ITE]}
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]
  !EQ': runtime: O(1) [0], size: O(n^1) [z']
  EQNATLIST[ITE]: runtime: O(n^1) [8 + 10*z5], size: O(n^1) [3 + 2*z'']
  EQNATLIST: runtime: O(n^1) [11 + 10*z], size: O(n^1) [4*z']
  prefix: runtime: O(1) [0], size: O(1) [2]
  PREFIX: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  DOMATCH: runtime: ?, size: O(n^2) [3 + 3*z' + z'^2]
  DOMATCH[ITE]: runtime: ?, size: O(n^2) [8 + 6*z'' + 2*z''^2]

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

(69) IntTrsBoundProof (UPPER BOUND(ID))

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

Computed RUNTIME bound using KoAT for: DOMATCH[ITE]
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 18 + 12*z'' + 2*z''^2

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

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

   !EQ(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z - 1 >= 0
   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ'(z, z') -{ 0 }-> 1 + s19 :|: s19 >= 0, s19 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   DOMATCH(z, z', z'') -{ 1 }-> 1 :|: z = 1, z'' >= 0, z' = 1
   DOMATCH(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1, z'' >= 0
   DOMATCH(z, z', z'') -{ 4 + z1 + z2 }-> 1 + DOMATCH[ITE](s27, 1 + z0' + z1', 1 + z1 + z2, z'') + s46 :|: s46 >= 0, s46 <= 1 + z1 + z2, s26 >= 0, s26 <= 2, s27 >= 0, s27 <= 2, s'' >= 0, s'' <= 2, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 4 + z1 + z2 }-> 1 + DOMATCH[ITE](2, 1, 1 + z1 + z2, z'') + s43 :|: s43 >= 0, s43 <= 1 + z1 + z2, z1 >= 0, z = 1, z' = 1 + z1 + z2, z2 >= 0, z'' >= 0
   DOMATCH(z, z', z'') -{ 4 + z1 + z2 }-> 1 + DOMATCH[ITE](0, z, 1 + z1 + z2, z'') + s44 :|: s44 >= 0, s44 <= 1 + z1 + z2, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   DOMATCH[ITE](z, z', z'', z4) -{ 0 }-> 1 + DOMATCH(z', z2, 1 + z4 + (1 + 1 + 1)) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0, z4 >= 0
   EQNATLIST(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   EQNATLIST(z, z') -{ 1 }-> 1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0
   EQNATLIST(z, z') -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s20 + s13 :|: s20 >= 0, s20 <= 2 * z3 + 3, s13 >= 0, s13 <= 1 + z1'', s >= 0, s <= 2, z' = 1 + (1 + z1'') + z3, z1 >= 0, z = 1 + (1 + z0'') + z1, z0'' >= 0, z3 >= 0, z1'' >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s21 + s14 :|: s21 >= 0, s21 <= 2 * z3 + 3, s14 >= 0, s14 <= 1 + z01, z - 1 >= 0, z01 >= 0, z' = 1 + (1 + z01) + z3, z3 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s22 + s15 :|: s22 >= 0, s22 <= 2 * (z' - 1) + 3, s15 >= 0, s15 <= 0, z1 >= 0, z = 1 + (1 + z02) + z1, z02 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ -1 + 10*z }-> 1 + s23 + s16 :|: s23 >= 0, s23 <= 2 * (z' - 1) + 3, s16 >= 0, s16 <= 0, z - 1 >= 0, z' - 1 >= 0
   EQNATLIST(z, z') -{ 9 + 10*z1 }-> 1 + s24 + s17 :|: s24 >= 0, s24 <= 2 * z3 + 3, s17 >= 0, s17 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   EQNATLIST[ITE](z, z', z'', z4, z5) -{ 11 + 10*z5 }-> 1 + s25 :|: s25 >= 0, s25 <= 4 * z'', z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   PREFIX(z, z') -{ 1 }-> 1 + s18 :|: s18 >= 0, s18 <= z2, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   PREFIX(z, z') -{ 3 + z3 }-> 1 + s45 :|: s45 >= 0, s45 <= z3, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> s10 :|: s10 >= 0, s10 <= 2, s3 >= 0, s3 <= 2, z11 >= 0, z' = 1 + (1 + z11) + z3, z - 3 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s11 :|: s11 >= 0, s11 <= 2, s4 >= 0, s4 <= 2, z' - 3 >= 0, z07 >= 0, z = 1 + (1 + z03) + (1 + z07 + z13), z03 >= 0, z13 >= 0
   prefix(z, z') -{ 0 }-> s12 :|: s12 >= 0, s12 <= 2, s5 >= 0, s5 <= 2, z = 1 + (1 + z03) + z1, z1 >= 0, z11 >= 0, z' = 1 + (1 + z11) + z3, z03 >= 0, z3 >= 0
   prefix(z, z') -{ 0 }-> s30 :|: s28 >= 0, s28 <= 2, s29 >= 0, s29 <= 2, s30 >= 0, s30 <= 2, s1 >= 0, s1 <= 2, s2 >= 0, s2 <= 2, z = 1 + (1 + z03) + (1 + z06 + z12), z11 >= 0, z3' >= 0, z' = 1 + (1 + z11) + (1 + z2' + z3'), z06 >= 0, z2' >= 0, z12 >= 0, z03 >= 0
   prefix(z, z') -{ 0 }-> s33 :|: s31 >= 0, s31 <= 2, s32 >= 0, s32 <= 2, s33 >= 0, s33 <= 2, s6 >= 0, s6 <= 2, z08 >= 0, z04 >= 0, z' = 1 + (1 + z04) + (1 + z2'' + z3''), z3'' >= 0, z = 1 + 0 + (1 + z08 + z14), z2'' >= 0, z14 >= 0
   prefix(z, z') -{ 0 }-> s36 :|: s34 >= 0, s34 <= 2, s35 >= 0, s35 <= 2, s36 >= 0, s36 <= 2, s7 >= 0, s7 <= 2, z21 >= 0, z31 >= 0, z = 1 + (1 + z05) + (1 + z010 + z16), z16 >= 0, z05 >= 0, z' = 1 + 0 + (1 + z21 + z31), z010 >= 0
   prefix(z, z') -{ 0 }-> s39 :|: s37 >= 0, s37 <= 2, s38 >= 0, s38 <= 2, s39 >= 0, s39 <= 2, s8 >= 0, s8 <= 2, z18 >= 0, z32 >= 0, z = 1 + 0 + (1 + z012 + z18), z012 >= 0, z' = 1 + 0 + (1 + z22 + z32), z22 >= 0
   prefix(z, z') -{ 0 }-> s42 :|: s40 >= 0, s40 <= 2, s41 >= 0, s41 <= 2, s42 >= 0, s42 <= 2, s9 >= 0, s9 <= 2, z110 >= 0, z' = 1 + z2 + (1 + z23 + z33), z = 1 + z0 + (1 + z014 + z110), z014 >= 0, z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1, z' >= 0
   prefix(z, z') -{ 0 }-> 2 :|: z = 1 + 0 + 1, z' - 1 >= 0, 2 = 2
   prefix(z, z') -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z' = 1, z = 1 + z0 + z1
   prefix(z, z') -{ 0 }-> 1 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z - 3 >= 0, z' - 1 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, 1 = 1
   prefix(z, z') -{ 0 }-> 1 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, 2 = 2, 1 = 1
   prefix(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z = 1 + 0 + 1, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' - 3 >= 0, z15 >= 0, z09 >= 0, z = 1 + 0 + (1 + z09 + z15), v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z04 >= 0, z - 1 >= 0, z' = 1 + (1 + z04) + z3, z3 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + z05) + (1 + z011 + z17), z011 >= 0, z' = 1 + 0 + 1, z17 >= 0, z05 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z = 1 + (1 + z05) + z1, z05 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 1 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z = 1 + 0 + 1, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + 0 + 1, z19 >= 0, z = 1 + 0 + (1 + z013 + z19), z013 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, v1 >= 0, 2 = v0, 0 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z' = 1 + z2 + z3, z - 2 >= 0, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 2 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z015 >= 0, z = 1 + z0 + (1 + z015 + z111), z0 >= 0, z111 >= 0, z' - 2 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 1 = v1
   prefix(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0, v0 >= 0, v1 >= 0, 0 = v0, 0 = v1

Function symbols to be analyzed: 
Previous analysis results are:
  !EQ: runtime: O(1) [0], size: O(1) [2]
  and: runtime: O(1) [0], size: O(1) [2]
  !EQ': runtime: O(1) [0], size: O(n^1) [z']
  EQNATLIST[ITE]: runtime: O(n^1) [8 + 10*z5], size: O(n^1) [3 + 2*z'']
  EQNATLIST: runtime: O(n^1) [11 + 10*z], size: O(n^1) [4*z']
  prefix: runtime: O(1) [0], size: O(1) [2]
  PREFIX: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  DOMATCH: runtime: O(n^2) [9 + 6*z' + z'^2], size: O(n^2) [3 + 3*z' + z'^2]
  DOMATCH[ITE]: runtime: O(n^2) [18 + 12*z'' + 2*z''^2], size: O(n^2) [8 + 6*z'' + 2*z''^2]

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

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

(72)
BOUNDS(1, n^2)