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


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


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


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

(0) CpxTRS
(1) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
(2) CpxWeightedTrs
    (3) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (4) CpxTypedWeightedTrs
    (5) CompletionProof [UPPER BOUND(ID), 0 ms]
    (6) CpxTypedWeightedCompleteTrs
    (7) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (8) CpxTypedWeightedCompleteTrs
    (9) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
    (10) CpxRNTS
    (11) InliningProof [UPPER BOUND(ID), 999 ms]
    (12) CpxRNTS
    (13) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (14) CpxRNTS
    (15) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
    (16) CpxRNTS
    (17) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (18) CpxRNTS
    (19) IntTrsBoundProof [UPPER BOUND(ID), 288 ms]
    (20) CpxRNTS
    (21) IntTrsBoundProof [UPPER BOUND(ID), 74 ms]
    (22) CpxRNTS
    (23) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (24) CpxRNTS
    (25) IntTrsBoundProof [UPPER BOUND(ID), 291 ms]
    (26) CpxRNTS
    (27) IntTrsBoundProof [UPPER BOUND(ID), 92 ms]
    (28) CpxRNTS
    (29) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (30) CpxRNTS
    (31) IntTrsBoundProof [UPPER BOUND(ID), 127 ms]
    (32) CpxRNTS
    (33) IntTrsBoundProof [UPPER BOUND(ID), 52 ms]
    (34) CpxRNTS
    (35) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (36) CpxRNTS
    (37) IntTrsBoundProof [UPPER BOUND(ID), 259 ms]
    (38) CpxRNTS
    (39) IntTrsBoundProof [UPPER BOUND(ID), 72 ms]
    (40) CpxRNTS
    (41) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (42) CpxRNTS
    (43) IntTrsBoundProof [UPPER BOUND(ID), 278 ms]
    (44) CpxRNTS
    (45) IntTrsBoundProof [UPPER BOUND(ID), 83 ms]
    (46) CpxRNTS
    (47) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (48) CpxRNTS
    (49) IntTrsBoundProof [UPPER BOUND(ID), 1842 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), 1033 ms]
    (56) CpxRNTS
    (57) IntTrsBoundProof [UPPER BOUND(ID), 863 ms]
    (58) CpxRNTS
    (59) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (60) CpxRNTS
    (61) IntTrsBoundProof [UPPER BOUND(ID), 353 ms]
    (62) CpxRNTS
    (63) IntTrsBoundProof [UPPER BOUND(ID), 45 ms]
    (64) CpxRNTS
    (65) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (66) CpxRNTS
    (67) IntTrsBoundProof [UPPER BOUND(ID), 227 ms]
    (68) CpxRNTS
    (69) IntTrsBoundProof [UPPER BOUND(ID), 0 ms]
    (70) CpxRNTS
    (71) FinalProof [FINISHED, 0 ms]
    (72) BOUNDS(1, n^2)
(73) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms]
(74) TRS for Loop Detection
    (75) DecreasingLoopProof [LOWER BOUND(ID), 0 ms]
    (76) BEST
        (77) proven lower bound
            (78) LowerBoundPropagationProof [FINISHED, 0 ms]
            (79) BOUNDS(n^1, INF)
        (80) TRS for Loop Detection


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

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


The TRS R consists of the following rules:

   if(true, t, e) -> t
   if(false, t, e) -> e
   member(x, nil) -> false
   member(x, cons(y, ys)) -> if(eq(x, y), true, member(x, ys))
   eq(nil, nil) -> true
   eq(O(x), 0(y)) -> eq(x, y)
   eq(0(x), 1(y)) -> false
   eq(1(x), 0(y)) -> false
   eq(1(x), 1(y)) -> eq(x, y)
   negate(0(x)) -> 1(x)
   negate(1(x)) -> 0(x)
   choice(cons(x, xs)) -> x
   choice(cons(x, xs)) -> choice(xs)
   guess(nil) -> nil
   guess(cons(clause, cnf)) -> cons(choice(clause), guess(cnf))
   verify(nil) -> true
   verify(cons(l, ls)) -> if(member(negate(l), ls), false, verify(ls))
   sat(cnf) -> satck(cnf, guess(cnf))
   satck(cnf, assign) -> if(verify(assign), assign, unsat)

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

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

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

   if(true, t, e) -> t [1]
   if(false, t, e) -> e [1]
   member(x, nil) -> false [1]
   member(x, cons(y, ys)) -> if(eq(x, y), true, member(x, ys)) [1]
   eq(nil, nil) -> true [1]
   eq(O(x), 0(y)) -> eq(x, y) [1]
   eq(0(x), 1(y)) -> false [1]
   eq(1(x), 0(y)) -> false [1]
   eq(1(x), 1(y)) -> eq(x, y) [1]
   negate(0(x)) -> 1(x) [1]
   negate(1(x)) -> 0(x) [1]
   choice(cons(x, xs)) -> x [1]
   choice(cons(x, xs)) -> choice(xs) [1]
   guess(nil) -> nil [1]
   guess(cons(clause, cnf)) -> cons(choice(clause), guess(cnf)) [1]
   verify(nil) -> true [1]
   verify(cons(l, ls)) -> if(member(negate(l), ls), false, verify(ls)) [1]
   sat(cnf) -> satck(cnf, guess(cnf)) [1]
   satck(cnf, assign) -> if(verify(assign), assign, unsat) [1]

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

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

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

   if(true, t, e) -> t [1]
   if(false, t, e) -> e [1]
   member(x, nil) -> false [1]
   member(x, cons(y, ys)) -> if(eq(x, y), true, member(x, ys)) [1]
   eq(nil, nil) -> true [1]
   eq(O(x), 0(y)) -> eq(x, y) [1]
   eq(0(x), 1(y)) -> false [1]
   eq(1(x), 0(y)) -> false [1]
   eq(1(x), 1(y)) -> eq(x, y) [1]
   negate(0(x)) -> 1(x) [1]
   negate(1(x)) -> 0(x) [1]
   choice(cons(x, xs)) -> x [1]
   choice(cons(x, xs)) -> choice(xs) [1]
   guess(nil) -> nil [1]
   guess(cons(clause, cnf)) -> cons(choice(clause), guess(cnf)) [1]
   verify(nil) -> true [1]
   verify(cons(l, ls)) -> if(member(negate(l), ls), false, verify(ls)) [1]
   sat(cnf) -> satck(cnf, guess(cnf)) [1]
   satck(cnf, assign) -> if(verify(assign), assign, unsat) [1]

The TRS has the following type information:
if :: true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat
true :: true:false:nil:cons:O:0:1:unsat
false :: true:false:nil:cons:O:0:1:unsat
member :: true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat
nil :: true:false:nil:cons:O:0:1:unsat
cons :: true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat
eq :: true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat
O :: true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat
0 :: true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat
1 :: true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat
negate :: true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat
choice :: true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat
guess :: true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat
verify :: true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat
sat :: true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat
satck :: true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat -> true:false:nil:cons:O:0:1:unsat
unsat :: true:false:nil:cons:O:0:1:unsat

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

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

   sat_1
   satck_2

(c) The following functions are completely defined:

   verify_1
   member_2
   negate_1
   eq_2
   guess_1
   if_3
   choice_1

Due to the following rules being added:

   verify(v0) -> null_verify [0]
   member(v0, v1) -> null_member [0]
   negate(v0) -> null_negate [0]
   eq(v0, v1) -> null_eq [0]
   guess(v0) -> null_guess [0]
   if(v0, v1, v2) -> null_if [0]
   choice(v0) -> null_choice [0]

And the following fresh constants:    null_verify, null_member, null_negate, null_eq, null_guess, null_if, null_choice

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

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

   if(true, t, e) -> t [1]
   if(false, t, e) -> e [1]
   member(x, nil) -> false [1]
   member(x, cons(y, ys)) -> if(eq(x, y), true, member(x, ys)) [1]
   eq(nil, nil) -> true [1]
   eq(O(x), 0(y)) -> eq(x, y) [1]
   eq(0(x), 1(y)) -> false [1]
   eq(1(x), 0(y)) -> false [1]
   eq(1(x), 1(y)) -> eq(x, y) [1]
   negate(0(x)) -> 1(x) [1]
   negate(1(x)) -> 0(x) [1]
   choice(cons(x, xs)) -> x [1]
   choice(cons(x, xs)) -> choice(xs) [1]
   guess(nil) -> nil [1]
   guess(cons(clause, cnf)) -> cons(choice(clause), guess(cnf)) [1]
   verify(nil) -> true [1]
   verify(cons(l, ls)) -> if(member(negate(l), ls), false, verify(ls)) [1]
   sat(cnf) -> satck(cnf, guess(cnf)) [1]
   satck(cnf, assign) -> if(verify(assign), assign, unsat) [1]
   verify(v0) -> null_verify [0]
   member(v0, v1) -> null_member [0]
   negate(v0) -> null_negate [0]
   eq(v0, v1) -> null_eq [0]
   guess(v0) -> null_guess [0]
   if(v0, v1, v2) -> null_if [0]
   choice(v0) -> null_choice [0]

