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


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


WORST_CASE(NON_POLY, ?)
proof of /export/starexec/sandbox/benchmark/theBenchmark.koat
# AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty


The runtime complexity of the given CpxIntTrs could be proven to be BOUNDS(INF, INF).

(0) CpxIntTrs
(1) Loat Proof [FINISHED, 1637 ms]
(2) BOUNDS(INF, INF)


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

(0)
Obligation:
Complexity Int TRS consisting of the following rules:
evalfstart(A, B, C, D, E, F, G) -> Com_1(evalfentryin(A, B, C, D, E, F, G)) :|: TRUE
evalfentryin(A, B, C, D, E, F, G) -> Com_1(evalfbb10in(B, C, D, A, E, F, G)) :|: TRUE
evalfbb10in(A, B, C, D, E, F, G) -> Com_1(evalfbb8in(A, B, C, D, 1, F, G)) :|: D >= 1
evalfbb10in(A, B, C, D, E, F, G) -> Com_1(evalfreturnin(A, B, C, D, E, F, G)) :|: 0 >= D
evalfbb8in(A, B, C, D, E, F, G) -> Com_1(evalfbb6in(A, B, C, D, E, D, G)) :|: A >= E
evalfbb8in(A, B, C, D, E, F, G) -> Com_1(evalfbb9in(A, B, C, D, E, F, G)) :|: E >= A + 1
evalfbb6in(A, B, C, D, E, F, G) -> Com_1(evalfbb4in(A, B, C, D, E, F, C)) :|: B >= F
evalfbb6in(A, B, C, D, E, F, G) -> Com_1(evalfbb7in(A, B, C, D, E, F, G)) :|: F >= B + 1
evalfbb4in(A, B, C, D, E, F, G) -> Com_1(evalfbb3in(A, B, C, D, E, F, G)) :|: E >= G
evalfbb4in(A, B, C, D, E, F, G) -> Com_1(evalfbb5in(A, B, C, D, E, F, G)) :|: G >= E + 1
evalfbb3in(A, B, C, D, E, F, G) -> Com_1(evalfbb4in(A, B, C, D, E, F, G - 1)) :|: TRUE
evalfbb5in(A, B, C, D, E, F, G) -> Com_1(evalfbb6in(A, B, C, D, E, F + 1, G)) :|: TRUE
evalfbb7in(A, B, C, D, E, F, G) -> Com_1(evalfbb8in(A, B, C, D, E + 1, F, G)) :|: TRUE
evalfbb9in(A, B, C, D, E, F, G) -> Com_1(evalfbb10in(A, B, C, D - 1, E, F, G)) :|: TRUE
evalfreturnin(A, B, C, D, E, F, G) -> Com_1(evalfstop(A, B, C, D, E, F, G)) :|: TRUE

The start-symbols are:[evalfstart_7]


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

(1) Loat Proof (FINISHED)


### Pre-processing the ITS problem ###



Initial linear ITS problem

   Start location: evalfstart

      0: evalfstart -> evalfentryin : [], cost: 1

      1: evalfentryin -> evalfbb10in : A'=B, B'=C, C'=D, D'=A, [], cost: 1

      2: evalfbb10in -> evalfbb8in : E'=1, [ D>=1 ], cost: 1

      3: evalfbb10in -> evalfreturnin : [ 0>=D ], cost: 1

      4: evalfbb8in -> evalfbb6in : F'=D, [ A>=E ], cost: 1

      5: evalfbb8in -> evalfbb9in : [ E>=1+A ], cost: 1

      6: evalfbb6in -> evalfbb4in : G'=C, [ B>=F ], cost: 1

      7: evalfbb6in -> evalfbb7in : [ F>=1+B ], cost: 1

      8: evalfbb4in -> evalfbb3in : [ E>=G ], cost: 1

      9: evalfbb4in -> evalfbb5in : [ G>=1+E ], cost: 1

     10: evalfbb3in -> evalfbb4in : G'=-1+G, [], cost: 1

     11: evalfbb5in -> evalfbb6in : F'=1+F, [], cost: 1

     12: evalfbb7in -> evalfbb8in : E'=1+E, [], cost: 1

     13: evalfbb9in -> evalfbb10in : D'=-1+D, [], cost: 1

     14: evalfreturnin -> evalfstop : [], cost: 1



