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


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


KILLED
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(1, INF).

(0) CpxIntTrs
(1) Loat Proof [FINISHED, 43.1 s]
(2) BOUNDS(1, INF)


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

(0)
Obligation:
Complexity Int TRS consisting of the following rules:
f0(A, B, C, D, E, F, G) -> Com_1(f1(A, B, C, D, E, F, G)) :|: A >= 0 && 3 >= A && B >= 0 && 3 >= B && 3 >= C && D >= 0 && 3 >= E && E >= 0
f1(A, B, C, D, E, F, G) -> Com_1(f2(A, B, C, D, E, D + 1, G)) :|: 1 + B >= 2 * D
f1(A, B, C, D, E, F, G) -> Com_1(f2(A, B, C, D, E, D - 1, G)) :|: 2 * D >= 4 + B
f1(A, B, C, D, E, F, G) -> Com_1(f2(A, B, C, D, E, D, G)) :|: B + 2 >= 2 * D && B + 2 <= 2 * D
f1(A, B, C, D, E, F, G) -> Com_1(f2(A, B, C, D, E, D, G)) :|: B + 3 >= 2 * D && B + 3 <= 2 * D
f2(A, B, C, D, E, F, G) -> Com_1(f3(A, B, C, D, E, F, E + 1)) :|: D + A >= 2 * E + 1
f2(A, B, C, D, E, F, G) -> Com_1(f3(A, B, C, D, E, F, E - 1)) :|: 2 * E >= 2 + D + A
f2(A, B, C, D, E, F, G) -> Com_1(f3(A, B, C, D, E, F, E)) :|: D + A >= 2 * E && D + A <= 2 * E
f2(A, B, C, D, E, F, G) -> Com_1(f3(A, B, C, D, E, F, E)) :|: D + A + 1 >= 2 * E && D + A + 1 <= 2 * E
f3(A, B, C, D, E, F, G) -> Com_1(f1(A, B, C, F, G, F, G)) :|: D >= F + 1
f3(A, B, C, D, E, F, G) -> Com_1(f1(A, B, C, F, G, F, G)) :|: F >= D + 1
f3(A, B, C, D, E, F, G) -> Com_1(f1(A, B, C, F, G, F, G)) :|: E >= G + 1
f3(A, B, C, D, E, F, G) -> Com_1(f1(A, B, C, F, G, F, G)) :|: G >= E + 1

The start-symbols are:[f0_7]


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

(1) Loat Proof (FINISHED)


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



Initial linear ITS problem

   Start location: f0

      0: f0 -> f1 : [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 ], cost: 1

      1: f1 -> f2 : F'=1+D, [ 1+B>=2*D ], cost: 1

      2: f1 -> f2 : F'=-1+D, [ 2*D>=4+B ], cost: 1

      3: f1 -> f2 : F'=D, [ 2+B==2*D ], cost: 1

      4: f1 -> f2 : F'=D, [ 3+B==2*D ], cost: 1

      5: f2 -> f3 : G'=1+E, [ D+A>=1+2*E ], cost: 1

      6: f2 -> f3 : G'=-1+E, [ 2*E>=2+D+A ], cost: 1

      7: f2 -> f3 : G'=E, [ D+A==2*E ], cost: 1

      8: f2 -> f3 : G'=E, [ 1+D+A==2*E ], cost: 1

      9: f3 -> f1 : D'=F, E'=G, [ D>=1+F ], cost: 1

     10: f3 -> f1 : D'=F, E'=G, [ F>=1+D ], cost: 1

     11: f3 -> f1 : D'=F, E'=G, [ E>=1+G ], cost: 1

     12: f3 -> f1 : D'=F, E'=G, [ G>=1+E ], cost: 1



Checking for constant complexity:

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

      0: f0 -> f1 : [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 ], cost: 1



### Simplification by acceleration and chaining ###