The TRS has the following type information:
if :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
true :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
false :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
member :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
nil :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
cons :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
eq :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
O :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
0 :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
1 :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
negate :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
choice :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
guess :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
verify :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
sat :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
satck :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
unsat :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
null_verify :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
null_member :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
null_negate :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
null_eq :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
null_guess :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
null_if :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
null_choice :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice

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

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

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

   if(true, t, e) -> t [1]
   if(false, t, e) -> e [1]
   member(x, nil) -> false [1]
   member(nil, cons(nil, nil)) -> if(true, true, false) [3]
   member(nil, cons(nil, cons(y3, ys'))) -> if(true, true, if(eq(nil, y3), true, member(nil, ys'))) [3]
   member(nil, cons(nil, ys)) -> if(true, true, null_member) [2]
   member(O(x'), cons(0(y'), nil)) -> if(eq(x', y'), true, false) [3]
   member(O(x'), cons(0(y'), cons(y4, ys''))) -> if(eq(x', y'), true, if(eq(O(x'), y4), true, member(O(x'), ys''))) [3]
   member(O(x'), cons(0(y'), ys)) -> if(eq(x', y'), true, null_member) [2]
   member(0(x''), cons(1(y''), nil)) -> if(false, true, false) [3]
   member(0(x''), cons(1(y''), cons(y5, ys1))) -> if(false, true, if(eq(0(x''), y5), true, member(0(x''), ys1))) [3]
   member(0(x''), cons(1(y''), ys)) -> if(false, true, null_member) [2]
   member(1(x1), cons(0(y1), nil)) -> if(false, true, false) [3]
   member(1(x1), cons(0(y1), cons(y6, ys2))) -> if(false, true, if(eq(1(x1), y6), true, member(1(x1), ys2))) [3]
   member(1(x1), cons(0(y1), ys)) -> if(false, true, null_member) [2]
   member(1(x2), cons(1(y2), nil)) -> if(eq(x2, y2), true, false) [3]
   member(1(x2), cons(1(y2), cons(y7, ys3))) -> if(eq(x2, y2), true, if(eq(1(x2), y7), true, member(1(x2), ys3))) [3]
   member(1(x2), cons(1(y2), ys)) -> if(eq(x2, y2), true, null_member) [2]
   member(x, cons(y, nil)) -> if(null_eq, true, false) [2]
   member(x, cons(y, cons(y8, ys4))) -> if(null_eq, true, if(eq(x, y8), true, member(x, ys4))) [2]
   member(x, cons(y, ys)) -> if(null_eq, true, null_member) [1]
   eq(nil, nil) -> true [1]
   eq(O(x), 0(y)) -> eq(x, y) [1]
   eq(0(x), 1(y)) -> false [1]
   eq(1(x), 0(y)) -> false [1]
   eq(1(x), 1(y)) -> eq(x, y) [1]
   negate(0(x)) -> 1(x) [1]
   negate(1(x)) -> 0(x) [1]
   choice(cons(x, xs)) -> x [1]
   choice(cons(x, xs)) -> choice(xs) [1]
   guess(nil) -> nil [1]
   guess(cons(clause, cnf)) -> cons(choice(clause), guess(cnf)) [1]
   verify(nil) -> true [1]
   verify(cons(0(x3), nil)) -> if(member(1(x3), nil), false, true) [3]
   verify(cons(0(x3), cons(l', ls'))) -> if(member(1(x3), cons(l', ls')), false, if(member(negate(l'), ls'), false, verify(ls'))) [3]
   verify(cons(0(x3), ls)) -> if(member(1(x3), ls), false, null_verify) [2]
   verify(cons(1(x4), nil)) -> if(member(0(x4), nil), false, true) [3]
   verify(cons(1(x4), cons(l'', ls''))) -> if(member(0(x4), cons(l'', ls'')), false, if(member(negate(l''), ls''), false, verify(ls''))) [3]
   verify(cons(1(x4), ls)) -> if(member(0(x4), ls), false, null_verify) [2]
   verify(cons(l, nil)) -> if(member(null_negate, nil), false, true) [2]
   verify(cons(l, cons(l1, ls1))) -> if(member(null_negate, cons(l1, ls1)), false, if(member(negate(l1), ls1), false, verify(ls1))) [2]
   verify(cons(l, ls)) -> if(member(null_negate, ls), false, null_verify) [1]
   sat(nil) -> satck(nil, nil) [2]
   sat(cons(clause', cnf')) -> satck(cons(clause', cnf'), cons(choice(clause'), guess(cnf'))) [2]
   sat(cnf) -> satck(cnf, null_guess) [1]
   satck(cnf, nil) -> if(true, nil, unsat) [2]
   satck(cnf, cons(l2, ls2)) -> if(if(member(negate(l2), ls2), false, verify(ls2)), cons(l2, ls2), unsat) [2]
   satck(cnf, assign) -> if(null_verify, assign, unsat) [1]
   verify(v0) -> null_verify [0]
   member(v0, v1) -> null_member [0]
   negate(v0) -> null_negate [0]
   eq(v0, v1) -> null_eq [0]
   guess(v0) -> null_guess [0]
   if(v0, v1, v2) -> null_if [0]
   choice(v0) -> null_choice [0]

The TRS has the following type information:
if :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
true :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
false :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
member :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
nil :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
cons :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
eq :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
O :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
0 :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
1 :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
negate :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
choice :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
guess :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
verify :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
sat :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
satck :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice -> true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
unsat :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
null_verify :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
null_member :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
null_negate :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
null_eq :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
null_guess :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
null_if :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice
null_choice :: true:false:nil:cons:O:0:1:unsat:null_verify:null_member:null_negate:null_eq:null_guess:null_if:null_choice

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

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

   true => 2
   false => 0
   nil => 1
   unsat => 3
   null_verify => 0
   null_member => 0
   null_negate => 0
   null_eq => 0
   null_guess => 0
   null_if => 0
   null_choice => 0

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

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

   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> choice(xs) :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   eq(z, z') -{ 1 }-> eq(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   eq(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   guess(z) -{ 1 }-> 1 + choice(clause) + guess(cnf) :|: cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> e :|: z' = t, t >= 0, e >= 0, z = 0, z'' = e
   if(z, z', z'') -{ 1 }-> t :|: z = 2, z' = t, t >= 0, e >= 0, z'' = e
   if(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   member(z, z') -{ 3 }-> if(eq(x', y'), 2, if(eq(1 + x', y4), 2, member(1 + x', ys''))) :|: z = 1 + x', z' = 1 + (1 + y') + (1 + y4 + ys''), x' >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 3 }-> if(eq(x', y'), 2, 0) :|: z = 1 + x', x' >= 0, y' >= 0, z' = 1 + (1 + y') + 1
   member(z, z') -{ 2 }-> if(eq(x', y'), 2, 0) :|: z = 1 + x', z' = 1 + (1 + y') + ys, ys >= 0, x' >= 0, y' >= 0
   member(z, z') -{ 3 }-> if(eq(x2, y2), 2, if(eq(1 + x2, y7), 2, member(1 + x2, ys3))) :|: z = 1 + x2, y7 >= 0, ys3 >= 0, y2 >= 0, x2 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 3 }-> if(eq(x2, y2), 2, 0) :|: z = 1 + x2, z' = 1 + (1 + y2) + 1, y2 >= 0, x2 >= 0
   member(z, z') -{ 2 }-> if(eq(x2, y2), 2, 0) :|: z' = 1 + (1 + y2) + ys, ys >= 0, z = 1 + x2, y2 >= 0, x2 >= 0
   member(z, z') -{ 3 }-> if(2, 2, if(eq(1, y3), 2, member(1, ys'))) :|: z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 3 }-> if(2, 2, 0) :|: z' = 1 + 1 + 1, z = 1
   member(z, z') -{ 2 }-> if(2, 2, 0) :|: z = 1, ys >= 0, z' = 1 + 1 + ys
   member(z, z') -{ 2 }-> if(0, 2, if(eq(x, y8), 2, member(x, ys4))) :|: z' = 1 + y + (1 + y8 + ys4), y8 >= 0, x >= 0, y >= 0, ys4 >= 0, z = x
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + x'', y5), 2, member(1 + x'', ys1))) :|: z = 1 + x'', y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, x'' >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + x1, y6), 2, member(1 + x1, ys2))) :|: y1 >= 0, x1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, z = 1 + x1, ys2 >= 0
   member(z, z') -{ 3 }-> if(0, 2, 0) :|: z = 1 + x'', z' = 1 + (1 + y'') + 1, y'' >= 0, x'' >= 0
   member(z, z') -{ 2 }-> if(0, 2, 0) :|: z = 1 + x'', z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, x'' >= 0
   member(z, z') -{ 3 }-> if(0, 2, 0) :|: y1 >= 0, x1 >= 0, z' = 1 + (1 + y1) + 1, z = 1 + x1
   member(z, z') -{ 2 }-> if(0, 2, 0) :|: y1 >= 0, x1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, z = 1 + x1
   member(z, z') -{ 2 }-> if(0, 2, 0) :|: z' = 1 + y + 1, x >= 0, y >= 0, z = x
   member(z, z') -{ 1 }-> if(0, 2, 0) :|: ys >= 0, x >= 0, y >= 0, z = x, z' = 1 + y + ys
   member(z, z') -{ 1 }-> 0 :|: x >= 0, z' = 1, z = x
   member(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   negate(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   negate(z) -{ 1 }-> 1 + x :|: x >= 0, z = 1 + x
   sat(z) -{ 1 }-> satck(cnf, 0) :|: cnf >= 0, z = cnf
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 2 }-> satck(1 + clause' + cnf', 1 + choice(clause') + guess(cnf')) :|: clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> if(if(member(negate(l2), ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, cnf >= 0, z = cnf, l2 >= 0, ls2 >= 0
   satck(z, z') -{ 2 }-> if(2, 1, 3) :|: cnf >= 0, z' = 1, z = cnf
   satck(z, z') -{ 1 }-> if(0, assign, 3) :|: cnf >= 0, z' = assign, z = cnf, assign >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z = 1 + l + 1, l >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(negate(l1), ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1), 0, 2) :|: z = 1 + (1 + x3) + 1, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(negate(l'), ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1), 0, 2) :|: x4 >= 0, z = 1 + (1 + x4) + 1
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(negate(l''), ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0


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

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

   if(z, z', z'') -{ 1 }-> e :|: z' = t, t >= 0, e >= 0, z = 0, z'' = e
   if(z, z', z'') -{ 1 }-> t :|: z = 2, z' = t, t >= 0, e >= 0, z'' = e
   if(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   negate(z) -{ 1 }-> 1 + x :|: x >= 0, z = 1 + x

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

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

   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> choice(xs) :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   eq(z, z') -{ 1 }-> eq(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   eq(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   guess(z) -{ 1 }-> 1 + choice(clause) + guess(cnf) :|: cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> e :|: z' = t, t >= 0, e >= 0, z = 0, z'' = e
   if(z, z', z'') -{ 1 }-> t :|: z = 2, z' = t, t >= 0, e >= 0, z'' = e
   if(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   member(z, z') -{ 4 }-> e :|: z = 1 + x'', z' = 1 + (1 + y'') + 1, y'' >= 0, x'' >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z = 1 + x'', z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, x'' >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> e :|: y1 >= 0, x1 >= 0, z' = 1 + (1 + y1) + 1, z = 1 + x1, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, x1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, z = 1 + x1, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + y + 1, x >= 0, y >= 0, z = x, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, x >= 0, y >= 0, z = x, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, ys >= 0, z' = 1 + 1 + ys, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> if(eq(x', y'), 2, if(eq(1 + x', y4), 2, member(1 + x', ys''))) :|: z = 1 + x', z' = 1 + (1 + y') + (1 + y4 + ys''), x' >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 3 }-> if(eq(x', y'), 2, 0) :|: z = 1 + x', x' >= 0, y' >= 0, z' = 1 + (1 + y') + 1
   member(z, z') -{ 2 }-> if(eq(x', y'), 2, 0) :|: z = 1 + x', z' = 1 + (1 + y') + ys, ys >= 0, x' >= 0, y' >= 0
   member(z, z') -{ 3 }-> if(eq(x2, y2), 2, if(eq(1 + x2, y7), 2, member(1 + x2, ys3))) :|: z = 1 + x2, y7 >= 0, ys3 >= 0, y2 >= 0, x2 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 3 }-> if(eq(x2, y2), 2, 0) :|: z = 1 + x2, z' = 1 + (1 + y2) + 1, y2 >= 0, x2 >= 0
   member(z, z') -{ 2 }-> if(eq(x2, y2), 2, 0) :|: z' = 1 + (1 + y2) + ys, ys >= 0, z = 1 + x2, y2 >= 0, x2 >= 0
   member(z, z') -{ 3 }-> if(2, 2, if(eq(1, y3), 2, member(1, ys'))) :|: z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 2 }-> if(0, 2, if(eq(x, y8), 2, member(x, ys4))) :|: z' = 1 + y + (1 + y8 + ys4), y8 >= 0, x >= 0, y >= 0, ys4 >= 0, z = x
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + x'', y5), 2, member(1 + x'', ys1))) :|: z = 1 + x'', y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, x'' >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + x1, y6), 2, member(1 + x1, ys2))) :|: y1 >= 0, x1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, z = 1 + x1, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: x >= 0, z' = 1, z = x
   member(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, ys >= 0, z' = 1 + 1 + ys, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z = 1 + x'', z' = 1 + (1 + y'') + 1, y'' >= 0, x'' >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1 + x'', z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, x'' >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: y1 >= 0, x1 >= 0, z' = 1 + (1 + y1) + 1, z = 1 + x1, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, x1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, z = 1 + x1, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + y + 1, x >= 0, y >= 0, z = x, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, x >= 0, y >= 0, z = x, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   negate(z) -{ 1 }-> 1 + x :|: x >= 0, z = 1 + x
   sat(z) -{ 1 }-> satck(cnf, 0) :|: cnf >= 0, z = cnf
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 2 }-> satck(1 + clause' + cnf', 1 + choice(clause') + guess(cnf')) :|: clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: cnf >= 0, z' = assign, z = cnf, assign >= 0, assign = t, t >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: cnf >= 0, z' = 1, z = cnf, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, cnf >= 0, z = cnf, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, cnf >= 0, z = cnf, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: cnf >= 0, z' = 1, z = cnf, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: cnf >= 0, z' = assign, z = cnf, assign >= 0, v0 >= 0, 3 = v2, v1 >= 0, 0 = v0, assign = v1, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z = 1 + l + 1, l >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1), 0, 2) :|: z = 1 + (1 + x3) + 1, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1), 0, 2) :|: x4 >= 0, z = 1 + (1 + x4) + 1
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0


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

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

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

   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> choice(xs) :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 1 }-> 1 + choice(clause) + guess(cnf) :|: cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> if(eq(z - 1, y'), 2, if(eq(1 + (z - 1), y4), 2, member(1 + (z - 1), ys''))) :|: z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 2 }-> if(eq(z - 1, y'), 2, 0) :|: z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, y2), 2, if(eq(1 + (z - 1), y7), 2, member(1 + (z - 1), ys3))) :|: y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 2 }-> if(eq(z - 1, y2), 2, 0) :|: z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, z' - 3), 2, 0) :|: z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 3 }-> if(2, 2, if(eq(1, y3), 2, member(1, ys'))) :|: z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 2 }-> if(0, 2, if(eq(z, y8), 2, member(z, ys4))) :|: z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y5), 2, member(1 + (z - 1), ys1))) :|: y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y6), 2, member(1 + (z - 1), ys2))) :|: y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 2 }-> satck(1 + clause' + cnf', 1 + choice(clause') + guess(cnf')) :|: clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0


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

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

   { choice }
   { eq }
   { negate }
   { if }
   { guess }
   { member }
   { verify }
   { satck }
   { sat }

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

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

   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> choice(xs) :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 1 }-> 1 + choice(clause) + guess(cnf) :|: cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> if(eq(z - 1, y'), 2, if(eq(1 + (z - 1), y4), 2, member(1 + (z - 1), ys''))) :|: z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 2 }-> if(eq(z - 1, y'), 2, 0) :|: z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, y2), 2, if(eq(1 + (z - 1), y7), 2, member(1 + (z - 1), ys3))) :|: y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 2 }-> if(eq(z - 1, y2), 2, 0) :|: z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, z' - 3), 2, 0) :|: z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 3 }-> if(2, 2, if(eq(1, y3), 2, member(1, ys'))) :|: z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 2 }-> if(0, 2, if(eq(z, y8), 2, member(z, ys4))) :|: z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y5), 2, member(1 + (z - 1), ys1))) :|: y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y6), 2, member(1 + (z - 1), ys2))) :|: y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 2 }-> satck(1 + clause' + cnf', 1 + choice(clause') + guess(cnf')) :|: clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {choice}, {eq}, {negate}, {if}, {guess}, {member}, {verify}, {satck}, {sat}

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

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

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

   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> choice(xs) :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 1 }-> 1 + choice(clause) + guess(cnf) :|: cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> if(eq(z - 1, y'), 2, if(eq(1 + (z - 1), y4), 2, member(1 + (z - 1), ys''))) :|: z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 2 }-> if(eq(z - 1, y'), 2, 0) :|: z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, y2), 2, if(eq(1 + (z - 1), y7), 2, member(1 + (z - 1), ys3))) :|: y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 2 }-> if(eq(z - 1, y2), 2, 0) :|: z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, z' - 3), 2, 0) :|: z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 3 }-> if(2, 2, if(eq(1, y3), 2, member(1, ys'))) :|: z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 2 }-> if(0, 2, if(eq(z, y8), 2, member(z, ys4))) :|: z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y5), 2, member(1 + (z - 1), ys1))) :|: y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y6), 2, member(1 + (z - 1), ys2))) :|: y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 2 }-> satck(1 + clause' + cnf', 1 + choice(clause') + guess(cnf')) :|: clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {choice}, {eq}, {negate}, {if}, {guess}, {member}, {verify}, {satck}, {sat}

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