Checking for constant complexity:

   The following rule is satisfiable with cost >= 1, yielding constant complexity:

      0: evalfstart -> evalfentryin : [], cost: 1



Removed unreachable and leaf rules:

   Start location: evalfstart

      0: evalfstart -> evalfentryin : [], cost: 1

      1: evalfentryin -> evalfbb10in : A'=B, B'=C, C'=D, D'=A, [], cost: 1

      2: evalfbb10in -> evalfbb8in : E'=1, [ D>=1 ], cost: 1

      4: evalfbb8in -> evalfbb6in : F'=D, [ A>=E ], cost: 1

      5: evalfbb8in -> evalfbb9in : [ E>=1+A ], cost: 1

      6: evalfbb6in -> evalfbb4in : G'=C, [ B>=F ], cost: 1

      7: evalfbb6in -> evalfbb7in : [ F>=1+B ], cost: 1

      8: evalfbb4in -> evalfbb3in : [ E>=G ], cost: 1

      9: evalfbb4in -> evalfbb5in : [ G>=1+E ], cost: 1

     10: evalfbb3in -> evalfbb4in : G'=-1+G, [], cost: 1

     11: evalfbb5in -> evalfbb6in : F'=1+F, [], cost: 1

     12: evalfbb7in -> evalfbb8in : E'=1+E, [], cost: 1

     13: evalfbb9in -> evalfbb10in : D'=-1+D, [], cost: 1



### Simplification by acceleration and chaining ###



Eliminated locations (on linear paths):

   Start location: evalfstart

     15: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=A, [], cost: 2

      2: evalfbb10in -> evalfbb8in : E'=1, [ D>=1 ], cost: 1

      4: evalfbb8in -> evalfbb6in : F'=D, [ A>=E ], cost: 1

     16: evalfbb8in -> evalfbb10in : D'=-1+D, [ E>=1+A ], cost: 2

      6: evalfbb6in -> evalfbb4in : G'=C, [ B>=F ], cost: 1

     17: evalfbb6in -> evalfbb8in : E'=1+E, [ F>=1+B ], cost: 2

     18: evalfbb4in -> evalfbb4in : G'=-1+G, [ E>=G ], cost: 2

     19: evalfbb4in -> evalfbb6in : F'=1+F, [ G>=1+E ], cost: 2



Accelerating simple loops of location 5.

   Accelerating the following rules:

     18: evalfbb4in -> evalfbb4in : G'=-1+G, [ E>=G ], cost: 2



   Accelerated rule 18 with NONTERM, yielding the new rule 20.

   Removing the simple loops: 18.



Accelerated all simple loops using metering functions (where possible):

   Start location: evalfstart

     15: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=A, [], cost: 2

      2: evalfbb10in -> evalfbb8in : E'=1, [ D>=1 ], cost: 1

      4: evalfbb8in -> evalfbb6in : F'=D, [ A>=E ], cost: 1

     16: evalfbb8in -> evalfbb10in : D'=-1+D, [ E>=1+A ], cost: 2

      6: evalfbb6in -> evalfbb4in : G'=C, [ B>=F ], cost: 1

     17: evalfbb6in -> evalfbb8in : E'=1+E, [ F>=1+B ], cost: 2

     19: evalfbb4in -> evalfbb6in : F'=1+F, [ G>=1+E ], cost: 2

     20: evalfbb4in -> [12] : [ E>=G ], cost: NONTERM



Chained accelerated rules (with incoming rules):

   Start location: evalfstart

     15: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=A, [], cost: 2

      2: evalfbb10in -> evalfbb8in : E'=1, [ D>=1 ], cost: 1

      4: evalfbb8in -> evalfbb6in : F'=D, [ A>=E ], cost: 1

     16: evalfbb8in -> evalfbb10in : D'=-1+D, [ E>=1+A ], cost: 2

      6: evalfbb6in -> evalfbb4in : G'=C, [ B>=F ], cost: 1

     17: evalfbb6in -> evalfbb8in : E'=1+E, [ F>=1+B ], cost: 2

     21: evalfbb6in -> [12] : G'=C, [ B>=F && E>=C ], cost: NONTERM

     19: evalfbb4in -> evalfbb6in : F'=1+F, [ G>=1+E ], cost: 2