Eliminated locations (on tree-shaped paths):

   Start location: f0

      0: f0 -> f1 : [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 ], cost: 1

     13: f1 -> f3 : F'=1+D, G'=1+E, [ 1+B>=2*D && D+A>=1+2*E ], cost: 2

     14: f1 -> f3 : F'=1+D, G'=-1+E, [ 1+B>=2*D && 2*E>=2+D+A ], cost: 2

     15: f1 -> f3 : F'=1+D, G'=E, [ 1+B>=2*D && D+A==2*E ], cost: 2

     16: f1 -> f3 : F'=1+D, G'=E, [ 1+B>=2*D && 1+D+A==2*E ], cost: 2

     17: f1 -> f3 : F'=-1+D, G'=1+E, [ 2*D>=4+B && D+A>=1+2*E ], cost: 2

     18: f1 -> f3 : F'=-1+D, G'=-1+E, [ 2*D>=4+B && 2*E>=2+D+A ], cost: 2

     19: f1 -> f3 : F'=-1+D, G'=E, [ 2*D>=4+B && D+A==2*E ], cost: 2

     20: f1 -> f3 : F'=-1+D, G'=E, [ 2*D>=4+B && 1+D+A==2*E ], cost: 2

     21: f1 -> f3 : F'=D, G'=1+E, [ 2+B==2*D && D+A>=1+2*E ], cost: 2

     22: f1 -> f3 : F'=D, G'=-1+E, [ 2+B==2*D && 2*E>=2+D+A ], cost: 2

     23: f1 -> f3 : F'=D, G'=E, [ 2+B==2*D && D+A==2*E ], cost: 2

     24: f1 -> f3 : F'=D, G'=E, [ 2+B==2*D && 1+D+A==2*E ], cost: 2

     25: f1 -> f3 : F'=D, G'=1+E, [ 3+B==2*D && D+A>=1+2*E ], cost: 2

     26: f1 -> f3 : F'=D, G'=-1+E, [ 3+B==2*D && 2*E>=2+D+A ], cost: 2

     27: f1 -> f3 : F'=D, G'=E, [ 3+B==2*D && D+A==2*E ], cost: 2

     28: f1 -> f3 : F'=D, G'=E, [ 3+B==2*D && 1+D+A==2*E ], cost: 2

      9: f3 -> f1 : D'=F, E'=G, [ D>=1+F ], cost: 1

     10: f3 -> f1 : D'=F, E'=G, [ F>=1+D ], cost: 1

     11: f3 -> f1 : D'=F, E'=G, [ E>=1+G ], cost: 1

     12: f3 -> f1 : D'=F, E'=G, [ G>=1+E ], cost: 1



Eliminated locations (on tree-shaped paths):

   Start location: f0

      0: f0 -> f1 : [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 ], cost: 1

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

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

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

     32: f1 -> f1 : D'=1+D, E'=-1+E, F'=1+D, G'=-1+E, [ 1+B>=2*D && 2*E>=2+D+A ], cost: 3

     33: f1 -> f1 : D'=1+D, E'=E, F'=1+D, G'=E, [ 1+B>=2*D && D+A==2*E ], cost: 3

     34: f1 -> f1 : D'=1+D, E'=E, F'=1+D, G'=E, [ 1+B>=2*D && 1+D+A==2*E ], cost: 3

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

     36: f1 -> f1 : D'=-1+D, E'=1+E, F'=-1+D, G'=1+E, [ 2*D>=4+B && D+A>=1+2*E ], cost: 3

     37: f1 -> f1 : D'=-1+D, E'=-1+E, F'=-1+D, G'=-1+E, [ 2*D>=4+B && 2*E>=2+D+A ], cost: 3

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

     39: f1 -> f1 : D'=-1+D, E'=E, F'=-1+D, G'=E, [ 2*D>=4+B && D+A==2*E ], cost: 3

     40: f1 -> f1 : D'=-1+D, E'=E, F'=-1+D, G'=E, [ 2*D>=4+B && 1+D+A==2*E ], cost: 3

     41: f1 -> f1 : D'=D, E'=1+E, F'=D, G'=1+E, [ 2+B==2*D && D+A>=1+2*E ], cost: 3

     42: f1 -> f1 : D'=D, E'=-1+E, F'=D, G'=-1+E, [ 2+B==2*D && 2*E>=2+D+A ], cost: 3

     43: f1 -> f1 : D'=D, E'=1+E, F'=D, G'=1+E, [ 3+B==2*D && D+A>=1+2*E ], cost: 3

     44: f1 -> f1 : D'=D, E'=-1+E, F'=D, G'=-1+E, [ 3+B==2*D && 2*E>=2+D+A ], cost: 3