(19) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> choice(xs) :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 1 }-> 1 + choice(clause) + guess(cnf) :|: cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> if(eq(z - 1, y'), 2, if(eq(1 + (z - 1), y4), 2, member(1 + (z - 1), ys''))) :|: z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 2 }-> if(eq(z - 1, y'), 2, 0) :|: z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, y2), 2, if(eq(1 + (z - 1), y7), 2, member(1 + (z - 1), ys3))) :|: y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 2 }-> if(eq(z - 1, y2), 2, 0) :|: z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, z' - 3), 2, 0) :|: z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 3 }-> if(2, 2, if(eq(1, y3), 2, member(1, ys'))) :|: z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 2 }-> if(0, 2, if(eq(z, y8), 2, member(z, ys4))) :|: z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y5), 2, member(1 + (z - 1), ys1))) :|: y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y6), 2, member(1 + (z - 1), ys2))) :|: y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 2 }-> satck(1 + clause' + cnf', 1 + choice(clause') + guess(cnf')) :|: clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {choice}, {eq}, {negate}, {if}, {guess}, {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: ?, size: O(n^1) [z]

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

(21) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> choice(xs) :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 1 }-> 1 + choice(clause) + guess(cnf) :|: cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> if(eq(z - 1, y'), 2, if(eq(1 + (z - 1), y4), 2, member(1 + (z - 1), ys''))) :|: z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 2 }-> if(eq(z - 1, y'), 2, 0) :|: z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, y2), 2, if(eq(1 + (z - 1), y7), 2, member(1 + (z - 1), ys3))) :|: y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 2 }-> if(eq(z - 1, y2), 2, 0) :|: z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, z' - 3), 2, 0) :|: z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 3 }-> if(2, 2, if(eq(1, y3), 2, member(1, ys'))) :|: z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 2 }-> if(0, 2, if(eq(z, y8), 2, member(z, ys4))) :|: z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y5), 2, member(1 + (z - 1), ys1))) :|: y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y6), 2, member(1 + (z - 1), ys2))) :|: y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 2 }-> satck(1 + clause' + cnf', 1 + choice(clause') + guess(cnf')) :|: clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {eq}, {negate}, {if}, {guess}, {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 2 + clause }-> 1 + s' + guess(cnf) :|: s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> if(eq(z - 1, y'), 2, if(eq(1 + (z - 1), y4), 2, member(1 + (z - 1), ys''))) :|: z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 2 }-> if(eq(z - 1, y'), 2, 0) :|: z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, y2), 2, if(eq(1 + (z - 1), y7), 2, member(1 + (z - 1), ys3))) :|: y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 2 }-> if(eq(z - 1, y2), 2, 0) :|: z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, z' - 3), 2, 0) :|: z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 3 }-> if(2, 2, if(eq(1, y3), 2, member(1, ys'))) :|: z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 2 }-> if(0, 2, if(eq(z, y8), 2, member(z, ys4))) :|: z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y5), 2, member(1 + (z - 1), ys1))) :|: y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y6), 2, member(1 + (z - 1), ys2))) :|: y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 3 + clause' }-> satck(1 + clause' + cnf', 1 + s'' + guess(cnf')) :|: s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {eq}, {negate}, {if}, {guess}, {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]

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

(25) 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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 2 + clause }-> 1 + s' + guess(cnf) :|: s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> if(eq(z - 1, y'), 2, if(eq(1 + (z - 1), y4), 2, member(1 + (z - 1), ys''))) :|: z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 2 }-> if(eq(z - 1, y'), 2, 0) :|: z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, y2), 2, if(eq(1 + (z - 1), y7), 2, member(1 + (z - 1), ys3))) :|: y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 2 }-> if(eq(z - 1, y2), 2, 0) :|: z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, z' - 3), 2, 0) :|: z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 3 }-> if(2, 2, if(eq(1, y3), 2, member(1, ys'))) :|: z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 2 }-> if(0, 2, if(eq(z, y8), 2, member(z, ys4))) :|: z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y5), 2, member(1 + (z - 1), ys1))) :|: y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y6), 2, member(1 + (z - 1), ys2))) :|: y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 3 + clause' }-> satck(1 + clause' + cnf', 1 + s'' + guess(cnf')) :|: s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {eq}, {negate}, {if}, {guess}, {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: ?, size: O(1) [2]

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

(27) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 2 + clause }-> 1 + s' + guess(cnf) :|: s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> if(eq(z - 1, y'), 2, if(eq(1 + (z - 1), y4), 2, member(1 + (z - 1), ys''))) :|: z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 2 }-> if(eq(z - 1, y'), 2, 0) :|: z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, y2), 2, if(eq(1 + (z - 1), y7), 2, member(1 + (z - 1), ys3))) :|: y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 2 }-> if(eq(z - 1, y2), 2, 0) :|: z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(eq(z - 1, z' - 3), 2, 0) :|: z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 3 }-> if(2, 2, if(eq(1, y3), 2, member(1, ys'))) :|: z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 2 }-> if(0, 2, if(eq(z, y8), 2, member(z, ys4))) :|: z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y5), 2, member(1 + (z - 1), ys1))) :|: y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 3 }-> if(0, 2, if(eq(1 + (z - 1), y6), 2, member(1 + (z - 1), ys2))) :|: y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 3 + clause' }-> satck(1 + clause' + cnf', 1 + s'' + guess(cnf')) :|: s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {negate}, {if}, {guess}, {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 2 + clause }-> 1 + s' + guess(cnf) :|: s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 4 + y2 }-> if(s11, 2, 0) :|: s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 2 + z' }-> if(s3, 2, 0) :|: s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 7 + y' + y4 }-> if(s4, 2, if(s5, 2, member(1 + (z - 1), ys''))) :|: s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 4 + y' }-> if(s6, 2, 0) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 7 + y2 + y7 }-> if(s9, 2, if(s10, 2, member(1 + (z - 1), ys3))) :|: s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 5 + y3 }-> if(2, 2, if(s2, 2, member(1, ys'))) :|: s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 4 + y8 }-> if(0, 2, if(s12, 2, member(z, ys4))) :|: s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 5 + y5 }-> if(0, 2, if(s7, 2, member(1 + (z - 1), ys1))) :|: s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 5 + y6 }-> if(0, 2, if(s8, 2, member(1 + (z - 1), ys2))) :|: s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 3 + clause' }-> satck(1 + clause' + cnf', 1 + s'' + guess(cnf')) :|: s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {negate}, {if}, {guess}, {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]

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

(31) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 2 + clause }-> 1 + s' + guess(cnf) :|: s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 4 + y2 }-> if(s11, 2, 0) :|: s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 2 + z' }-> if(s3, 2, 0) :|: s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 7 + y' + y4 }-> if(s4, 2, if(s5, 2, member(1 + (z - 1), ys''))) :|: s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 4 + y' }-> if(s6, 2, 0) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 7 + y2 + y7 }-> if(s9, 2, if(s10, 2, member(1 + (z - 1), ys3))) :|: s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 5 + y3 }-> if(2, 2, if(s2, 2, member(1, ys'))) :|: s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 4 + y8 }-> if(0, 2, if(s12, 2, member(z, ys4))) :|: s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 5 + y5 }-> if(0, 2, if(s7, 2, member(1 + (z - 1), ys1))) :|: s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 5 + y6 }-> if(0, 2, if(s8, 2, member(1 + (z - 1), ys2))) :|: s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 3 + clause' }-> satck(1 + clause' + cnf', 1 + s'' + guess(cnf')) :|: s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {negate}, {if}, {guess}, {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: ?, size: O(n^1) [z]

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

(33) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 2 + clause }-> 1 + s' + guess(cnf) :|: s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 4 + y2 }-> if(s11, 2, 0) :|: s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 2 + z' }-> if(s3, 2, 0) :|: s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 7 + y' + y4 }-> if(s4, 2, if(s5, 2, member(1 + (z - 1), ys''))) :|: s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 4 + y' }-> if(s6, 2, 0) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 7 + y2 + y7 }-> if(s9, 2, if(s10, 2, member(1 + (z - 1), ys3))) :|: s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 5 + y3 }-> if(2, 2, if(s2, 2, member(1, ys'))) :|: s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 4 + y8 }-> if(0, 2, if(s12, 2, member(z, ys4))) :|: s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 5 + y5 }-> if(0, 2, if(s7, 2, member(1 + (z - 1), ys1))) :|: s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 5 + y6 }-> if(0, 2, if(s8, 2, member(1 + (z - 1), ys2))) :|: s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 3 + clause' }-> satck(1 + clause' + cnf', 1 + s'' + guess(cnf')) :|: s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {if}, {guess}, {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 2 + clause }-> 1 + s' + guess(cnf) :|: s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 4 + y2 }-> if(s11, 2, 0) :|: s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 2 + z' }-> if(s3, 2, 0) :|: s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 7 + y' + y4 }-> if(s4, 2, if(s5, 2, member(1 + (z - 1), ys''))) :|: s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 4 + y' }-> if(s6, 2, 0) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 7 + y2 + y7 }-> if(s9, 2, if(s10, 2, member(1 + (z - 1), ys3))) :|: s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 5 + y3 }-> if(2, 2, if(s2, 2, member(1, ys'))) :|: s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 4 + y8 }-> if(0, 2, if(s12, 2, member(z, ys4))) :|: s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 5 + y5 }-> if(0, 2, if(s7, 2, member(1 + (z - 1), ys1))) :|: s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 5 + y6 }-> if(0, 2, if(s8, 2, member(1 + (z - 1), ys2))) :|: s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 3 + clause' }-> satck(1 + clause' + cnf', 1 + s'' + guess(cnf')) :|: s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {if}, {guess}, {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]

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