Eliminated locations (on linear paths):

   Start location: evalfstart

     15: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=A, [], cost: 2

      2: evalfbb10in -> evalfbb8in : E'=1, [ D>=1 ], cost: 1

      4: evalfbb8in -> evalfbb6in : F'=D, [ A>=E ], cost: 1

     16: evalfbb8in -> evalfbb10in : D'=-1+D, [ E>=1+A ], cost: 2

     17: evalfbb6in -> evalfbb8in : E'=1+E, [ F>=1+B ], cost: 2

     21: evalfbb6in -> [12] : G'=C, [ B>=F && E>=C ], cost: NONTERM

     22: evalfbb6in -> evalfbb6in : F'=1+F, G'=C, [ B>=F && C>=1+E ], cost: 3



Accelerating simple loops of location 4.

   Accelerating the following rules:

     22: evalfbb6in -> evalfbb6in : F'=1+F, G'=C, [ B>=F && C>=1+E ], cost: 3



   Accelerated rule 22 with metering function 1-F+B, yielding the new rule 23.

   Removing the simple loops: 22.



Accelerated all simple loops using metering functions (where possible):

   Start location: evalfstart

     15: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=A, [], cost: 2

      2: evalfbb10in -> evalfbb8in : E'=1, [ D>=1 ], cost: 1

      4: evalfbb8in -> evalfbb6in : F'=D, [ A>=E ], cost: 1

     16: evalfbb8in -> evalfbb10in : D'=-1+D, [ E>=1+A ], cost: 2

     17: evalfbb6in -> evalfbb8in : E'=1+E, [ F>=1+B ], cost: 2

     21: evalfbb6in -> [12] : G'=C, [ B>=F && E>=C ], cost: NONTERM

     23: evalfbb6in -> evalfbb6in : F'=1+B, G'=C, [ B>=F && C>=1+E ], cost: 3-3*F+3*B



Chained accelerated rules (with incoming rules):

   Start location: evalfstart

     15: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=A, [], cost: 2

      2: evalfbb10in -> evalfbb8in : E'=1, [ D>=1 ], cost: 1

      4: evalfbb8in -> evalfbb6in : F'=D, [ A>=E ], cost: 1

     16: evalfbb8in -> evalfbb10in : D'=-1+D, [ E>=1+A ], cost: 2

     24: evalfbb8in -> evalfbb6in : F'=1+B, G'=C, [ A>=E && B>=D && C>=1+E ], cost: 4-3*D+3*B

     17: evalfbb6in -> evalfbb8in : E'=1+E, [ F>=1+B ], cost: 2

     21: evalfbb6in -> [12] : G'=C, [ B>=F && E>=C ], cost: NONTERM



Eliminated locations (on tree-shaped paths):

   Start location: evalfstart

     15: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=A, [], cost: 2

      2: evalfbb10in -> evalfbb8in : E'=1, [ D>=1 ], cost: 1

     16: evalfbb8in -> evalfbb10in : D'=-1+D, [ E>=1+A ], cost: 2

     25: evalfbb8in -> evalfbb8in : E'=1+E, F'=D, [ A>=E && D>=1+B ], cost: 3

     26: evalfbb8in -> [12] : F'=D, G'=C, [ A>=E && B>=D && E>=C ], cost: NONTERM

     27: evalfbb8in -> evalfbb8in : E'=1+E, F'=1+B, G'=C, [ A>=E && B>=D && C>=1+E ], cost: 6-3*D+3*B

     28: evalfbb8in -> [14] : [ A>=E && B>=D && C>=1+E ], cost: 4-3*D+3*B



Accelerating simple loops of location 3.

   Accelerating the following rules:

     25: evalfbb8in -> evalfbb8in : E'=1+E, F'=D, [ A>=E && D>=1+B ], cost: 3

     27: evalfbb8in -> evalfbb8in : E'=1+E, F'=1+B, G'=C, [ A>=E && B>=D && C>=1+E ], cost: 6-3*D+3*B



   Accelerated rule 25 with metering function 1+A-E, yielding the new rule 29.

   Found no metering function for rule 27.

   Removing the simple loops: 25.