Accelerating simple loops of location 1.

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

   Accelerating the following rules:

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

     32: f1 -> f1 : D'=1+D, E'=-1+E, F'=1+D, G'=-1+E, [ 1+B>=2*D && 2*E>=2+D+A ], cost: 3

     33: f1 -> f1 : D'=1+D, F'=1+D, G'=E, [ 1+B>=2*D && D+A==2*E ], cost: 3

     34: f1 -> f1 : D'=1+D, F'=1+D, G'=E, [ 1+B>=2*D && 1+D+A==2*E ], cost: 3

     36: f1 -> f1 : D'=-1+D, E'=1+E, F'=-1+D, G'=1+E, [ 2*D>=4+B && D+A>=1+2*E ], cost: 3

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

     39: f1 -> f1 : D'=-1+D, F'=-1+D, G'=E, [ 2*D>=4+B && D+A==2*E ], cost: 3

     40: f1 -> f1 : D'=-1+D, F'=-1+D, G'=E, [ 2*D>=4+B && 1+D+A==2*E ], cost: 3

     41: f1 -> f1 : E'=1+E, F'=D, G'=1+E, [ 2+B==2*D && D+A>=1+2*E ], cost: 3

     42: f1 -> f1 : E'=-1+E, F'=D, G'=-1+E, [ 2+B==2*D && 2*E>=2+D+A ], cost: 3

     43: f1 -> f1 : E'=1+E, F'=D, G'=1+E, [ 3+B==2*D && D+A>=1+2*E ], cost: 3

     44: f1 -> f1 : E'=-1+E, F'=D, G'=-1+E, [ 3+B==2*D && 2*E>=2+D+A ], cost: 3



   Found no metering function for rule 30.

   Found no metering function for rule 32.

   Accelerated rule 33 with metering function -D-A+2*E, yielding the new rule 45.

   Accelerated rule 34 with metering function -1-D-A+2*E, yielding the new rule 46.

   Found no metering function for rule 36.

   Found no metering function for rule 38.

   Accelerated rule 39 with metering function D+A-2*E, yielding the new rule 47.

   Accelerated rule 40 with metering function 1+D+A-2*E, yielding the new rule 48.

   Accelerated rule 41 with metering function meter (where 2*meter==D+A-2*E), yielding the new rule 49.

   Accelerated rule 42 with metering function meter_1 (where 2*meter_1==-1-D-A+2*E), yielding the new rule 50.

   Accelerated rule 43 with metering function meter_2 (where 2*meter_2==D+A-2*E), yielding the new rule 51.

   Accelerated rule 44 with metering function meter_3 (where 2*meter_3==-1-D-A+2*E), yielding the new rule 52.

   Nested simple loops 30 (outer loop) and 49 (inner loop) with metering function meter_4 (where 2*meter_4==-2*D+B), resulting in the new rules: 53.

   Nested simple loops 36 (outer loop) and 49 (inner loop) with metering function meter_5 (where 2*meter_5==-4+2*D-B), resulting in the new rules: 54.

   Nested simple loops 32 (outer loop) and 50 (inner loop) with metering function meter_6 (where 2*meter_6==-2*D+B), resulting in the new rules: 55.

   Nested simple loops 38 (outer loop) and 50 (inner loop) with metering function meter_7 (where 2*meter_7==-4+2*D-B), resulting in the new rules: 56.

   Nested simple loops 30 (outer loop) and 51 (inner loop) with metering function meter_8 (where 2*meter_8==1-2*D+B), resulting in the new rules: 57.

   Nested simple loops 36 (outer loop) and 51 (inner loop) with metering function meter_9 (where 2*meter_9==-5+2*D-B), resulting in the new rules: 58.

   Nested simple loops 32 (outer loop) and 52 (inner loop) with metering function meter_10 (where 2*meter_10==1-2*D+B), resulting in the new rules: 59.

   Nested simple loops 38 (outer loop) and 52 (inner loop) with metering function meter_11 (where 2*meter_11==-5+2*D-B), resulting in the new rules: 60.

   Removing the simple loops: 30 32 33 34 36 38 39 40 41 42 43 44.



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

   Start location: f0

      0: f0 -> f1 : [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 ], cost: 1

     45: f1 -> f1 : D'=-A+2*E, F'=-A+2*E, G'=E, [ 1+B>=2*D && D+A==2*E && -D-A+2*E>=1 ], cost: -3*D-3*A+6*E

     46: f1 -> f1 : D'=-1-A+2*E, F'=-1-A+2*E, G'=E, [ 1+B>=2*D && 1+D+A==2*E && -1-D-A+2*E>=1 ], cost: -3-3*D-3*A+6*E

     47: f1 -> f1 : D'=-A+2*E, F'=-A+2*E, G'=E, [ 2*D>=4+B && D+A==2*E && D+A-2*E>=1 ], cost: 3*D+3*A-6*E

     48: f1 -> f1 : D'=-1-A+2*E, F'=-1-A+2*E, G'=E, [ 2*D>=4+B && 1+D+A==2*E && 1+D+A-2*E>=1 ], cost: 3+3*D+3*A-6*E

     49: f1 -> f1 : E'=meter+E, F'=D, G'=meter+E, [ 2+B==2*D && D+A>=1+2*E && 2*meter==D+A-2*E && meter>=1 ], cost: 3*meter

     50: f1 -> f1 : E'=E-meter_1, F'=D, G'=E-meter_1, [ 2+B==2*D && 2*E>=2+D+A && 2*meter_1==-1-D-A+2*E && meter_1>=1 ], cost: 3*meter_1

     51: f1 -> f1 : E'=meter_2+E, F'=D, G'=meter_2+E, [ 3+B==2*D && D+A>=1+2*E && 2*meter_2==D+A-2*E && meter_2>=1 ], cost: 3*meter_2

     52: f1 -> f1 : E'=-meter_3+E, F'=D, G'=-meter_3+E, [ 3+B==2*D && 2*E>=2+D+A && 2*meter_3==-1-D-A+2*E && meter_3>=1 ], cost: 3*meter_3

     53: f1 -> f1 : D'=D+meter_4, E'=meter_4+meter_4*meter+E, F'=D+meter_4, G'=meter_4+meter_4*meter+E, [ 2+B==2+2*D && 1+D+A>=3+2*E && 2*meter==-1+D+A-2*E && meter>=1 && 2*meter_4==-2*D+B && meter_4>=1 ], cost: 3*meter_4+3*meter_4*meter

     54: f1 -> f1 : D'=D-meter_5, E'=meter*meter_5+E+meter_5, F'=D-meter_5, G'=meter*meter_5+E+meter_5, [ 2+B==-2+2*D && -1+D+A>=3+2*E && 2*meter==-3+D+A-2*E && meter>=1 && 2*meter_5==-4+2*D-B && meter_5>=1 ], cost: 3*meter*meter_5+3*meter_5

     55: f1 -> f1 : D'=meter_6+D, E'=-meter_6+E-meter_6*meter_1, F'=meter_6+D, G'=-meter_6+E-meter_6*meter_1, [ 2+B==2+2*D && -2+2*E>=3+D+A && 2*meter_1==-4-D-A+2*E && meter_1>=1 && 2*meter_6==-2*D+B && meter_6>=1 ], cost: 3*meter_6+3*meter_6*meter_1

     56: f1 -> f1 : D'=D-meter_7, E'=-meter_7+E-meter_7*meter_1, F'=D-meter_7, G'=-meter_7+E-meter_7*meter_1, [ 2+B==-2+2*D && -2+2*E>=1+D+A && 2*meter_1==-2-D-A+2*E && meter_1>=1 && 2*meter_7==-4+2*D-B && meter_7>=1 ], cost: 3*meter_7+3*meter_7*meter_1

     57: f1 -> f1 : D'=meter_8+D, E'=meter_8*meter_2+meter_8+E, F'=meter_8+D, G'=meter_8*meter_2+meter_8+E, [ 3+B==2+2*D && 1+D+A>=3+2*E && 2*meter_2==-1+D+A-2*E && meter_2>=1 && 2*meter_8==1-2*D+B && meter_8>=1 ], cost: 3*meter_8*meter_2+3*meter_8

     58: f1 -> f1 : D'=D-meter_9, E'=meter_9+E+meter_2*meter_9, F'=D-meter_9, G'=meter_9+E+meter_2*meter_9, [ 3+B==-2+2*D && -1+D+A>=3+2*E && 2*meter_2==-3+D+A-2*E && meter_2>=1 && 2*meter_9==-5+2*D-B && meter_9>=1 ], cost: 3*meter_9+3*meter_2*meter_9

     59: f1 -> f1 : D'=meter_10+D, E'=-meter_10+E-meter_10*meter_3, F'=meter_10+D, G'=-meter_10+E-meter_10*meter_3, [ 3+B==2+2*D && -2+2*E>=3+D+A && 2*meter_3==-4-D-A+2*E && meter_3>=1 && 2*meter_10==1-2*D+B && meter_10>=1 ], cost: 3*meter_10+3*meter_10*meter_3

     60: f1 -> f1 : D'=D-meter_11, E'=-meter_11*meter_3-meter_11+E, F'=D-meter_11, G'=-meter_11*meter_3-meter_11+E, [ 3+B==-2+2*D && -2+2*E>=1+D+A && 2*meter_3==-2-D-A+2*E && meter_3>=1 && 2*meter_11==-5+2*D-B && meter_11>=1 ], cost: 3*meter_11*meter_3+3*meter_11