(37) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 2 + clause }-> 1 + s' + guess(cnf) :|: s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 4 + y2 }-> if(s11, 2, 0) :|: s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 2 + z' }-> if(s3, 2, 0) :|: s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 7 + y' + y4 }-> if(s4, 2, if(s5, 2, member(1 + (z - 1), ys''))) :|: s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 4 + y' }-> if(s6, 2, 0) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 7 + y2 + y7 }-> if(s9, 2, if(s10, 2, member(1 + (z - 1), ys3))) :|: s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 5 + y3 }-> if(2, 2, if(s2, 2, member(1, ys'))) :|: s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 4 + y8 }-> if(0, 2, if(s12, 2, member(z, ys4))) :|: s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 5 + y5 }-> if(0, 2, if(s7, 2, member(1 + (z - 1), ys1))) :|: s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 5 + y6 }-> if(0, 2, if(s8, 2, member(1 + (z - 1), ys2))) :|: s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 3 + clause' }-> satck(1 + clause' + cnf', 1 + s'' + guess(cnf')) :|: s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {if}, {guess}, {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: ?, size: O(n^1) [z' + z'']

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 2 + clause }-> 1 + s' + guess(cnf) :|: s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 4 + y2 }-> if(s11, 2, 0) :|: s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 2 + z' }-> if(s3, 2, 0) :|: s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 7 + y' + y4 }-> if(s4, 2, if(s5, 2, member(1 + (z - 1), ys''))) :|: s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 4 + y' }-> if(s6, 2, 0) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 7 + y2 + y7 }-> if(s9, 2, if(s10, 2, member(1 + (z - 1), ys3))) :|: s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 5 + y3 }-> if(2, 2, if(s2, 2, member(1, ys'))) :|: s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 4 + y8 }-> if(0, 2, if(s12, 2, member(z, ys4))) :|: s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 5 + y5 }-> if(0, 2, if(s7, 2, member(1 + (z - 1), ys1))) :|: s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 5 + y6 }-> if(0, 2, if(s8, 2, member(1 + (z - 1), ys2))) :|: s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 3 + clause' }-> satck(1 + clause' + cnf', 1 + s'' + guess(cnf')) :|: s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {guess}, {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 2 + clause }-> 1 + s' + guess(cnf) :|: s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 7 + y' + y4 }-> if(s4, 2, if(s5, 2, member(1 + (z - 1), ys''))) :|: s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 7 + y2 + y7 }-> if(s9, 2, if(s10, 2, member(1 + (z - 1), ys3))) :|: s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 5 + y3 }-> if(2, 2, if(s2, 2, member(1, ys'))) :|: s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 4 + y8 }-> if(0, 2, if(s12, 2, member(z, ys4))) :|: s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 5 + y5 }-> if(0, 2, if(s7, 2, member(1 + (z - 1), ys1))) :|: s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 5 + y6 }-> if(0, 2, if(s8, 2, member(1 + (z - 1), ys2))) :|: s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 3 + clause' }-> satck(1 + clause' + cnf', 1 + s'' + guess(cnf')) :|: s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {guess}, {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']

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

(43) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using KoAT for: guess
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:

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 2 + clause }-> 1 + s' + guess(cnf) :|: s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 7 + y' + y4 }-> if(s4, 2, if(s5, 2, member(1 + (z - 1), ys''))) :|: s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 7 + y2 + y7 }-> if(s9, 2, if(s10, 2, member(1 + (z - 1), ys3))) :|: s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 5 + y3 }-> if(2, 2, if(s2, 2, member(1, ys'))) :|: s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 4 + y8 }-> if(0, 2, if(s12, 2, member(z, ys4))) :|: s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 5 + y5 }-> if(0, 2, if(s7, 2, member(1 + (z - 1), ys1))) :|: s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 5 + y6 }-> if(0, 2, if(s8, 2, member(1 + (z - 1), ys2))) :|: s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 3 + clause' }-> satck(1 + clause' + cnf', 1 + s'' + guess(cnf')) :|: s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {guess}, {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']
  guess: runtime: ?, size: O(n^1) [z]

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

(45) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 2 + clause }-> 1 + s' + guess(cnf) :|: s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 7 + y' + y4 }-> if(s4, 2, if(s5, 2, member(1 + (z - 1), ys''))) :|: s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 7 + y2 + y7 }-> if(s9, 2, if(s10, 2, member(1 + (z - 1), ys3))) :|: s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 5 + y3 }-> if(2, 2, if(s2, 2, member(1, ys'))) :|: s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 4 + y8 }-> if(0, 2, if(s12, 2, member(z, ys4))) :|: s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 5 + y5 }-> if(0, 2, if(s7, 2, member(1 + (z - 1), ys1))) :|: s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 5 + y6 }-> if(0, 2, if(s8, 2, member(1 + (z - 1), ys2))) :|: s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 3 + clause' }-> satck(1 + clause' + cnf', 1 + s'' + guess(cnf')) :|: s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']
  guess: runtime: O(n^1) [3 + 2*z], 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:

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 5 + clause + 2*cnf }-> 1 + s' + s16 :|: s16 >= 0, s16 <= cnf, s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 7 + y' + y4 }-> if(s4, 2, if(s5, 2, member(1 + (z - 1), ys''))) :|: s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 7 + y2 + y7 }-> if(s9, 2, if(s10, 2, member(1 + (z - 1), ys3))) :|: s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 5 + y3 }-> if(2, 2, if(s2, 2, member(1, ys'))) :|: s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 4 + y8 }-> if(0, 2, if(s12, 2, member(z, ys4))) :|: s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 5 + y5 }-> if(0, 2, if(s7, 2, member(1 + (z - 1), ys1))) :|: s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 5 + y6 }-> if(0, 2, if(s8, 2, member(1 + (z - 1), ys2))) :|: s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 6 + clause' + 2*cnf' }-> satck(1 + clause' + cnf', 1 + s'' + s17) :|: s17 >= 0, s17 <= cnf', s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']
  guess: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z]

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

(49) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 5 + clause + 2*cnf }-> 1 + s' + s16 :|: s16 >= 0, s16 <= cnf, s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 7 + y' + y4 }-> if(s4, 2, if(s5, 2, member(1 + (z - 1), ys''))) :|: s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 7 + y2 + y7 }-> if(s9, 2, if(s10, 2, member(1 + (z - 1), ys3))) :|: s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 5 + y3 }-> if(2, 2, if(s2, 2, member(1, ys'))) :|: s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 4 + y8 }-> if(0, 2, if(s12, 2, member(z, ys4))) :|: s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 5 + y5 }-> if(0, 2, if(s7, 2, member(1 + (z - 1), ys1))) :|: s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 5 + y6 }-> if(0, 2, if(s8, 2, member(1 + (z - 1), ys2))) :|: s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 6 + clause' + 2*cnf' }-> satck(1 + clause' + cnf', 1 + s'' + s17) :|: s17 >= 0, s17 <= cnf', s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {member}, {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']
  guess: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z]
  member: runtime: ?, size: O(n^1) [2*z']

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 5 + clause + 2*cnf }-> 1 + s' + s16 :|: s16 >= 0, s16 <= cnf, s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 7 + y' + y4 }-> if(s4, 2, if(s5, 2, member(1 + (z - 1), ys''))) :|: s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 7 + y2 + y7 }-> if(s9, 2, if(s10, 2, member(1 + (z - 1), ys3))) :|: s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 5 + y3 }-> if(2, 2, if(s2, 2, member(1, ys'))) :|: s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 4 + y8 }-> if(0, 2, if(s12, 2, member(z, ys4))) :|: s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 5 + y5 }-> if(0, 2, if(s7, 2, member(1 + (z - 1), ys1))) :|: s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 5 + y6 }-> if(0, 2, if(s8, 2, member(1 + (z - 1), ys2))) :|: s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 6 + clause' + 2*cnf' }-> satck(1 + clause' + cnf', 1 + s'' + s17) :|: s17 >= 0, s17 <= cnf', s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> if(if(member(0, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 3 }-> if(if(member(1 + x, ls2), 0, verify(ls2)), 1 + l2 + ls2, 3) :|: z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 1 }-> if(member(0, ls), 0, 0) :|: l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 2 }-> if(member(0, 1), 0, 2) :|: z - 2 >= 0
   verify(z) -{ 2 }-> if(member(0, 1 + l1 + ls1), 0, if(member(0, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 3 }-> if(member(0, 1 + l1 + ls1), 0, if(member(1 + x, ls1), 0, verify(ls1))) :|: z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x3, ls), 0, 0) :|: z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 3 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(0, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 4 }-> if(member(1 + x3, 1 + l' + ls'), 0, if(member(1 + x, ls'), 0, verify(ls'))) :|: ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 2 }-> if(member(1 + x4, ls), 0, 0) :|: x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 3 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(0, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 4 }-> if(member(1 + x4, 1 + l'' + ls''), 0, if(member(1 + x, ls''), 0, verify(ls''))) :|: x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 3 }-> if(member(1 + (z - 3), 1), 0, 2) :|: z - 3 >= 0
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']
  guess: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z]
  member: runtime: O(n^1) [39 + 27*z'], size: O(n^1) [2*z']

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 5 + clause + 2*cnf }-> 1 + s' + s16 :|: s16 >= 0, s16 <= cnf, s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y3 + 27*ys' }-> s20 :|: s18 >= 0, s18 <= 2 * ys', s19 >= 0, s19 <= s18 + 2, s20 >= 0, s20 <= s19 + 2, s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 48 + y' + y4 + 27*ys'' }-> s23 :|: s21 >= 0, s21 <= 2 * ys'', s22 >= 0, s22 <= s21 + 2, s23 >= 0, s23 <= s22 + 2, s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 46 + y5 + 27*ys1 }-> s26 :|: s24 >= 0, s24 <= 2 * ys1, s25 >= 0, s25 <= s24 + 2, s26 >= 0, s26 <= s25 + 2, s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y6 + 27*ys2 }-> s29 :|: s27 >= 0, s27 <= 2 * ys2, s28 >= 0, s28 <= s27 + 2, s29 >= 0, s29 <= s28 + 2, s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 48 + y2 + y7 + 27*ys3 }-> s32 :|: s30 >= 0, s30 <= 2 * ys3, s31 >= 0, s31 <= s30 + 2, s32 >= 0, s32 <= s31 + 2, s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 45 + y8 + 27*ys4 }-> s35 :|: s33 >= 0, s33 <= 2 * ys4, s34 >= 0, s34 <= s33 + 2, s35 >= 0, s35 <= s34 + 2, s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 6 + clause' + 2*cnf' }-> satck(1 + clause' + cnf', 1 + s'' + s17) :|: s17 >= 0, s17 <= cnf', s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 41 + 27*ls2 }-> if(if(s58, 0, verify(ls2)), 1 + l2 + ls2, 3) :|: s58 >= 0, s58 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 42 + 27*ls2 }-> if(if(s59, 0, verify(ls2)), 1 + l2 + ls2, 3) :|: s59 >= 0, s59 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 70 }-> s37 :|: s36 >= 0, s36 <= 2 * 1, s37 >= 0, s37 <= 2 + 0, z - 3 >= 0
   verify(z) -{ 42 + 27*ls }-> s39 :|: s38 >= 0, s38 <= 2 * ls, s39 >= 0, s39 <= 0 + 0, z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 42 + 27*ls }-> s41 :|: s40 >= 0, s40 <= 2 * ls, s41 >= 0, s41 <= 0 + 0, x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 69 }-> s43 :|: s42 >= 0, s42 <= 2 * 1, s43 >= 0, s43 <= 2 + 0, z - 2 >= 0
   verify(z) -{ 41 + 27*ls }-> s45 :|: s44 >= 0, s44 <= 2 * ls, s45 >= 0, s45 <= 0 + 0, l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 108 + 27*l' + 54*ls' }-> if(s46, 0, if(s47, 0, verify(ls'))) :|: s46 >= 0, s46 <= 2 * (1 + l' + ls'), s47 >= 0, s47 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 109 + 27*l' + 54*ls' }-> if(s48, 0, if(s49, 0, verify(ls'))) :|: s48 >= 0, s48 <= 2 * (1 + l' + ls'), s49 >= 0, s49 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 108 + 27*l'' + 54*ls'' }-> if(s50, 0, if(s51, 0, verify(ls''))) :|: s50 >= 0, s50 <= 2 * (1 + l'' + ls''), s51 >= 0, s51 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 109 + 27*l'' + 54*ls'' }-> if(s52, 0, if(s53, 0, verify(ls''))) :|: s52 >= 0, s52 <= 2 * (1 + l'' + ls''), s53 >= 0, s53 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 107 + 27*l1 + 54*ls1 }-> if(s54, 0, if(s55, 0, verify(ls1))) :|: s54 >= 0, s54 <= 2 * (1 + l1 + ls1), s55 >= 0, s55 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 108 + 27*l1 + 54*ls1 }-> if(s56, 0, if(s57, 0, verify(ls1))) :|: s56 >= 0, s56 <= 2 * (1 + l1 + ls1), s57 >= 0, s57 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']
  guess: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z]
  member: runtime: O(n^1) [39 + 27*z'], size: O(n^1) [2*z']

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