Accelerated all simple loops using metering functions (where possible):

   Start location: evalfstart

     15: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=A, [], cost: 2

      2: evalfbb10in -> evalfbb8in : E'=1, [ D>=1 ], cost: 1

     16: evalfbb8in -> evalfbb10in : D'=-1+D, [ E>=1+A ], cost: 2

     26: evalfbb8in -> [12] : F'=D, G'=C, [ A>=E && B>=D && E>=C ], cost: NONTERM

     27: evalfbb8in -> evalfbb8in : E'=1+E, F'=1+B, G'=C, [ A>=E && B>=D && C>=1+E ], cost: 6-3*D+3*B

     28: evalfbb8in -> [14] : [ A>=E && B>=D && C>=1+E ], cost: 4-3*D+3*B

     29: evalfbb8in -> evalfbb8in : E'=1+A, F'=D, [ A>=E && D>=1+B ], cost: 3+3*A-3*E



Chained accelerated rules (with incoming rules):

   Start location: evalfstart

     15: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=A, [], cost: 2

      2: evalfbb10in -> evalfbb8in : E'=1, [ D>=1 ], cost: 1

     30: evalfbb10in -> evalfbb8in : E'=2, F'=1+B, G'=C, [ D>=1 && A>=1 && B>=D && C>=2 ], cost: 7-3*D+3*B

     31: evalfbb10in -> evalfbb8in : E'=1+A, F'=D, [ D>=1 && A>=1 && D>=1+B ], cost: 1+3*A

     16: evalfbb8in -> evalfbb10in : D'=-1+D, [ E>=1+A ], cost: 2

     26: evalfbb8in -> [12] : F'=D, G'=C, [ A>=E && B>=D && E>=C ], cost: NONTERM

     28: evalfbb8in -> [14] : [ A>=E && B>=D && C>=1+E ], cost: 4-3*D+3*B



Eliminated locations (on tree-shaped paths):

   Start location: evalfstart

     15: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=A, [], cost: 2

     32: evalfbb10in -> evalfbb10in : D'=-1+D, E'=1, [ D>=1 && 1>=1+A ], cost: 3

     33: evalfbb10in -> [12] : E'=1, F'=D, G'=C, [ D>=1 && A>=1 && B>=D && 1>=C ], cost: NONTERM

     34: evalfbb10in -> [14] : E'=1, [ D>=1 && A>=1 && B>=D && C>=2 ], cost: 5-3*D+3*B

     35: evalfbb10in -> evalfbb10in : D'=-1+D, E'=2, F'=1+B, G'=C, [ D>=1 && A>=1 && B>=D && C>=2 && 2>=1+A ], cost: 9-3*D+3*B

     36: evalfbb10in -> [12] : E'=2, F'=D, G'=C, [ D>=1 && B>=D && C>=2 && A>=2 && 2>=C ], cost: NONTERM

     37: evalfbb10in -> [14] : E'=2, F'=1+B, G'=C, [ D>=1 && B>=D && A>=2 && C>=3 ], cost: 11-6*D+6*B

     38: evalfbb10in -> evalfbb10in : D'=-1+D, E'=1+A, F'=D, [ D>=1 && A>=1 && D>=1+B ], cost: 3+3*A

     39: evalfbb10in -> [16] : [ D>=1 && A>=1 && D>=1+B ], cost: 1+3*A



Accelerating simple loops of location 2.

   Simplified some of the simple loops (and removed duplicate rules).

   Accelerating the following rules:

     32: evalfbb10in -> evalfbb10in : D'=-1+D, E'=1, [ D>=1 && 1>=1+A ], cost: 3

     35: evalfbb10in -> evalfbb10in : D'=-1+D, E'=2, F'=1+B, G'=C, [ D>=1 && 1-A==0 && B>=D && C>=2 ], cost: 9-3*D+3*B

     38: evalfbb10in -> evalfbb10in : D'=-1+D, E'=1+A, F'=D, [ D>=1 && A>=1 && D>=1+B ], cost: 3+3*A



   Accelerated rule 32 with metering function D, yielding the new rule 40.

   Accelerated rule 35 with metering function D, yielding the new rule 41.

   Found no metering function for rule 38.

   Removing the simple loops: 32 35.