Chained accelerated rules (with incoming rules):

   Start location: f0

      0: f0 -> f1 : [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 ], cost: 1

     61: f0 -> f1 : E'=meter+E, F'=D, G'=meter+E, [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 2+B==2*D && D+A>=1+2*E && 2*meter==D+A-2*E && meter>=1 ], cost: 1+3*meter

     62: f0 -> f1 : E'=E-meter_1, F'=D, G'=E-meter_1, [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 2+B==2*D && 2*E>=2+D+A && 2*meter_1==-1-D-A+2*E && meter_1>=1 ], cost: 1+3*meter_1

     63: f0 -> f1 : E'=meter_2+E, F'=D, G'=meter_2+E, [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 3+B==2*D && D+A>=1+2*E && 2*meter_2==D+A-2*E && meter_2>=1 ], cost: 1+3*meter_2

     64: f0 -> f1 : E'=-meter_3+E, F'=D, G'=-meter_3+E, [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 3+B==2*D && 2*E>=2+D+A && 2*meter_3==-1-D-A+2*E && meter_3>=1 ], cost: 1+3*meter_3



Removed unreachable locations (and leaf rules with constant cost):

   Start location: f0

     61: f0 -> f1 : E'=meter+E, F'=D, G'=meter+E, [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 2+B==2*D && D+A>=1+2*E && 2*meter==D+A-2*E && meter>=1 ], cost: 1+3*meter

     62: f0 -> f1 : E'=E-meter_1, F'=D, G'=E-meter_1, [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 2+B==2*D && 2*E>=2+D+A && 2*meter_1==-1-D-A+2*E && meter_1>=1 ], cost: 1+3*meter_1

     63: f0 -> f1 : E'=meter_2+E, F'=D, G'=meter_2+E, [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 3+B==2*D && D+A>=1+2*E && 2*meter_2==D+A-2*E && meter_2>=1 ], cost: 1+3*meter_2

     64: f0 -> f1 : E'=-meter_3+E, F'=D, G'=-meter_3+E, [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 3+B==2*D && 2*E>=2+D+A && 2*meter_3==-1-D-A+2*E && meter_3>=1 ], cost: 1+3*meter_3