(55) IntTrsBoundProof (UPPER BOUND(ID))

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 5 + clause + 2*cnf }-> 1 + s' + s16 :|: s16 >= 0, s16 <= cnf, s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y3 + 27*ys' }-> s20 :|: s18 >= 0, s18 <= 2 * ys', s19 >= 0, s19 <= s18 + 2, s20 >= 0, s20 <= s19 + 2, s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 48 + y' + y4 + 27*ys'' }-> s23 :|: s21 >= 0, s21 <= 2 * ys'', s22 >= 0, s22 <= s21 + 2, s23 >= 0, s23 <= s22 + 2, s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 46 + y5 + 27*ys1 }-> s26 :|: s24 >= 0, s24 <= 2 * ys1, s25 >= 0, s25 <= s24 + 2, s26 >= 0, s26 <= s25 + 2, s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y6 + 27*ys2 }-> s29 :|: s27 >= 0, s27 <= 2 * ys2, s28 >= 0, s28 <= s27 + 2, s29 >= 0, s29 <= s28 + 2, s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 48 + y2 + y7 + 27*ys3 }-> s32 :|: s30 >= 0, s30 <= 2 * ys3, s31 >= 0, s31 <= s30 + 2, s32 >= 0, s32 <= s31 + 2, s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 45 + y8 + 27*ys4 }-> s35 :|: s33 >= 0, s33 <= 2 * ys4, s34 >= 0, s34 <= s33 + 2, s35 >= 0, s35 <= s34 + 2, s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 6 + clause' + 2*cnf' }-> satck(1 + clause' + cnf', 1 + s'' + s17) :|: s17 >= 0, s17 <= cnf', s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 41 + 27*ls2 }-> if(if(s58, 0, verify(ls2)), 1 + l2 + ls2, 3) :|: s58 >= 0, s58 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 42 + 27*ls2 }-> if(if(s59, 0, verify(ls2)), 1 + l2 + ls2, 3) :|: s59 >= 0, s59 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 70 }-> s37 :|: s36 >= 0, s36 <= 2 * 1, s37 >= 0, s37 <= 2 + 0, z - 3 >= 0
   verify(z) -{ 42 + 27*ls }-> s39 :|: s38 >= 0, s38 <= 2 * ls, s39 >= 0, s39 <= 0 + 0, z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 42 + 27*ls }-> s41 :|: s40 >= 0, s40 <= 2 * ls, s41 >= 0, s41 <= 0 + 0, x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 69 }-> s43 :|: s42 >= 0, s42 <= 2 * 1, s43 >= 0, s43 <= 2 + 0, z - 2 >= 0
   verify(z) -{ 41 + 27*ls }-> s45 :|: s44 >= 0, s44 <= 2 * ls, s45 >= 0, s45 <= 0 + 0, l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 108 + 27*l' + 54*ls' }-> if(s46, 0, if(s47, 0, verify(ls'))) :|: s46 >= 0, s46 <= 2 * (1 + l' + ls'), s47 >= 0, s47 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 109 + 27*l' + 54*ls' }-> if(s48, 0, if(s49, 0, verify(ls'))) :|: s48 >= 0, s48 <= 2 * (1 + l' + ls'), s49 >= 0, s49 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 108 + 27*l'' + 54*ls'' }-> if(s50, 0, if(s51, 0, verify(ls''))) :|: s50 >= 0, s50 <= 2 * (1 + l'' + ls''), s51 >= 0, s51 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 109 + 27*l'' + 54*ls'' }-> if(s52, 0, if(s53, 0, verify(ls''))) :|: s52 >= 0, s52 <= 2 * (1 + l'' + ls''), s53 >= 0, s53 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 107 + 27*l1 + 54*ls1 }-> if(s54, 0, if(s55, 0, verify(ls1))) :|: s54 >= 0, s54 <= 2 * (1 + l1 + ls1), s55 >= 0, s55 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 108 + 27*l1 + 54*ls1 }-> if(s56, 0, if(s57, 0, verify(ls1))) :|: s56 >= 0, s56 <= 2 * (1 + l1 + ls1), s57 >= 0, s57 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {verify}, {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']
  guess: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z]
  member: runtime: O(n^1) [39 + 27*z'], size: O(n^1) [2*z']
  verify: runtime: ?, size: O(1) [2]

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 5 + clause + 2*cnf }-> 1 + s' + s16 :|: s16 >= 0, s16 <= cnf, s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y3 + 27*ys' }-> s20 :|: s18 >= 0, s18 <= 2 * ys', s19 >= 0, s19 <= s18 + 2, s20 >= 0, s20 <= s19 + 2, s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 48 + y' + y4 + 27*ys'' }-> s23 :|: s21 >= 0, s21 <= 2 * ys'', s22 >= 0, s22 <= s21 + 2, s23 >= 0, s23 <= s22 + 2, s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 46 + y5 + 27*ys1 }-> s26 :|: s24 >= 0, s24 <= 2 * ys1, s25 >= 0, s25 <= s24 + 2, s26 >= 0, s26 <= s25 + 2, s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y6 + 27*ys2 }-> s29 :|: s27 >= 0, s27 <= 2 * ys2, s28 >= 0, s28 <= s27 + 2, s29 >= 0, s29 <= s28 + 2, s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 48 + y2 + y7 + 27*ys3 }-> s32 :|: s30 >= 0, s30 <= 2 * ys3, s31 >= 0, s31 <= s30 + 2, s32 >= 0, s32 <= s31 + 2, s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 45 + y8 + 27*ys4 }-> s35 :|: s33 >= 0, s33 <= 2 * ys4, s34 >= 0, s34 <= s33 + 2, s35 >= 0, s35 <= s34 + 2, s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 6 + clause' + 2*cnf' }-> satck(1 + clause' + cnf', 1 + s'' + s17) :|: s17 >= 0, s17 <= cnf', s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 41 + 27*ls2 }-> if(if(s58, 0, verify(ls2)), 1 + l2 + ls2, 3) :|: s58 >= 0, s58 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 42 + 27*ls2 }-> if(if(s59, 0, verify(ls2)), 1 + l2 + ls2, 3) :|: s59 >= 0, s59 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 70 }-> s37 :|: s36 >= 0, s36 <= 2 * 1, s37 >= 0, s37 <= 2 + 0, z - 3 >= 0
   verify(z) -{ 42 + 27*ls }-> s39 :|: s38 >= 0, s38 <= 2 * ls, s39 >= 0, s39 <= 0 + 0, z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 42 + 27*ls }-> s41 :|: s40 >= 0, s40 <= 2 * ls, s41 >= 0, s41 <= 0 + 0, x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 69 }-> s43 :|: s42 >= 0, s42 <= 2 * 1, s43 >= 0, s43 <= 2 + 0, z - 2 >= 0
   verify(z) -{ 41 + 27*ls }-> s45 :|: s44 >= 0, s44 <= 2 * ls, s45 >= 0, s45 <= 0 + 0, l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 108 + 27*l' + 54*ls' }-> if(s46, 0, if(s47, 0, verify(ls'))) :|: s46 >= 0, s46 <= 2 * (1 + l' + ls'), s47 >= 0, s47 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 109 + 27*l' + 54*ls' }-> if(s48, 0, if(s49, 0, verify(ls'))) :|: s48 >= 0, s48 <= 2 * (1 + l' + ls'), s49 >= 0, s49 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 108 + 27*l'' + 54*ls'' }-> if(s50, 0, if(s51, 0, verify(ls''))) :|: s50 >= 0, s50 <= 2 * (1 + l'' + ls''), s51 >= 0, s51 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 109 + 27*l'' + 54*ls'' }-> if(s52, 0, if(s53, 0, verify(ls''))) :|: s52 >= 0, s52 <= 2 * (1 + l'' + ls''), s53 >= 0, s53 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 107 + 27*l1 + 54*ls1 }-> if(s54, 0, if(s55, 0, verify(ls1))) :|: s54 >= 0, s54 <= 2 * (1 + l1 + ls1), s55 >= 0, s55 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 108 + 27*l1 + 54*ls1 }-> if(s56, 0, if(s57, 0, verify(ls1))) :|: s56 >= 0, s56 <= 2 * (1 + l1 + ls1), s57 >= 0, s57 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']
  guess: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z]
  member: runtime: O(n^1) [39 + 27*z'], size: O(n^1) [2*z']
  verify: runtime: O(n^2) [617 + 505*z + 108*z^2], 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:

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 5 + clause + 2*cnf }-> 1 + s' + s16 :|: s16 >= 0, s16 <= cnf, s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y3 + 27*ys' }-> s20 :|: s18 >= 0, s18 <= 2 * ys', s19 >= 0, s19 <= s18 + 2, s20 >= 0, s20 <= s19 + 2, s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 48 + y' + y4 + 27*ys'' }-> s23 :|: s21 >= 0, s21 <= 2 * ys'', s22 >= 0, s22 <= s21 + 2, s23 >= 0, s23 <= s22 + 2, s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 46 + y5 + 27*ys1 }-> s26 :|: s24 >= 0, s24 <= 2 * ys1, s25 >= 0, s25 <= s24 + 2, s26 >= 0, s26 <= s25 + 2, s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y6 + 27*ys2 }-> s29 :|: s27 >= 0, s27 <= 2 * ys2, s28 >= 0, s28 <= s27 + 2, s29 >= 0, s29 <= s28 + 2, s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 48 + y2 + y7 + 27*ys3 }-> s32 :|: s30 >= 0, s30 <= 2 * ys3, s31 >= 0, s31 <= s30 + 2, s32 >= 0, s32 <= s31 + 2, s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 45 + y8 + 27*ys4 }-> s35 :|: s33 >= 0, s33 <= 2 * ys4, s34 >= 0, s34 <= s33 + 2, s35 >= 0, s35 <= s34 + 2, s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 6 + clause' + 2*cnf' }-> satck(1 + clause' + cnf', 1 + s'' + s17) :|: s17 >= 0, s17 <= cnf', s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 660 + 532*ls2 + 108*ls2^2 }-> s80 :|: s78 >= 0, s78 <= 2, s79 >= 0, s79 <= s78 + 0, s80 >= 0, s80 <= 3 + (1 + l2 + ls2), s58 >= 0, s58 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 661 + 532*ls2 + 108*ls2^2 }-> s83 :|: s81 >= 0, s81 <= 2, s82 >= 0, s82 <= s81 + 0, s83 >= 0, s83 <= 3 + (1 + l2 + ls2), s59 >= 0, s59 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 70 }-> s37 :|: s36 >= 0, s36 <= 2 * 1, s37 >= 0, s37 <= 2 + 0, z - 3 >= 0
   verify(z) -{ 42 + 27*ls }-> s39 :|: s38 >= 0, s38 <= 2 * ls, s39 >= 0, s39 <= 0 + 0, z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 42 + 27*ls }-> s41 :|: s40 >= 0, s40 <= 2 * ls, s41 >= 0, s41 <= 0 + 0, x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 69 }-> s43 :|: s42 >= 0, s42 <= 2 * 1, s43 >= 0, s43 <= 2 + 0, z - 2 >= 0
   verify(z) -{ 41 + 27*ls }-> s45 :|: s44 >= 0, s44 <= 2 * ls, s45 >= 0, s45 <= 0 + 0, l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 727 + 27*l' + 559*ls' + 108*ls'^2 }-> s62 :|: s60 >= 0, s60 <= 2, s61 >= 0, s61 <= s60 + 0, s62 >= 0, s62 <= s61 + 0, s46 >= 0, s46 <= 2 * (1 + l' + ls'), s47 >= 0, s47 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 728 + 27*l' + 559*ls' + 108*ls'^2 }-> s65 :|: s63 >= 0, s63 <= 2, s64 >= 0, s64 <= s63 + 0, s65 >= 0, s65 <= s64 + 0, s48 >= 0, s48 <= 2 * (1 + l' + ls'), s49 >= 0, s49 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 727 + 27*l'' + 559*ls'' + 108*ls''^2 }-> s68 :|: s66 >= 0, s66 <= 2, s67 >= 0, s67 <= s66 + 0, s68 >= 0, s68 <= s67 + 0, s50 >= 0, s50 <= 2 * (1 + l'' + ls''), s51 >= 0, s51 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 728 + 27*l'' + 559*ls'' + 108*ls''^2 }-> s71 :|: s69 >= 0, s69 <= 2, s70 >= 0, s70 <= s69 + 0, s71 >= 0, s71 <= s70 + 0, s52 >= 0, s52 <= 2 * (1 + l'' + ls''), s53 >= 0, s53 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 726 + 27*l1 + 559*ls1 + 108*ls1^2 }-> s74 :|: s72 >= 0, s72 <= 2, s73 >= 0, s73 <= s72 + 0, s74 >= 0, s74 <= s73 + 0, s54 >= 0, s54 <= 2 * (1 + l1 + ls1), s55 >= 0, s55 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 727 + 27*l1 + 559*ls1 + 108*ls1^2 }-> s77 :|: s75 >= 0, s75 <= 2, s76 >= 0, s76 <= s75 + 0, s77 >= 0, s77 <= s76 + 0, s56 >= 0, s56 <= 2 * (1 + l1 + ls1), s57 >= 0, s57 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']
  guess: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z]
  member: runtime: O(n^1) [39 + 27*z'], size: O(n^1) [2*z']
  verify: runtime: O(n^2) [617 + 505*z + 108*z^2], size: O(1) [2]

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