Accelerated all simple loops using metering functions (where possible):

   Start location: evalfstart

     15: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=A, [], cost: 2

     33: evalfbb10in -> [12] : E'=1, F'=D, G'=C, [ D>=1 && A>=1 && B>=D && 1>=C ], cost: NONTERM

     34: evalfbb10in -> [14] : E'=1, [ D>=1 && A>=1 && B>=D && C>=2 ], cost: 5-3*D+3*B

     36: evalfbb10in -> [12] : E'=2, F'=D, G'=C, [ D>=1 && B>=D && C>=2 && A>=2 && 2>=C ], cost: NONTERM

     37: evalfbb10in -> [14] : E'=2, F'=1+B, G'=C, [ D>=1 && B>=D && A>=2 && C>=3 ], cost: 11-6*D+6*B

     38: evalfbb10in -> evalfbb10in : D'=-1+D, E'=1+A, F'=D, [ D>=1 && A>=1 && D>=1+B ], cost: 3+3*A

     39: evalfbb10in -> [16] : [ D>=1 && A>=1 && D>=1+B ], cost: 1+3*A

     40: evalfbb10in -> evalfbb10in : D'=0, E'=1, [ D>=1 && 1>=1+A ], cost: 3*D

     41: evalfbb10in -> evalfbb10in : D'=0, E'=2, F'=1+B, G'=C, [ D>=1 && 1-A==0 && B>=D && C>=2 ], cost: 15/2*D+3*D*B-3/2*D^2



Chained accelerated rules (with incoming rules):

   Start location: evalfstart

     15: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=A, [], cost: 2

     42: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=-1+A, E'=1+B, F'=A, [ A>=1 && B>=1 && A>=1+C ], cost: 5+3*B

     43: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=0, E'=1, [ A>=1 && 1>=1+B ], cost: 2+3*A

     44: evalfstart -> evalfbb10in : A'=B, B'=C, C'=D, D'=0, E'=2, F'=1+C, G'=D, [ A>=1 && 1-B==0 && C>=A && D>=2 ], cost: 2+15/2*A-3/2*A^2+3*C*A

     33: evalfbb10in -> [12] : E'=1, F'=D, G'=C, [ D>=1 && A>=1 && B>=D && 1>=C ], cost: NONTERM

     34: evalfbb10in -> [14] : E'=1, [ D>=1 && A>=1 && B>=D && C>=2 ], cost: 5-3*D+3*B

     36: evalfbb10in -> [12] : E'=2, F'=D, G'=C, [ D>=1 && B>=D && C>=2 && A>=2 && 2>=C ], cost: NONTERM

     37: evalfbb10in -> [14] : E'=2, F'=1+B, G'=C, [ D>=1 && B>=D && A>=2 && C>=3 ], cost: 11-6*D+6*B

     39: evalfbb10in -> [16] : [ D>=1 && A>=1 && D>=1+B ], cost: 1+3*A



Eliminated locations (on tree-shaped paths):

   Start location: evalfstart

     45: evalfstart -> [12] : A'=B, B'=C, C'=D, D'=A, E'=1, F'=A, G'=D, [ A>=1 && B>=1 && C>=A && 1>=D ], cost: NONTERM

     46: evalfstart -> [14] : A'=B, B'=C, C'=D, D'=A, E'=1, [ A>=1 && B>=1 && C>=A && D>=2 ], cost: 7+3*C-3*A

     47: evalfstart -> [12] : A'=B, B'=C, C'=D, D'=A, E'=2, F'=A, G'=D, [ A>=1 && C>=A && D>=2 && B>=2 && 2>=D ], cost: NONTERM

     48: evalfstart -> [14] : A'=B, B'=C, C'=D, D'=A, E'=2, F'=1+C, G'=D, [ A>=1 && C>=A && B>=2 && D>=3 ], cost: 13+6*C-6*A

     49: evalfstart -> [16] : A'=B, B'=C, C'=D, D'=A, [ A>=1 && B>=1 && A>=1+C ], cost: 3+3*B

     50: evalfstart -> [12] : A'=B, B'=C, C'=D, D'=-1+A, E'=1, F'=-1+A, G'=D, [ B>=1 && A>=1+C && -1+A>=1 && C>=-1+A && 1>=D ], cost: NONTERM

     51: evalfstart -> [14] : A'=B, B'=C, C'=D, D'=-1+A, E'=1, F'=A, [ B>=1 && A>=1+C && -1+A>=1 && C>=-1+A && D>=2 ], cost: 13+3*C-3*A+3*B

     52: evalfstart -> [12] : A'=B, B'=C, C'=D, D'=-1+A, E'=2, F'=-1+A, G'=D, [ A>=1+C && -1+A>=1 && C>=-1+A && D>=2 && B>=2 && 2>=D ], cost: NONTERM

     53: evalfstart -> [14] : A'=B, B'=C, C'=D, D'=-1+A, E'=2, F'=1+C, G'=D, [ A>=1+C && -1+A>=1 && C>=-1+A && B>=2 && D>=3 ], cost: 22+6*C-6*A+3*B

     54: evalfstart -> [16] : A'=B, B'=C, C'=D, D'=-1+A, E'=1+B, F'=A, [ B>=1 && -1+A>=1 && -1+A>=1+C ], cost: 6+6*B

     55: evalfstart -> [18] : [ A>=1 && 1>=1+B ], cost: 2+3*A

     56: evalfstart -> [18] : [ A>=1 && 1-B==0 && C>=A && D>=2 ], cost: 2+15/2*A-3/2*A^2+3*C*A