### Computing asymptotic complexity ###



Fully simplified ITS problem

   Start location: f0

     61: f0 -> f1 : E'=meter+E, F'=D, G'=meter+E, [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 2+B==2*D && D+A>=1+2*E && 2*meter==D+A-2*E && meter>=1 ], cost: 1+3*meter

     62: f0 -> f1 : E'=E-meter_1, F'=D, G'=E-meter_1, [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 2+B==2*D && 2*E>=2+D+A && 2*meter_1==-1-D-A+2*E && meter_1>=1 ], cost: 1+3*meter_1

     63: f0 -> f1 : E'=meter_2+E, F'=D, G'=meter_2+E, [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 3+B==2*D && D+A>=1+2*E && 2*meter_2==D+A-2*E && meter_2>=1 ], cost: 1+3*meter_2

     64: f0 -> f1 : E'=-meter_3+E, F'=D, G'=-meter_3+E, [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 3+B==2*D && 2*E>=2+D+A && 2*meter_3==-1-D-A+2*E && meter_3>=1 ], cost: 1+3*meter_3



Computing asymptotic complexity for rule 61

   Simplified the guard:

     61: f0 -> f1 : E'=meter+E, F'=D, G'=meter+E, [ 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 2+B==2*D && D+A>=1+2*E && 2*meter==D+A-2*E ], cost: 1+3*meter

   Could not solve the limit problem.

   Resulting cost 0 has complexity: Unknown



Computing asymptotic complexity for rule 62

   Simplified the guard:

     62: f0 -> f1 : E'=E-meter_1, F'=D, G'=E-meter_1, [ A>=0 && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 2+B==2*D && 2*E>=2+D+A && 2*meter_1==-1-D-A+2*E ], cost: 1+3*meter_1

   Could not solve the limit problem.

   Resulting cost 0 has complexity: Unknown



Computing asymptotic complexity for rule 63

   Could not solve the limit problem.

   Resulting cost 0 has complexity: Unknown



Computing asymptotic complexity for rule 64

   Simplified the guard:

     64: f0 -> f1 : E'=-meter_3+E, F'=D, G'=-meter_3+E, [ A>=0 && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 && 3+B==2*D && 2*E>=2+D+A && 2*meter_3==-1-D-A+2*E ], cost: 1+3*meter_3

   Could not solve the limit problem.

   Resulting cost 0 has complexity: Unknown



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

   Complexity:  Constant

   Cpx degree:  0

   Solved cost: 1

   Rule cost:   1

   Rule guard:  [ A>=0 && 3>=A && B>=0 && 3>=B && 3>=C && D>=0 && 3>=E && E>=0 ]



WORST_CASE(Omega(1),?)


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

(2)
BOUNDS(1, INF)