(61) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 5 + clause + 2*cnf }-> 1 + s' + s16 :|: s16 >= 0, s16 <= cnf, s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y3 + 27*ys' }-> s20 :|: s18 >= 0, s18 <= 2 * ys', s19 >= 0, s19 <= s18 + 2, s20 >= 0, s20 <= s19 + 2, s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 48 + y' + y4 + 27*ys'' }-> s23 :|: s21 >= 0, s21 <= 2 * ys'', s22 >= 0, s22 <= s21 + 2, s23 >= 0, s23 <= s22 + 2, s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 46 + y5 + 27*ys1 }-> s26 :|: s24 >= 0, s24 <= 2 * ys1, s25 >= 0, s25 <= s24 + 2, s26 >= 0, s26 <= s25 + 2, s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y6 + 27*ys2 }-> s29 :|: s27 >= 0, s27 <= 2 * ys2, s28 >= 0, s28 <= s27 + 2, s29 >= 0, s29 <= s28 + 2, s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 48 + y2 + y7 + 27*ys3 }-> s32 :|: s30 >= 0, s30 <= 2 * ys3, s31 >= 0, s31 <= s30 + 2, s32 >= 0, s32 <= s31 + 2, s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 45 + y8 + 27*ys4 }-> s35 :|: s33 >= 0, s33 <= 2 * ys4, s34 >= 0, s34 <= s33 + 2, s35 >= 0, s35 <= s34 + 2, s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 6 + clause' + 2*cnf' }-> satck(1 + clause' + cnf', 1 + s'' + s17) :|: s17 >= 0, s17 <= cnf', s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 660 + 532*ls2 + 108*ls2^2 }-> s80 :|: s78 >= 0, s78 <= 2, s79 >= 0, s79 <= s78 + 0, s80 >= 0, s80 <= 3 + (1 + l2 + ls2), s58 >= 0, s58 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 661 + 532*ls2 + 108*ls2^2 }-> s83 :|: s81 >= 0, s81 <= 2, s82 >= 0, s82 <= s81 + 0, s83 >= 0, s83 <= 3 + (1 + l2 + ls2), s59 >= 0, s59 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 70 }-> s37 :|: s36 >= 0, s36 <= 2 * 1, s37 >= 0, s37 <= 2 + 0, z - 3 >= 0
   verify(z) -{ 42 + 27*ls }-> s39 :|: s38 >= 0, s38 <= 2 * ls, s39 >= 0, s39 <= 0 + 0, z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 42 + 27*ls }-> s41 :|: s40 >= 0, s40 <= 2 * ls, s41 >= 0, s41 <= 0 + 0, x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 69 }-> s43 :|: s42 >= 0, s42 <= 2 * 1, s43 >= 0, s43 <= 2 + 0, z - 2 >= 0
   verify(z) -{ 41 + 27*ls }-> s45 :|: s44 >= 0, s44 <= 2 * ls, s45 >= 0, s45 <= 0 + 0, l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 727 + 27*l' + 559*ls' + 108*ls'^2 }-> s62 :|: s60 >= 0, s60 <= 2, s61 >= 0, s61 <= s60 + 0, s62 >= 0, s62 <= s61 + 0, s46 >= 0, s46 <= 2 * (1 + l' + ls'), s47 >= 0, s47 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 728 + 27*l' + 559*ls' + 108*ls'^2 }-> s65 :|: s63 >= 0, s63 <= 2, s64 >= 0, s64 <= s63 + 0, s65 >= 0, s65 <= s64 + 0, s48 >= 0, s48 <= 2 * (1 + l' + ls'), s49 >= 0, s49 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 727 + 27*l'' + 559*ls'' + 108*ls''^2 }-> s68 :|: s66 >= 0, s66 <= 2, s67 >= 0, s67 <= s66 + 0, s68 >= 0, s68 <= s67 + 0, s50 >= 0, s50 <= 2 * (1 + l'' + ls''), s51 >= 0, s51 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 728 + 27*l'' + 559*ls'' + 108*ls''^2 }-> s71 :|: s69 >= 0, s69 <= 2, s70 >= 0, s70 <= s69 + 0, s71 >= 0, s71 <= s70 + 0, s52 >= 0, s52 <= 2 * (1 + l'' + ls''), s53 >= 0, s53 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 726 + 27*l1 + 559*ls1 + 108*ls1^2 }-> s74 :|: s72 >= 0, s72 <= 2, s73 >= 0, s73 <= s72 + 0, s74 >= 0, s74 <= s73 + 0, s54 >= 0, s54 <= 2 * (1 + l1 + ls1), s55 >= 0, s55 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 727 + 27*l1 + 559*ls1 + 108*ls1^2 }-> s77 :|: s75 >= 0, s75 <= 2, s76 >= 0, s76 <= s75 + 0, s77 >= 0, s77 <= s76 + 0, s56 >= 0, s56 <= 2 * (1 + l1 + ls1), s57 >= 0, s57 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {satck}, {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']
  guess: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z]
  member: runtime: O(n^1) [39 + 27*z'], size: O(n^1) [2*z']
  verify: runtime: O(n^2) [617 + 505*z + 108*z^2], size: O(1) [2]
  satck: runtime: ?, size: O(n^1) [3 + z']

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

(63) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 5 + clause + 2*cnf }-> 1 + s' + s16 :|: s16 >= 0, s16 <= cnf, s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y3 + 27*ys' }-> s20 :|: s18 >= 0, s18 <= 2 * ys', s19 >= 0, s19 <= s18 + 2, s20 >= 0, s20 <= s19 + 2, s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 48 + y' + y4 + 27*ys'' }-> s23 :|: s21 >= 0, s21 <= 2 * ys'', s22 >= 0, s22 <= s21 + 2, s23 >= 0, s23 <= s22 + 2, s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 46 + y5 + 27*ys1 }-> s26 :|: s24 >= 0, s24 <= 2 * ys1, s25 >= 0, s25 <= s24 + 2, s26 >= 0, s26 <= s25 + 2, s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y6 + 27*ys2 }-> s29 :|: s27 >= 0, s27 <= 2 * ys2, s28 >= 0, s28 <= s27 + 2, s29 >= 0, s29 <= s28 + 2, s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 48 + y2 + y7 + 27*ys3 }-> s32 :|: s30 >= 0, s30 <= 2 * ys3, s31 >= 0, s31 <= s30 + 2, s32 >= 0, s32 <= s31 + 2, s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 45 + y8 + 27*ys4 }-> s35 :|: s33 >= 0, s33 <= 2 * ys4, s34 >= 0, s34 <= s33 + 2, s35 >= 0, s35 <= s34 + 2, s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 1 }-> satck(z, 0) :|: z >= 0
   sat(z) -{ 2 }-> satck(1, 1) :|: z = 1
   sat(z) -{ 6 + clause' + 2*cnf' }-> satck(1 + clause' + cnf', 1 + s'' + s17) :|: s17 >= 0, s17 <= cnf', s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 660 + 532*ls2 + 108*ls2^2 }-> s80 :|: s78 >= 0, s78 <= 2, s79 >= 0, s79 <= s78 + 0, s80 >= 0, s80 <= 3 + (1 + l2 + ls2), s58 >= 0, s58 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 661 + 532*ls2 + 108*ls2^2 }-> s83 :|: s81 >= 0, s81 <= 2, s82 >= 0, s82 <= s81 + 0, s83 >= 0, s83 <= 3 + (1 + l2 + ls2), s59 >= 0, s59 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 70 }-> s37 :|: s36 >= 0, s36 <= 2 * 1, s37 >= 0, s37 <= 2 + 0, z - 3 >= 0
   verify(z) -{ 42 + 27*ls }-> s39 :|: s38 >= 0, s38 <= 2 * ls, s39 >= 0, s39 <= 0 + 0, z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 42 + 27*ls }-> s41 :|: s40 >= 0, s40 <= 2 * ls, s41 >= 0, s41 <= 0 + 0, x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 69 }-> s43 :|: s42 >= 0, s42 <= 2 * 1, s43 >= 0, s43 <= 2 + 0, z - 2 >= 0
   verify(z) -{ 41 + 27*ls }-> s45 :|: s44 >= 0, s44 <= 2 * ls, s45 >= 0, s45 <= 0 + 0, l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 727 + 27*l' + 559*ls' + 108*ls'^2 }-> s62 :|: s60 >= 0, s60 <= 2, s61 >= 0, s61 <= s60 + 0, s62 >= 0, s62 <= s61 + 0, s46 >= 0, s46 <= 2 * (1 + l' + ls'), s47 >= 0, s47 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 728 + 27*l' + 559*ls' + 108*ls'^2 }-> s65 :|: s63 >= 0, s63 <= 2, s64 >= 0, s64 <= s63 + 0, s65 >= 0, s65 <= s64 + 0, s48 >= 0, s48 <= 2 * (1 + l' + ls'), s49 >= 0, s49 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 727 + 27*l'' + 559*ls'' + 108*ls''^2 }-> s68 :|: s66 >= 0, s66 <= 2, s67 >= 0, s67 <= s66 + 0, s68 >= 0, s68 <= s67 + 0, s50 >= 0, s50 <= 2 * (1 + l'' + ls''), s51 >= 0, s51 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 728 + 27*l'' + 559*ls'' + 108*ls''^2 }-> s71 :|: s69 >= 0, s69 <= 2, s70 >= 0, s70 <= s69 + 0, s71 >= 0, s71 <= s70 + 0, s52 >= 0, s52 <= 2 * (1 + l'' + ls''), s53 >= 0, s53 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 726 + 27*l1 + 559*ls1 + 108*ls1^2 }-> s74 :|: s72 >= 0, s72 <= 2, s73 >= 0, s73 <= s72 + 0, s74 >= 0, s74 <= s73 + 0, s54 >= 0, s54 <= 2 * (1 + l1 + ls1), s55 >= 0, s55 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 727 + 27*l1 + 559*ls1 + 108*ls1^2 }-> s77 :|: s75 >= 0, s75 <= 2, s76 >= 0, s76 <= s75 + 0, s77 >= 0, s77 <= s76 + 0, s56 >= 0, s56 <= 2 * (1 + l1 + ls1), s57 >= 0, s57 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']
  guess: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z]
  member: runtime: O(n^1) [39 + 27*z'], size: O(n^1) [2*z']
  verify: runtime: O(n^2) [617 + 505*z + 108*z^2], size: O(1) [2]
  satck: runtime: O(n^2) [1329 + 1064*z' + 216*z'^2], size: O(n^1) [3 + 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:

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 5 + clause + 2*cnf }-> 1 + s' + s16 :|: s16 >= 0, s16 <= cnf, s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y3 + 27*ys' }-> s20 :|: s18 >= 0, s18 <= 2 * ys', s19 >= 0, s19 <= s18 + 2, s20 >= 0, s20 <= s19 + 2, s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 48 + y' + y4 + 27*ys'' }-> s23 :|: s21 >= 0, s21 <= 2 * ys'', s22 >= 0, s22 <= s21 + 2, s23 >= 0, s23 <= s22 + 2, s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 46 + y5 + 27*ys1 }-> s26 :|: s24 >= 0, s24 <= 2 * ys1, s25 >= 0, s25 <= s24 + 2, s26 >= 0, s26 <= s25 + 2, s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y6 + 27*ys2 }-> s29 :|: s27 >= 0, s27 <= 2 * ys2, s28 >= 0, s28 <= s27 + 2, s29 >= 0, s29 <= s28 + 2, s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 48 + y2 + y7 + 27*ys3 }-> s32 :|: s30 >= 0, s30 <= 2 * ys3, s31 >= 0, s31 <= s30 + 2, s32 >= 0, s32 <= s31 + 2, s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 45 + y8 + 27*ys4 }-> s35 :|: s33 >= 0, s33 <= 2 * ys4, s34 >= 0, s34 <= s33 + 2, s35 >= 0, s35 <= s34 + 2, s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 2611 }-> s84 :|: s84 >= 0, s84 <= 1 + 3, z = 1
   sat(z) -{ 2615 + clause' + 2*cnf' + 1496*s'' + 432*s''*s17 + 216*s''^2 + 1496*s17 + 216*s17^2 }-> s85 :|: s85 >= 0, s85 <= 1 + s'' + s17 + 3, s17 >= 0, s17 <= cnf', s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   sat(z) -{ 1330 }-> s86 :|: s86 >= 0, s86 <= 0 + 3, z >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 660 + 532*ls2 + 108*ls2^2 }-> s80 :|: s78 >= 0, s78 <= 2, s79 >= 0, s79 <= s78 + 0, s80 >= 0, s80 <= 3 + (1 + l2 + ls2), s58 >= 0, s58 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 661 + 532*ls2 + 108*ls2^2 }-> s83 :|: s81 >= 0, s81 <= 2, s82 >= 0, s82 <= s81 + 0, s83 >= 0, s83 <= 3 + (1 + l2 + ls2), s59 >= 0, s59 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 70 }-> s37 :|: s36 >= 0, s36 <= 2 * 1, s37 >= 0, s37 <= 2 + 0, z - 3 >= 0
   verify(z) -{ 42 + 27*ls }-> s39 :|: s38 >= 0, s38 <= 2 * ls, s39 >= 0, s39 <= 0 + 0, z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 42 + 27*ls }-> s41 :|: s40 >= 0, s40 <= 2 * ls, s41 >= 0, s41 <= 0 + 0, x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 69 }-> s43 :|: s42 >= 0, s42 <= 2 * 1, s43 >= 0, s43 <= 2 + 0, z - 2 >= 0
   verify(z) -{ 41 + 27*ls }-> s45 :|: s44 >= 0, s44 <= 2 * ls, s45 >= 0, s45 <= 0 + 0, l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 727 + 27*l' + 559*ls' + 108*ls'^2 }-> s62 :|: s60 >= 0, s60 <= 2, s61 >= 0, s61 <= s60 + 0, s62 >= 0, s62 <= s61 + 0, s46 >= 0, s46 <= 2 * (1 + l' + ls'), s47 >= 0, s47 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 728 + 27*l' + 559*ls' + 108*ls'^2 }-> s65 :|: s63 >= 0, s63 <= 2, s64 >= 0, s64 <= s63 + 0, s65 >= 0, s65 <= s64 + 0, s48 >= 0, s48 <= 2 * (1 + l' + ls'), s49 >= 0, s49 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 727 + 27*l'' + 559*ls'' + 108*ls''^2 }-> s68 :|: s66 >= 0, s66 <= 2, s67 >= 0, s67 <= s66 + 0, s68 >= 0, s68 <= s67 + 0, s50 >= 0, s50 <= 2 * (1 + l'' + ls''), s51 >= 0, s51 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 728 + 27*l'' + 559*ls'' + 108*ls''^2 }-> s71 :|: s69 >= 0, s69 <= 2, s70 >= 0, s70 <= s69 + 0, s71 >= 0, s71 <= s70 + 0, s52 >= 0, s52 <= 2 * (1 + l'' + ls''), s53 >= 0, s53 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 726 + 27*l1 + 559*ls1 + 108*ls1^2 }-> s74 :|: s72 >= 0, s72 <= 2, s73 >= 0, s73 <= s72 + 0, s74 >= 0, s74 <= s73 + 0, s54 >= 0, s54 <= 2 * (1 + l1 + ls1), s55 >= 0, s55 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 727 + 27*l1 + 559*ls1 + 108*ls1^2 }-> s77 :|: s75 >= 0, s75 <= 2, s76 >= 0, s76 <= s75 + 0, s77 >= 0, s77 <= s76 + 0, s56 >= 0, s56 <= 2 * (1 + l1 + ls1), s57 >= 0, s57 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']
  guess: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z]
  member: runtime: O(n^1) [39 + 27*z'], size: O(n^1) [2*z']
  verify: runtime: O(n^2) [617 + 505*z + 108*z^2], size: O(1) [2]
  satck: runtime: O(n^2) [1329 + 1064*z' + 216*z'^2], size: O(n^1) [3 + z']

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

(67) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 5 + clause + 2*cnf }-> 1 + s' + s16 :|: s16 >= 0, s16 <= cnf, s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y3 + 27*ys' }-> s20 :|: s18 >= 0, s18 <= 2 * ys', s19 >= 0, s19 <= s18 + 2, s20 >= 0, s20 <= s19 + 2, s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 48 + y' + y4 + 27*ys'' }-> s23 :|: s21 >= 0, s21 <= 2 * ys'', s22 >= 0, s22 <= s21 + 2, s23 >= 0, s23 <= s22 + 2, s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 46 + y5 + 27*ys1 }-> s26 :|: s24 >= 0, s24 <= 2 * ys1, s25 >= 0, s25 <= s24 + 2, s26 >= 0, s26 <= s25 + 2, s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y6 + 27*ys2 }-> s29 :|: s27 >= 0, s27 <= 2 * ys2, s28 >= 0, s28 <= s27 + 2, s29 >= 0, s29 <= s28 + 2, s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 48 + y2 + y7 + 27*ys3 }-> s32 :|: s30 >= 0, s30 <= 2 * ys3, s31 >= 0, s31 <= s30 + 2, s32 >= 0, s32 <= s31 + 2, s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 45 + y8 + 27*ys4 }-> s35 :|: s33 >= 0, s33 <= 2 * ys4, s34 >= 0, s34 <= s33 + 2, s35 >= 0, s35 <= s34 + 2, s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 2611 }-> s84 :|: s84 >= 0, s84 <= 1 + 3, z = 1
   sat(z) -{ 2615 + clause' + 2*cnf' + 1496*s'' + 432*s''*s17 + 216*s''^2 + 1496*s17 + 216*s17^2 }-> s85 :|: s85 >= 0, s85 <= 1 + s'' + s17 + 3, s17 >= 0, s17 <= cnf', s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   sat(z) -{ 1330 }-> s86 :|: s86 >= 0, s86 <= 0 + 3, z >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 660 + 532*ls2 + 108*ls2^2 }-> s80 :|: s78 >= 0, s78 <= 2, s79 >= 0, s79 <= s78 + 0, s80 >= 0, s80 <= 3 + (1 + l2 + ls2), s58 >= 0, s58 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 661 + 532*ls2 + 108*ls2^2 }-> s83 :|: s81 >= 0, s81 <= 2, s82 >= 0, s82 <= s81 + 0, s83 >= 0, s83 <= 3 + (1 + l2 + ls2), s59 >= 0, s59 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 70 }-> s37 :|: s36 >= 0, s36 <= 2 * 1, s37 >= 0, s37 <= 2 + 0, z - 3 >= 0
   verify(z) -{ 42 + 27*ls }-> s39 :|: s38 >= 0, s38 <= 2 * ls, s39 >= 0, s39 <= 0 + 0, z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 42 + 27*ls }-> s41 :|: s40 >= 0, s40 <= 2 * ls, s41 >= 0, s41 <= 0 + 0, x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 69 }-> s43 :|: s42 >= 0, s42 <= 2 * 1, s43 >= 0, s43 <= 2 + 0, z - 2 >= 0
   verify(z) -{ 41 + 27*ls }-> s45 :|: s44 >= 0, s44 <= 2 * ls, s45 >= 0, s45 <= 0 + 0, l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 727 + 27*l' + 559*ls' + 108*ls'^2 }-> s62 :|: s60 >= 0, s60 <= 2, s61 >= 0, s61 <= s60 + 0, s62 >= 0, s62 <= s61 + 0, s46 >= 0, s46 <= 2 * (1 + l' + ls'), s47 >= 0, s47 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 728 + 27*l' + 559*ls' + 108*ls'^2 }-> s65 :|: s63 >= 0, s63 <= 2, s64 >= 0, s64 <= s63 + 0, s65 >= 0, s65 <= s64 + 0, s48 >= 0, s48 <= 2 * (1 + l' + ls'), s49 >= 0, s49 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 727 + 27*l'' + 559*ls'' + 108*ls''^2 }-> s68 :|: s66 >= 0, s66 <= 2, s67 >= 0, s67 <= s66 + 0, s68 >= 0, s68 <= s67 + 0, s50 >= 0, s50 <= 2 * (1 + l'' + ls''), s51 >= 0, s51 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 728 + 27*l'' + 559*ls'' + 108*ls''^2 }-> s71 :|: s69 >= 0, s69 <= 2, s70 >= 0, s70 <= s69 + 0, s71 >= 0, s71 <= s70 + 0, s52 >= 0, s52 <= 2 * (1 + l'' + ls''), s53 >= 0, s53 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 726 + 27*l1 + 559*ls1 + 108*ls1^2 }-> s74 :|: s72 >= 0, s72 <= 2, s73 >= 0, s73 <= s72 + 0, s74 >= 0, s74 <= s73 + 0, s54 >= 0, s54 <= 2 * (1 + l1 + ls1), s55 >= 0, s55 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 727 + 27*l1 + 559*ls1 + 108*ls1^2 }-> s77 :|: s75 >= 0, s75 <= 2, s76 >= 0, s76 <= s75 + 0, s77 >= 0, s77 <= s76 + 0, s56 >= 0, s56 <= 2 * (1 + l1 + ls1), s57 >= 0, s57 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {sat}
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']
  guess: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z]
  member: runtime: O(n^1) [39 + 27*z'], size: O(n^1) [2*z']
  verify: runtime: O(n^2) [617 + 505*z + 108*z^2], size: O(1) [2]
  satck: runtime: O(n^2) [1329 + 1064*z' + 216*z'^2], size: O(n^1) [3 + z']
  sat: runtime: ?, size: O(n^1) [3 + z]

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

(69) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   choice(z) -{ 2 + xs }-> s :|: s >= 0, s <= xs, z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 1 }-> x :|: z = 1 + x + xs, xs >= 0, x >= 0
   choice(z) -{ 0 }-> 0 :|: z >= 0
   eq(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 2 :|: z = 1, z' = 1
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   guess(z) -{ 1 }-> 1 :|: z = 1
   guess(z) -{ 0 }-> 0 :|: z >= 0
   guess(z) -{ 5 + clause + 2*cnf }-> 1 + s' + s16 :|: s16 >= 0, s16 <= cnf, s' >= 0, s' <= clause, cnf >= 0, z = 1 + clause + cnf, clause >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z' >= 0, z'' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   member(z, z') -{ 4 }-> e :|: z' - 3 >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 }-> e :|: z >= 0, z' - 2 >= 0, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 2 }-> e :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, 2 = t, t >= 0, e >= 0, 0 = 0, 0 = e
   member(z, z') -{ 3 + z' }-> s13 :|: s13 >= 0, s13 <= 0 + 2, s3 >= 0, s3 <= 2, z - 1 >= 0, z' - 3 >= 0
   member(z, z') -{ 5 + y' }-> s14 :|: s14 >= 0, s14 <= 0 + 2, s6 >= 0, s6 <= 2, z' = 1 + (1 + y') + ys, ys >= 0, z - 1 >= 0, y' >= 0
   member(z, z') -{ 5 + y2 }-> s15 :|: s15 >= 0, s15 <= 0 + 2, s11 >= 0, s11 <= 2, z' = 1 + (1 + y2) + ys, ys >= 0, y2 >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y3 + 27*ys' }-> s20 :|: s18 >= 0, s18 <= 2 * ys', s19 >= 0, s19 <= s18 + 2, s20 >= 0, s20 <= s19 + 2, s2 >= 0, s2 <= 2, z = 1, ys' >= 0, z' = 1 + 1 + (1 + y3 + ys'), y3 >= 0
   member(z, z') -{ 48 + y' + y4 + 27*ys'' }-> s23 :|: s21 >= 0, s21 <= 2 * ys'', s22 >= 0, s22 <= s21 + 2, s23 >= 0, s23 <= s22 + 2, s4 >= 0, s4 <= 2, s5 >= 0, s5 <= 2, z' = 1 + (1 + y') + (1 + y4 + ys''), z - 1 >= 0, y' >= 0, ys'' >= 0, y4 >= 0
   member(z, z') -{ 46 + y5 + 27*ys1 }-> s26 :|: s24 >= 0, s24 <= 2 * ys1, s25 >= 0, s25 <= s24 + 2, s26 >= 0, s26 <= s25 + 2, s7 >= 0, s7 <= 2, y5 >= 0, ys1 >= 0, z' = 1 + (1 + y'') + (1 + y5 + ys1), y'' >= 0, z - 1 >= 0
   member(z, z') -{ 46 + y6 + 27*ys2 }-> s29 :|: s27 >= 0, s27 <= 2 * ys2, s28 >= 0, s28 <= s27 + 2, s29 >= 0, s29 <= s28 + 2, s8 >= 0, s8 <= 2, y1 >= 0, z - 1 >= 0, z' = 1 + (1 + y1) + (1 + y6 + ys2), y6 >= 0, ys2 >= 0
   member(z, z') -{ 48 + y2 + y7 + 27*ys3 }-> s32 :|: s30 >= 0, s30 <= 2 * ys3, s31 >= 0, s31 <= s30 + 2, s32 >= 0, s32 <= s31 + 2, s9 >= 0, s9 <= 2, s10 >= 0, s10 <= 2, y7 >= 0, ys3 >= 0, y2 >= 0, z - 1 >= 0, z' = 1 + (1 + y2) + (1 + y7 + ys3)
   member(z, z') -{ 45 + y8 + 27*ys4 }-> s35 :|: s33 >= 0, s33 <= 2 * ys4, s34 >= 0, s34 <= s33 + 2, s35 >= 0, s35 <= s34 + 2, s12 >= 0, s12 <= 2, z' = 1 + y + (1 + y8 + ys4), y8 >= 0, z >= 0, y >= 0, ys4 >= 0
   member(z, z') -{ 4 }-> t :|: z' = 1 + 1 + 1, z = 1, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 3 }-> t :|: z = 1, z' - 2 >= 0, 2 = 2, 2 = t, t >= 0, e >= 0, 0 = e
   member(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 1
   member(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   member(z, z') -{ 3 }-> 0 :|: z' = 1 + 1 + 1, z = 1, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z = 1, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 2 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 3 }-> 0 :|: z' - 3 >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z' = 1 + (1 + y'') + ys, ys >= 0, y'' >= 0, z - 1 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: y1 >= 0, z - 1 >= 0, ys >= 0, z' = 1 + (1 + y1) + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 2 }-> 0 :|: z >= 0, z' - 2 >= 0, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   member(z, z') -{ 1 }-> 0 :|: ys >= 0, z >= 0, y >= 0, z' = 1 + y + ys, v0 >= 0, 0 = v2, v1 >= 0, 0 = v0, 2 = v1, v2 >= 0
   negate(z) -{ 0 }-> 0 :|: z >= 0
   negate(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   sat(z) -{ 2611 }-> s84 :|: s84 >= 0, s84 <= 1 + 3, z = 1
   sat(z) -{ 2615 + clause' + 2*cnf' + 1496*s'' + 432*s''*s17 + 216*s''^2 + 1496*s17 + 216*s17^2 }-> s85 :|: s85 >= 0, s85 <= 1 + s'' + s17 + 3, s17 >= 0, s17 <= cnf', s'' >= 0, s'' <= clause', clause' >= 0, z = 1 + clause' + cnf', cnf' >= 0
   sat(z) -{ 1330 }-> s86 :|: s86 >= 0, s86 <= 0 + 3, z >= 0
   satck(z, z') -{ 2 }-> e :|: z >= 0, z' >= 0, e >= 0, 0 = 0, 3 = e
   satck(z, z') -{ 660 + 532*ls2 + 108*ls2^2 }-> s80 :|: s78 >= 0, s78 <= 2, s79 >= 0, s79 <= s78 + 0, s80 >= 0, s80 <= 3 + (1 + l2 + ls2), s58 >= 0, s58 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, v0 >= 0, l2 = v0
   satck(z, z') -{ 661 + 532*ls2 + 108*ls2^2 }-> s83 :|: s81 >= 0, s81 <= 2, s82 >= 0, s82 <= s81 + 0, s83 >= 0, s83 <= 3 + (1 + l2 + ls2), s59 >= 0, s59 <= 2 * ls2, z' = 1 + l2 + ls2, z >= 0, l2 >= 0, ls2 >= 0, x >= 0, l2 = 1 + x
   satck(z, z') -{ 3 }-> t :|: z >= 0, z' = 1, 2 = 2, 1 = t, t >= 0, e >= 0, 3 = e
   satck(z, z') -{ 2 }-> 0 :|: z >= 0, z' = 1, v0 >= 0, 3 = v2, v1 >= 0, 2 = v0, 1 = v1, v2 >= 0
   satck(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 3 = v2, 0 = v0, v2 >= 0
   verify(z) -{ 70 }-> s37 :|: s36 >= 0, s36 <= 2 * 1, s37 >= 0, s37 <= 2 + 0, z - 3 >= 0
   verify(z) -{ 42 + 27*ls }-> s39 :|: s38 >= 0, s38 <= 2 * ls, s39 >= 0, s39 <= 0 + 0, z = 1 + (1 + x3) + ls, ls >= 0, x3 >= 0
   verify(z) -{ 42 + 27*ls }-> s41 :|: s40 >= 0, s40 <= 2 * ls, s41 >= 0, s41 <= 0 + 0, x4 >= 0, ls >= 0, z = 1 + (1 + x4) + ls
   verify(z) -{ 69 }-> s43 :|: s42 >= 0, s42 <= 2 * 1, s43 >= 0, s43 <= 2 + 0, z - 2 >= 0
   verify(z) -{ 41 + 27*ls }-> s45 :|: s44 >= 0, s44 <= 2 * ls, s45 >= 0, s45 <= 0 + 0, l >= 0, ls >= 0, z = 1 + l + ls
   verify(z) -{ 727 + 27*l' + 559*ls' + 108*ls'^2 }-> s62 :|: s60 >= 0, s60 <= 2, s61 >= 0, s61 <= s60 + 0, s62 >= 0, s62 <= s61 + 0, s46 >= 0, s46 <= 2 * (1 + l' + ls'), s47 >= 0, s47 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, v0 >= 0, l' = v0
   verify(z) -{ 728 + 27*l' + 559*ls' + 108*ls'^2 }-> s65 :|: s63 >= 0, s63 <= 2, s64 >= 0, s64 <= s63 + 0, s65 >= 0, s65 <= s64 + 0, s48 >= 0, s48 <= 2 * (1 + l' + ls'), s49 >= 0, s49 <= 2 * ls', ls' >= 0, l' >= 0, z = 1 + (1 + x3) + (1 + l' + ls'), x3 >= 0, x >= 0, l' = 1 + x
   verify(z) -{ 727 + 27*l'' + 559*ls'' + 108*ls''^2 }-> s68 :|: s66 >= 0, s66 <= 2, s67 >= 0, s67 <= s66 + 0, s68 >= 0, s68 <= s67 + 0, s50 >= 0, s50 <= 2 * (1 + l'' + ls''), s51 >= 0, s51 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, v0 >= 0, l'' = v0
   verify(z) -{ 728 + 27*l'' + 559*ls'' + 108*ls''^2 }-> s71 :|: s69 >= 0, s69 <= 2, s70 >= 0, s70 <= s69 + 0, s71 >= 0, s71 <= s70 + 0, s52 >= 0, s52 <= 2 * (1 + l'' + ls''), s53 >= 0, s53 <= 2 * ls'', x4 >= 0, l'' >= 0, z = 1 + (1 + x4) + (1 + l'' + ls''), ls'' >= 0, x >= 0, l'' = 1 + x
   verify(z) -{ 726 + 27*l1 + 559*ls1 + 108*ls1^2 }-> s74 :|: s72 >= 0, s72 <= 2, s73 >= 0, s73 <= s72 + 0, s74 >= 0, s74 <= s73 + 0, s54 >= 0, s54 <= 2 * (1 + l1 + ls1), s55 >= 0, s55 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, v0 >= 0, l1 = v0
   verify(z) -{ 727 + 27*l1 + 559*ls1 + 108*ls1^2 }-> s77 :|: s75 >= 0, s75 <= 2, s76 >= 0, s76 <= s75 + 0, s77 >= 0, s77 <= s76 + 0, s56 >= 0, s56 <= 2 * (1 + l1 + ls1), s57 >= 0, s57 <= 2 * ls1, z = 1 + l + (1 + l1 + ls1), l >= 0, l1 >= 0, ls1 >= 0, x >= 0, l1 = 1 + x
   verify(z) -{ 1 }-> 2 :|: z = 1
   verify(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: 
Previous analysis results are:
  choice: runtime: O(n^1) [1 + z], size: O(n^1) [z]
  eq: runtime: O(n^1) [2 + z'], size: O(1) [2]
  negate: runtime: O(1) [1], size: O(n^1) [z]
  if: runtime: O(1) [1], size: O(n^1) [z' + z'']
  guess: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z]
  member: runtime: O(n^1) [39 + 27*z'], size: O(n^1) [2*z']
  verify: runtime: O(n^2) [617 + 505*z + 108*z^2], size: O(1) [2]
  satck: runtime: O(n^2) [1329 + 1064*z' + 216*z'^2], size: O(n^1) [3 + z']
  sat: runtime: O(n^2) [6556 + 2995*z + 864*z^2], size: O(n^1) [3 + z]

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

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

(72)
BOUNDS(1, n^2)

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

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

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

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


The TRS R consists of the following rules:

   if(true, t, e) -> t
   if(false, t, e) -> e
   member(x, nil) -> false
   member(x, cons(y, ys)) -> if(eq(x, y), true, member(x, ys))
   eq(nil, nil) -> true
   eq(O(x), 0(y)) -> eq(x, y)
   eq(0(x), 1(y)) -> false
   eq(1(x), 0(y)) -> false
   eq(1(x), 1(y)) -> eq(x, y)
   negate(0(x)) -> 1(x)
   negate(1(x)) -> 0(x)
   choice(cons(x, xs)) -> x
   choice(cons(x, xs)) -> choice(xs)
   guess(nil) -> nil
   guess(cons(clause, cnf)) -> cons(choice(clause), guess(cnf))
   verify(nil) -> true
   verify(cons(l, ls)) -> if(member(negate(l), ls), false, verify(ls))
   sat(cnf) -> satck(cnf, guess(cnf))
   satck(cnf, assign) -> if(verify(assign), assign, unsat)

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

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

The rewrite sequence

member(x, cons(y, ys)) ->^+ if(eq(x, y), true, member(x, ys))

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

The pumping substitution is [ys / cons(y, ys)].

The result substitution is [ ].




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

(76)
Complex Obligation (BEST)

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

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

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


The TRS R consists of the following rules:

   if(true, t, e) -> t
   if(false, t, e) -> e
   member(x, nil) -> false
   member(x, cons(y, ys)) -> if(eq(x, y), true, member(x, ys))
   eq(nil, nil) -> true
   eq(O(x), 0(y)) -> eq(x, y)
   eq(0(x), 1(y)) -> false
   eq(1(x), 0(y)) -> false
   eq(1(x), 1(y)) -> eq(x, y)
   negate(0(x)) -> 1(x)
   negate(1(x)) -> 0(x)
   choice(cons(x, xs)) -> x
   choice(cons(x, xs)) -> choice(xs)
   guess(nil) -> nil
   guess(cons(clause, cnf)) -> cons(choice(clause), guess(cnf))
   verify(nil) -> true
   verify(cons(l, ls)) -> if(member(negate(l), ls), false, verify(ls))
   sat(cnf) -> satck(cnf, guess(cnf))
   satck(cnf, assign) -> if(verify(assign), assign, unsat)

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

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

(79)
BOUNDS(n^1, INF)

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

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

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


The TRS R consists of the following rules:

   if(true, t, e) -> t
   if(false, t, e) -> e
   member(x, nil) -> false
   member(x, cons(y, ys)) -> if(eq(x, y), true, member(x, ys))
   eq(nil, nil) -> true
   eq(O(x), 0(y)) -> eq(x, y)
   eq(0(x), 1(y)) -> false
   eq(1(x), 0(y)) -> false
   eq(1(x), 1(y)) -> eq(x, y)
   negate(0(x)) -> 1(x)
   negate(1(x)) -> 0(x)
   choice(cons(x, xs)) -> x
   choice(cons(x, xs)) -> choice(xs)
   guess(nil) -> nil
   guess(cons(clause, cnf)) -> cons(choice(clause), guess(cnf))
   verify(nil) -> true
   verify(cons(l, ls)) -> if(member(negate(l), ls), false, verify(ls))
   sat(cnf) -> satck(cnf, guess(cnf))
   satck(cnf, assign) -> if(verify(assign), assign, unsat)

S is empty.
Rewrite Strategy: INNERMOST