### Computing asymptotic complexity ###



Fully simplified ITS problem

   Start location: evalfstart

     45: evalfstart -> [12] : A'=B, B'=C, C'=D, D'=A, E'=1, F'=A, G'=D, [ A>=1 && B>=1 && C>=A && 1>=D ], cost: NONTERM

     46: evalfstart -> [14] : A'=B, B'=C, C'=D, D'=A, E'=1, [ A>=1 && B>=1 && C>=A && D>=2 ], cost: 7+3*C-3*A

     47: evalfstart -> [12] : A'=B, B'=C, C'=D, D'=A, E'=2, F'=A, G'=D, [ A>=1 && C>=A && D>=2 && B>=2 && 2>=D ], cost: NONTERM

     48: evalfstart -> [14] : A'=B, B'=C, C'=D, D'=A, E'=2, F'=1+C, G'=D, [ A>=1 && C>=A && B>=2 && D>=3 ], cost: 13+6*C-6*A

     49: evalfstart -> [16] : A'=B, B'=C, C'=D, D'=A, [ A>=1 && B>=1 && A>=1+C ], cost: 3+3*B

     50: evalfstart -> [12] : A'=B, B'=C, C'=D, D'=-1+A, E'=1, F'=-1+A, G'=D, [ B>=1 && A>=1+C && -1+A>=1 && C>=-1+A && 1>=D ], cost: NONTERM

     51: evalfstart -> [14] : A'=B, B'=C, C'=D, D'=-1+A, E'=1, F'=A, [ B>=1 && A>=1+C && -1+A>=1 && C>=-1+A && D>=2 ], cost: 13+3*C-3*A+3*B

     52: evalfstart -> [12] : A'=B, B'=C, C'=D, D'=-1+A, E'=2, F'=-1+A, G'=D, [ A>=1+C && -1+A>=1 && C>=-1+A && D>=2 && B>=2 && 2>=D ], cost: NONTERM

     53: evalfstart -> [14] : A'=B, B'=C, C'=D, D'=-1+A, E'=2, F'=1+C, G'=D, [ A>=1+C && -1+A>=1 && C>=-1+A && B>=2 && D>=3 ], cost: 22+6*C-6*A+3*B

     54: evalfstart -> [16] : A'=B, B'=C, C'=D, D'=-1+A, E'=1+B, F'=A, [ B>=1 && -1+A>=1 && -1+A>=1+C ], cost: 6+6*B

     55: evalfstart -> [18] : [ A>=1 && 1>=1+B ], cost: 2+3*A

     56: evalfstart -> [18] : [ A>=1 && 1-B==0 && C>=A && D>=2 ], cost: 2+15/2*A-3/2*A^2+3*C*A



Computing asymptotic complexity for rule 45

   Guard is satisfiable, yielding nontermination

   Resulting cost NONTERM has complexity: Nonterm



Found new complexity Nonterm.



Obtained the following overall complexity (w.r.t. the length of the input n):

   Complexity:  Nonterm

   Cpx degree:  Nonterm

   Solved cost: NONTERM

   Rule cost:   NONTERM

   Rule guard:  [ A>=1 && B>=1 && C>=A && 1>=D ]



NO


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

(2)
BOUNDS(INF, INF)