WORST_CASE(Omega(1),?)

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

Initial linear ITS problem
   Start location: __init
      0: f1 -> f2 : arg1'=arg1P_1, arg2'=arg2P_1, [ arg2==arg2P_1 ], cost: 1
      1: f2 -> f3 : arg1'=arg1P_2, arg2'=arg2P_2, [ arg1==arg1P_2 ], cost: 1
     20: f3 -> f4 : arg1'=arg1P_21, arg2'=arg2P_21, [ arg1>=2 && arg1==arg1P_21 && arg2==arg2P_21 ], cost: 1
     22: f3 -> f17 : arg1'=arg1P_23, arg2'=arg2P_23, [ arg1<2 && arg1==arg1P_23 && arg2==arg2P_23 ], cost: 1
      2: f4 -> f5 : arg1'=arg1P_3, arg2'=arg2P_3, [ arg1P_3==-1+arg1 && arg2==arg2P_3 ], cost: 1
      3: f5 -> f6 : arg1'=arg1P_4, arg2'=arg2P_4, [ arg2P_4==arg2+arg1 && arg1==arg1P_4 ], cost: 1
     13: f6 -> f7 : arg1'=arg1P_14, arg2'=arg2P_14, [ arg2>=1+arg1 && x26_1<0 && arg1==arg1P_14 && arg2==arg2P_14 ], cost: 1
     14: f6 -> f7 : arg1'=arg1P_15, arg2'=arg2P_15, [ arg2>=1+arg1 && x65_1>0 && arg1==arg1P_15 && arg2==arg2P_15 ], cost: 1
     16: f6 -> f14 : arg1'=arg1P_17, arg2'=arg2P_17, [ arg2<1+arg1 && arg1==arg1P_17 && arg2==arg2P_17 ], cost: 1
     17: f6 -> f14 : arg1'=arg1P_18, arg2'=arg2P_18, [ x68_1==0 && arg1==arg1P_18 && arg2==arg2P_18 ], cost: 1
      4: f7 -> f8 : arg1'=arg1P_5, arg2'=arg2P_5, [ arg2P_5==-1+arg2 && arg1==arg1P_5 ], cost: 1
      7: f8 -> f9 : arg1'=arg1P_8, arg2'=arg2P_8, [ arg2>=3+arg1 && x16_1<0 && arg1==arg1P_8 && arg2==arg2P_8 ], cost: 1
      8: f8 -> f9 : arg1'=arg1P_9, arg2'=arg2P_9, [ arg2>=3+arg1 && x56_1>0 && arg1==arg1P_9 && arg2==arg2P_9 ], cost: 1
     10: f8 -> f12 : arg1'=arg1P_11, arg2'=arg2P_11, [ arg2<3+arg1 && arg1==arg1P_11 && arg2==arg2P_11 ], cost: 1
     11: f8 -> f12 : arg1'=arg1P_12, arg2'=arg2P_12, [ x59_1==0 && arg1==arg1P_12 && arg2==arg2P_12 ], cost: 1
      5: f9 -> f10 : arg1'=arg1P_6, arg2'=arg2P_6, [ arg1P_6==1+arg1 && arg2==arg2P_6 ], cost: 1
      6: f10 -> f11 : arg1'=arg1P_7, arg2'=arg2P_7, [ arg2P_7==-2+arg2 && arg1==arg1P_7 ], cost: 1
      9: f11 -> f8 : arg1'=arg1P_10, arg2'=arg2P_10, [ arg1==arg1P_10 && arg2==arg2P_10 ], cost: 1
     12: f12 -> f13 : arg1'=arg1P_13, arg2'=arg2P_13, [ arg2P_13==-1+arg2 && arg1==arg1P_13 ], cost: 1
     15: f13 -> f6 : arg1'=arg1P_16, arg2'=arg2P_16, [ arg1==arg1P_16 && arg2==arg2P_16 ], cost: 1
     18: f14 -> f15 : arg1'=arg1P_19, arg2'=arg2P_19, [ arg1P_19==-1+arg1 && arg2==arg2P_19 ], cost: 1
     19: f15 -> f16 : arg1'=arg1P_20, arg2'=arg2P_20, [ arg2P_20==arg2-arg1 && arg1==arg1P_20 ], cost: 1
     21: f16 -> f3 : arg1'=arg1P_22, arg2'=arg2P_22, [ arg1==arg1P_22 && arg2==arg2P_22 ], cost: 1
     23: __init -> f1 : arg1'=arg1P_24, arg2'=arg2P_24, [], cost: 1

Checking for constant complexity:
   The following rule is satisfiable with cost >= 1, yielding constant complexity:
     23: __init -> f1 : arg1'=arg1P_24, arg2'=arg2P_24, [], cost: 1

Removed unreachable and leaf rules:
   Start location: __init
      0: f1 -> f2 : arg1'=arg1P_1, arg2'=arg2P_1, [ arg2==arg2P_1 ], cost: 1
      1: f2 -> f3 : arg1'=arg1P_2, arg2'=arg2P_2, [ arg1==arg1P_2 ], cost: 1
     20: f3 -> f4 : arg1'=arg1P_21, arg2'=arg2P_21, [ arg1>=2 && arg1==arg1P_21 && arg2==arg2P_21 ], cost: 1
      2: f4 -> f5 : arg1'=arg1P_3, arg2'=arg2P_3, [ arg1P_3==-1+arg1 && arg2==arg2P_3 ], cost: 1
      3: f5 -> f6 : arg1'=arg1P_4, arg2'=arg2P_4, [ arg2P_4==arg2+arg1 && arg1==arg1P_4 ], cost: 1
     13: f6 -> f7 : arg1'=arg1P_14, arg2'=arg2P_14, [ arg2>=1+arg1 && x26_1<0 && arg1==arg1P_14 && arg2==arg2P_14 ], cost: 1
     14: f6 -> f7 : arg1'=arg1P_15, arg2'=arg2P_15, [ arg2>=1+arg1 && x65_1>0 && arg1==arg1P_15 && arg2==arg2P_15 ], cost: 1
     16: f6 -> f14 : arg1'=arg1P_17, arg2'=arg2P_17, [ arg2<1+arg1 && arg1==arg1P_17 && arg2==arg2P_17 ], cost: 1
     17: f6 -> f14 : arg1'=arg1P_18, arg2'=arg2P_18, [ x68_1==0 && arg1==arg1P_18 && arg2==arg2P_18 ], cost: 1
      4: f7 -> f8 : arg1'=arg1P_5, arg2'=arg2P_5, [ arg2P_5==-1+arg2 && arg1==arg1P_5 ], cost: 1
      7: f8 -> f9 : arg1'=arg1P_8, arg2'=arg2P_8, [ arg2>=3+arg1 && x16_1<0 && arg1==arg1P_8 && arg2==arg2P_8 ], cost: 1
      8: f8 -> f9 : arg1'=arg1P_9, arg2'=arg2P_9, [ arg2>=3+arg1 && x56_1>0 && arg1==arg1P_9 && arg2==arg2P_9 ], cost: 1
     10: f8 -> f12 : arg1'=arg1P_11, arg2'=arg2P_11, [ arg2<3+arg1 && arg1==arg1P_11 && arg2==arg2P_11 ], cost: 1
     11: f8 -> f12 : arg1'=arg1P_12, arg2'=arg2P_12, [ x59_1==0 && arg1==arg1P_12 && arg2==arg2P_12 ], cost: 1
      5: f9 -> f10 : arg1'=arg1P_6, arg2'=arg2P_6, [ arg1P_6==1+arg1 && arg2==arg2P_6 ], cost: 1
      6: f10 -> f11 : arg1'=arg1P_7, arg2'=arg2P_7, [ arg2P_7==-2+arg2 && arg1==arg1P_7 ], cost: 1
      9: f11 -> f8 : arg1'=arg1P_10, arg2'=arg2P_10, [ arg1==arg1P_10 && arg2==arg2P_10 ], cost: 1
     12: f12 -> f13 : arg1'=arg1P_13, arg2'=arg2P_13, [ arg2P_13==-1+arg2 && arg1==arg1P_13 ], cost: 1
     15: f13 -> f6 : arg1'=arg1P_16, arg2'=arg2P_16, [ arg1==arg1P_16 && arg2==arg2P_16 ], cost: 1
     18: f14 -> f15 : arg1'=arg1P_19, arg2'=arg2P_19, [ arg1P_19==-1+arg1 && arg2==arg2P_19 ], cost: 1
     19: f15 -> f16 : arg1'=arg1P_20, arg2'=arg2P_20, [ arg2P_20==arg2-arg1 && arg1==arg1P_20 ], cost: 1
     21: f16 -> f3 : arg1'=arg1P_22, arg2'=arg2P_22, [ arg1==arg1P_22 && arg2==arg2P_22 ], cost: 1
     23: __init -> f1 : arg1'=arg1P_24, arg2'=arg2P_24, [], cost: 1

Simplified all rules, resulting in:
   Start location: __init
      0: f1 -> f2 : arg1'=arg1P_1, [], cost: 1
      1: f2 -> f3 : arg2'=arg2P_2, [], cost: 1
     20: f3 -> f4 : [ arg1>=2 ], cost: 1
      2: f4 -> f5 : arg1'=-1+arg1, [], cost: 1
      3: f5 -> f6 : arg2'=arg2+arg1, [], cost: 1
     14: f6 -> f7 : [ arg2>=1+arg1 ], cost: 1
     16: f6 -> f14 : [ arg2<1+arg1 ], cost: 1
     17: f6 -> f14 : [], cost: 1
      4: f7 -> f8 : arg2'=-1+arg2, [], cost: 1
      8: f8 -> f9 : [ arg2>=3+arg1 ], cost: 1
     10: f8 -> f12 : [ arg2<3+arg1 ], cost: 1
     11: f8 -> f12 : [], cost: 1
      5: f9 -> f10 : arg1'=1+arg1, [], cost: 1
      6: f10 -> f11 : arg2'=-2+arg2, [], cost: 1
      9: f11 -> f8 : [], cost: 1
     12: f12 -> f13 : arg2'=-1+arg2, [], cost: 1
     15: f13 -> f6 : [], cost: 1
     18: f14 -> f15 : arg1'=-1+arg1, [], cost: 1
     19: f15 -> f16 : arg2'=arg2-arg1, [], cost: 1
     21: f16 -> f3 : [], cost: 1
     23: __init -> f1 : arg1'=arg1P_24, arg2'=arg2P_24, [], cost: 1

### Simplification by acceleration and chaining ###

Eliminated locations (on linear paths):
   Start location: __init
     27: f3 -> f6 : arg1'=-1+arg1, arg2'=-1+arg2+arg1, [ arg1>=2 ], cost: 3
     16: f6 -> f14 : [ arg2<1+arg1 ], cost: 1
     17: f6 -> f14 : [], cost: 1
     28: f6 -> f8 : arg2'=-1+arg2, [ arg2>=1+arg1 ], cost: 2
     10: f8 -> f12 : [ arg2<3+arg1 ], cost: 1
     11: f8 -> f12 : [], cost: 1
     31: f8 -> f8 : arg1'=1+arg1, arg2'=-2+arg2, [ arg2>=3+arg1 ], cost: 4
     32: f12 -> f6 : arg2'=-1+arg2, [], cost: 2
     34: f14 -> f3 : arg1'=-1+arg1, arg2'=1+arg2-arg1, [], cost: 3
     25: __init -> f3 : arg1'=arg1P_1, arg2'=arg2P_2, [], cost: 3

Accelerating simple loops of location 7.
   Accelerating the following rules:
     31: f8 -> f8 : arg1'=1+arg1, arg2'=-2+arg2, [ arg2>=3+arg1 ], cost: 4

   Accelerated rule 31 with backward acceleration, yielding the new rule 35.
[accelerate] Nesting with 1 inner and 1 outer candidates
   Removing the simple loops: 31.

Accelerated all simple loops using metering functions (where possible):
   Start location: __init
     27: f3 -> f6 : arg1'=-1+arg1, arg2'=-1+arg2+arg1, [ arg1>=2 ], cost: 3
     16: f6 -> f14 : [ arg2<1+arg1 ], cost: 1
     17: f6 -> f14 : [], cost: 1
     28: f6 -> f8 : arg2'=-1+arg2, [ arg2>=1+arg1 ], cost: 2
     10: f8 -> f12 : [ arg2<3+arg1 ], cost: 1
     11: f8 -> f12 : [], cost: 1
     35: f8 -> f8 : arg1'=k+arg1, arg2'=-2*k+arg2, [ k>=0 && 2-2*k+arg2>=2+k+arg1 ], cost: 4*k
     32: f12 -> f6 : arg2'=-1+arg2, [], cost: 2
     34: f14 -> f3 : arg1'=-1+arg1, arg2'=1+arg2-arg1, [], cost: 3
     25: __init -> f3 : arg1'=arg1P_1, arg2'=arg2P_2, [], cost: 3

Chained accelerated rules (with incoming rules):
   Start location: __init
     27: f3 -> f6 : arg1'=-1+arg1, arg2'=-1+arg2+arg1, [ arg1>=2 ], cost: 3
     16: f6 -> f14 : [ arg2<1+arg1 ], cost: 1
     17: f6 -> f14 : [], cost: 1
     28: f6 -> f8 : arg2'=-1+arg2, [ arg2>=1+arg1 ], cost: 2
     36: f6 -> f8 : arg1'=k+arg1, arg2'=-1-2*k+arg2, [ arg2>=1+arg1 && k>=0 && 1-2*k+arg2>=2+k+arg1 ], cost: 2+4*k
     10: f8 -> f12 : [ arg2<3+arg1 ], cost: 1
     11: f8 -> f12 : [], cost: 1
     32: f12 -> f6 : arg2'=-1+arg2, [], cost: 2
     34: f14 -> f3 : arg1'=-1+arg1, arg2'=1+arg2-arg1, [], cost: 3
     25: __init -> f3 : arg1'=arg1P_1, arg2'=arg2P_2, [], cost: 3

Eliminated locations (on tree-shaped paths):
   Start location: __init
     27: f3 -> f6 : arg1'=-1+arg1, arg2'=-1+arg2+arg1, [ arg1>=2 ], cost: 3
     37: f6 -> f12 : arg2'=-1+arg2, [ arg2>=1+arg1 && -1+arg2<3+arg1 ], cost: 3
     38: f6 -> f12 : arg2'=-1+arg2, [ arg2>=1+arg1 ], cost: 3
     39: f6 -> f12 : arg1'=k+arg1, arg2'=-1-2*k+arg2, [ arg2>=1+arg1 && k>=0 && 1-2*k+arg2>=2+k+arg1 && -1-2*k+arg2<3+k+arg1 ], cost: 3+4*k
     40: f6 -> f12 : arg1'=k+arg1, arg2'=-1-2*k+arg2, [ arg2>=1+arg1 && k>=0 && 1-2*k+arg2>=2+k+arg1 ], cost: 3+4*k
     41: f6 -> f3 : arg1'=-1+arg1, arg2'=1+arg2-arg1, [ arg2<1+arg1 ], cost: 4
     42: f6 -> f3 : arg1'=-1+arg1, arg2'=1+arg2-arg1, [], cost: 4
     32: f12 -> f6 : arg2'=-1+arg2, [], cost: 2
     25: __init -> f3 : arg1'=arg1P_1, arg2'=arg2P_2, [], cost: 3

Merged rules:
   Start location: __init
     27: f3 -> f6 : arg1'=-1+arg1, arg2'=-1+arg2+arg1, [ arg1>=2 ], cost: 3
     43: f6 -> f12 : arg2'=-1+arg2, [ arg2>=1+arg1 ], cost: 3
     44: f6 -> f12 : arg1'=k+arg1, arg2'=-1-2*k+arg2, [ arg2>=1+arg1 && k>=0 && 1-2*k+arg2>=2+k+arg1 ], cost: 3+4*k
     45: f6 -> f3 : arg1'=-1+arg1, arg2'=1+arg2-arg1, [], cost: 4
     32: f12 -> f6 : arg2'=-1+arg2, [], cost: 2
     25: __init -> f3 : arg1'=arg1P_1, arg2'=arg2P_2, [], cost: 3

Eliminated locations (on tree-shaped paths):
   Start location: __init
     27: f3 -> f6 : arg1'=-1+arg1, arg2'=-1+arg2+arg1, [ arg1>=2 ], cost: 3
     45: f6 -> f3 : arg1'=-1+arg1, arg2'=1+arg2-arg1, [], cost: 4
     46: f6 -> f6 : arg2'=-2+arg2, [ arg2>=1+arg1 ], cost: 5
     47: f6 -> f6 : arg1'=k+arg1, arg2'=-2-2*k+arg2, [ arg2>=1+arg1 && k>=0 && 1-2*k+arg2>=2+k+arg1 ], cost: 5+4*k
     25: __init -> f3 : arg1'=arg1P_1, arg2'=arg2P_2, [], cost: 3

Accelerating simple loops of location 5.
   Accelerating the following rules:
     46: f6 -> f6 : arg2'=-2+arg2, [ arg2>=1+arg1 ], cost: 5
     47: f6 -> f6 : arg1'=k+arg1, arg2'=-2-2*k+arg2, [ arg2>=1+arg1 && k>=0 && 1-2*k+arg2>=2+k+arg1 ], cost: 5+4*k

   Accelerated rule 46 with backward acceleration, yielding the new rule 48.
   Accelerated rule 47 with backward acceleration, yielding the new rule 49.
[accelerate] Nesting with 2 inner and 2 outer candidates
   Removing the simple loops: 46 47.

Accelerated all simple loops using metering functions (where possible):
   Start location: __init
     27: f3 -> f6 : arg1'=-1+arg1, arg2'=-1+arg2+arg1, [ arg1>=2 ], cost: 3
     45: f6 -> f3 : arg1'=-1+arg1, arg2'=1+arg2-arg1, [], cost: 4
     48: f6 -> f6 : arg2'=-2*k_1+arg2, [ k_1>=0 && 2-2*k_1+arg2>=1+arg1 ], cost: 5*k_1
     49: f6 -> f6 : arg1'=k*k_2+arg1, arg2'=arg2-2*k_2-2*k*k_2, [ k>=0 && k_2>=0 && 2-2*k*(-1+k_2)+arg2-2*k_2>=1+k*(-1+k_2)+arg1 && 3-2*k*(-1+k_2)-2*k+arg2-2*k_2>=2+k*(-1+k_2)+k+arg1 ], cost: 5*k_2+4*k*k_2
     25: __init -> f3 : arg1'=arg1P_1, arg2'=arg2P_2, [], cost: 3

Chained accelerated rules (with incoming rules):
   Start location: __init
     27: f3 -> f6 : arg1'=-1+arg1, arg2'=-1+arg2+arg1, [ arg1>=2 ], cost: 3
     50: f3 -> f6 : arg1'=-1+arg1, arg2'=-1-2*k_1+arg2+arg1, [ arg1>=2 && k_1>=0 && 1-2*k_1+arg2+arg1>=arg1 ], cost: 3+5*k_1
     51: f3 -> f6 : arg1'=-1+k*k_2+arg1, arg2'=-1+arg2-2*k_2-2*k*k_2+arg1, [ arg1>=2 && k>=0 && k_2>=0 && 1-2*k*(-1+k_2)+arg2-2*k_2+arg1>=k*(-1+k_2)+arg1 && 2-2*k*(-1+k_2)-2*k+arg2-2*k_2+arg1>=1+k*(-1+k_2)+k+arg1 ], cost: 3+5*k_2+4*k*k_2
     45: f6 -> f3 : arg1'=-1+arg1, arg2'=1+arg2-arg1, [], cost: 4
     25: __init -> f3 : arg1'=arg1P_1, arg2'=arg2P_2, [], cost: 3

Eliminated locations (on tree-shaped paths):
   Start location: __init
     52: f3 -> f3 : arg1'=-2+arg1, arg2'=1+arg2, [ arg1>=2 ], cost: 7
     53: f3 -> f3 : arg1'=-2+arg1, arg2'=1-2*k_1+arg2, [ arg1>=2 && k_1>=0 && 1-2*k_1+arg2+arg1>=arg1 ], cost: 7+5*k_1
     54: f3 -> f3 : arg1'=-2+k*k_2+arg1, arg2'=1+arg2-2*k_2-3*k*k_2, [ arg1>=2 && k>=0 && k_2>=0 && 1-2*k*(-1+k_2)+arg2-2*k_2+arg1>=k*(-1+k_2)+arg1 && 2-2*k*(-1+k_2)-2*k+arg2-2*k_2+arg1>=1+k*(-1+k_2)+k+arg1 ], cost: 7+5*k_2+4*k*k_2
     25: __init -> f3 : arg1'=arg1P_1, arg2'=arg2P_2, [], cost: 3

Accelerating simple loops of location 2.
   Accelerating the following rules:
     52: f3 -> f3 : arg1'=-2+arg1, arg2'=1+arg2, [ arg1>=2 ], cost: 7
     53: f3 -> f3 : arg1'=-2+arg1, arg2'=1-2*k_1+arg2, [ arg1>=2 && k_1>=0 && 1-2*k_1+arg2+arg1>=arg1 ], cost: 7+5*k_1
     54: f3 -> f3 : arg1'=-2+k*k_2+arg1, arg2'=1+arg2-2*k_2-3*k*k_2, [ arg1>=2 && k>=0 && k_2>=0 && 1-2*k*(-1+k_2)+arg2-2*k_2+arg1>=k*(-1+k_2)+arg1 && 2-2*k*(-1+k_2)-2*k+arg2-2*k_2+arg1>=1+k*(-1+k_2)+k+arg1 ], cost: 7+5*k_2+4*k*k_2

   Accelerated rule 52 with backward acceleration, yielding the new rule 55.
[test] deduced pseudo-invariant -2-3*k_1+3*arg2+2*arg1<=0, also trying 2+3*k_1-3*arg2-2*arg1<=-1
[test] deduced pseudo-invariant 15*k_1<=0, also trying -15*k_1<=-1
   Accelerated rule 53 with backward acceleration, yielding the new rule 56.
   Accelerated rule 53 with backward acceleration, yielding the new rule 57.
   Accelerated rule 53 with backward acceleration, yielding the new rule 58.
   Failed to prove monotonicity of the guard of rule 54.
[accelerate] Nesting with 5 inner and 3 outer candidates
   Removing the simple loops: 52.

Accelerated all simple loops using metering functions (where possible):
   Start location: __init
     53: f3 -> f3 : arg1'=-2+arg1, arg2'=1-2*k_1+arg2, [ arg1>=2 && k_1>=0 && 1-2*k_1+arg2+arg1>=arg1 ], cost: 7+5*k_1
     54: f3 -> f3 : arg1'=-2+k*k_2+arg1, arg2'=1+arg2-2*k_2-3*k*k_2, [ arg1>=2 && k>=0 && k_2>=0 && 1-2*k*(-1+k_2)+arg2-2*k_2+arg1>=k*(-1+k_2)+arg1 && 2-2*k*(-1+k_2)-2*k+arg2-2*k_2+arg1>=1+k*(-1+k_2)+k+arg1 ], cost: 7+5*k_2+4*k*k_2
     55: f3 -> f3 : arg1'=-2*k_7+arg1, arg2'=arg2+k_7, [ k_7>=0 && 2-2*k_7+arg1>=2 ], cost: 7*k_7
     56: f3 -> f3 : arg1'=-2*k_9+arg1, arg2'=arg2+k_9-2*k_1*k_9, [ k_1>=0 && 1-2*k_1+arg2+arg1>=arg1 && -2-3*k_1+3*arg2+2*arg1<=0 && k_9>=0 && 2-2*k_9+arg1>=2 ], cost: 7*k_9+5*k_1*k_9
     57: f3 -> f3 : arg1'=-2*k_10+arg1, arg2'=k_10+arg2-2*k_10*k_1, [ k_1>=0 && 1-2*k_1+arg2+arg1>=arg1 && 15*k_1<=0 && k_10>=0 && 2-2*k_10+arg1>=2 && 1+k_10+3*k_1-3*arg2+6*k_1*(-1+k_10)-2*arg1<=-1 ], cost: 7*k_10+5*k_10*k_1
     58: f3 -> f3 : arg1'=-2*k_11+arg1, arg2'=arg2+k_11-2*k_1*k_11, [ k_1>=0 && -15*k_1<=-1 && k_11>=0 && 2-2*k_11+arg1>=2 && 2-2*k_1+arg2-k_11-2*k_1*(-1+k_11)+arg1>=2-2*k_11+arg1 && 1+3*k_1-3*arg2+k_11+6*k_1*(-1+k_11)-2*arg1<=-1 ], cost: 7*k_11+5*k_1*k_11
     25: __init -> f3 : arg1'=arg1P_1, arg2'=arg2P_2, [], cost: 3

Chained accelerated rules (with incoming rules):
   Start location: __init
     25: __init -> f3 : arg1'=arg1P_1, arg2'=arg2P_2, [], cost: 3
     59: __init -> f3 : arg1'=-2+arg1P_1, arg2'=1+arg2P_2-2*k_1, [ arg1P_1>=2 && k_1>=0 && 1+arg2P_2+arg1P_1-2*k_1>=arg1P_1 ], cost: 10+5*k_1
     60: __init -> f3 : arg1'=-2+arg1P_1+k*k_2, arg2'=1+arg2P_2-2*k_2-3*k*k_2, [ arg1P_1>=2 && k>=0 && k_2>=0 && 1-2*k*(-1+k_2)+arg2P_2+arg1P_1-2*k_2>=k*(-1+k_2)+arg1P_1 && 2-2*k*(-1+k_2)+arg2P_2-2*k+arg1P_1-2*k_2>=1+k*(-1+k_2)+k+arg1P_1 ], cost: 10+5*k_2+4*k*k_2
     61: __init -> f3 : arg1'=arg1P_1-2*k_7, arg2'=arg2P_2+k_7, [ k_7>=0 && 2+arg1P_1-2*k_7>=2 ], cost: 3+7*k_7
     62: __init -> f3 : arg1'=arg1P_1-2*k_9, arg2'=arg2P_2+k_9-2*k_1*k_9, [ k_1>=0 && 1+arg2P_2+arg1P_1-2*k_1>=arg1P_1 && -2+3*arg2P_2+2*arg1P_1-3*k_1<=0 && k_9>=0 && 2+arg1P_1-2*k_9>=2 ], cost: 3+7*k_9+5*k_1*k_9
     63: __init -> f3 : arg1'=-2*k_10+arg1P_1, arg2'=k_10+arg2P_2-2*k_10*k_1, [ k_1>=0 && 1+arg2P_2+arg1P_1-2*k_1>=arg1P_1 && 15*k_1<=0 && k_10>=0 && 2-2*k_10+arg1P_1>=2 && 1+k_10-3*arg2P_2-2*arg1P_1+3*k_1+6*k_1*(-1+k_10)<=-1 ], cost: 3+7*k_10+5*k_10*k_1
     64: __init -> f3 : arg1'=arg1P_1-2*k_11, arg2'=arg2P_2+k_11-2*k_1*k_11, [ k_1>=0 && -15*k_1<=-1 && k_11>=0 && 2+arg1P_1-2*k_11>=2 && 2+arg2P_2+arg1P_1-2*k_1-k_11-2*k_1*(-1+k_11)>=2+arg1P_1-2*k_11 && 1-3*arg2P_2-2*arg1P_1+3*k_1+k_11+6*k_1*(-1+k_11)<=-1 ], cost: 3+7*k_11+5*k_1*k_11

Removed unreachable locations (and leaf rules with constant cost):
   Start location: __init
     59: __init -> f3 : arg1'=-2+arg1P_1, arg2'=1+arg2P_2-2*k_1, [ arg1P_1>=2 && k_1>=0 && 1+arg2P_2+arg1P_1-2*k_1>=arg1P_1 ], cost: 10+5*k_1
     60: __init -> f3 : arg1'=-2+arg1P_1+k*k_2, arg2'=1+arg2P_2-2*k_2-3*k*k_2, [ arg1P_1>=2 && k>=0 && k_2>=0 && 1-2*k*(-1+k_2)+arg2P_2+arg1P_1-2*k_2>=k*(-1+k_2)+arg1P_1 && 2-2*k*(-1+k_2)+arg2P_2-2*k+arg1P_1-2*k_2>=1+k*(-1+k_2)+k+arg1P_1 ], cost: 10+5*k_2+4*k*k_2
     61: __init -> f3 : arg1'=arg1P_1-2*k_7, arg2'=arg2P_2+k_7, [ k_7>=0 && 2+arg1P_1-2*k_7>=2 ], cost: 3+7*k_7
     62: __init -> f3 : arg1'=arg1P_1-2*k_9, arg2'=arg2P_2+k_9-2*k_1*k_9, [ k_1>=0 && 1+arg2P_2+arg1P_1-2*k_1>=arg1P_1 && -2+3*arg2P_2+2*arg1P_1-3*k_1<=0 && k_9>=0 && 2+arg1P_1-2*k_9>=2 ], cost: 3+7*k_9+5*k_1*k_9
     63: __init -> f3 : arg1'=-2*k_10+arg1P_1, arg2'=k_10+arg2P_2-2*k_10*k_1, [ k_1>=0 && 1+arg2P_2+arg1P_1-2*k_1>=arg1P_1 && 15*k_1<=0 && k_10>=0 && 2-2*k_10+arg1P_1>=2 && 1+k_10-3*arg2P_2-2*arg1P_1+3*k_1+6*k_1*(-1+k_10)<=-1 ], cost: 3+7*k_10+5*k_10*k_1
     64: __init -> f3 : arg1'=arg1P_1-2*k_11, arg2'=arg2P_2+k_11-2*k_1*k_11, [ k_1>=0 && -15*k_1<=-1 && k_11>=0 && 2+arg1P_1-2*k_11>=2 && 2+arg2P_2+arg1P_1-2*k_1-k_11-2*k_1*(-1+k_11)>=2+arg1P_1-2*k_11 && 1-3*arg2P_2-2*arg1P_1+3*k_1+k_11+6*k_1*(-1+k_11)<=-1 ], cost: 3+7*k_11+5*k_1*k_11

### Computing asymptotic complexity ###

Fully simplified ITS problem
   Start location: __init
     59: __init -> f3 : arg1'=-2+arg1P_1, arg2'=1+arg2P_2-2*k_1, [ arg1P_1>=2 && k_1>=0 && 1+arg2P_2+arg1P_1-2*k_1>=arg1P_1 ], cost: 10+5*k_1
     60: __init -> f3 : arg1'=-2+arg1P_1+k*k_2, arg2'=1+arg2P_2-2*k_2-3*k*k_2, [ arg1P_1>=2 && k>=0 && k_2>=0 && 1-2*k*(-1+k_2)+arg2P_2+arg1P_1-2*k_2>=k*(-1+k_2)+arg1P_1 && 2-2*k*(-1+k_2)+arg2P_2-2*k+arg1P_1-2*k_2>=1+k*(-1+k_2)+k+arg1P_1 ], cost: 10+5*k_2+4*k*k_2
     61: __init -> f3 : arg1'=arg1P_1-2*k_7, arg2'=arg2P_2+k_7, [ k_7>=0 && 2+arg1P_1-2*k_7>=2 ], cost: 3+7*k_7
     62: __init -> f3 : arg1'=arg1P_1-2*k_9, arg2'=arg2P_2+k_9-2*k_1*k_9, [ k_1>=0 && 1+arg2P_2+arg1P_1-2*k_1>=arg1P_1 && -2+3*arg2P_2+2*arg1P_1-3*k_1<=0 && k_9>=0 && 2+arg1P_1-2*k_9>=2 ], cost: 3+7*k_9+5*k_1*k_9
     63: __init -> f3 : arg1'=-2*k_10+arg1P_1, arg2'=k_10+arg2P_2-2*k_10*k_1, [ k_1>=0 && 1+arg2P_2+arg1P_1-2*k_1>=arg1P_1 && 15*k_1<=0 && k_10>=0 && 2-2*k_10+arg1P_1>=2 && 1+k_10-3*arg2P_2-2*arg1P_1+3*k_1+6*k_1*(-1+k_10)<=-1 ], cost: 3+7*k_10+5*k_10*k_1
     64: __init -> f3 : arg1'=arg1P_1-2*k_11, arg2'=arg2P_2+k_11-2*k_1*k_11, [ k_1>=0 && -15*k_1<=-1 && k_11>=0 && 2+arg1P_1-2*k_11>=2 && 2+arg2P_2+arg1P_1-2*k_1-k_11-2*k_1*(-1+k_11)>=2+arg1P_1-2*k_11 && 1-3*arg2P_2-2*arg1P_1+3*k_1+k_11+6*k_1*(-1+k_11)<=-1 ], cost: 3+7*k_11+5*k_1*k_11

Computing asymptotic complexity for rule 60
   Resulting cost 0 has complexity: Unknown

Computing asymptotic complexity for rule 62
   Resulting cost 0 has complexity: Unknown

Computing asymptotic complexity for rule 63
   Resulting cost 0 has complexity: Unknown

Computing asymptotic complexity for rule 64
   Simplified the guard:
     64: __init -> f3 : arg1'=arg1P_1-2*k_11, arg2'=arg2P_2+k_11-2*k_1*k_11, [ -15*k_1<=-1 && k_11>=0 && 2+arg1P_1-2*k_11>=2 && 2+arg2P_2+arg1P_1-2*k_1-k_11-2*k_1*(-1+k_11)>=2+arg1P_1-2*k_11 ], cost: 3+7*k_11+5*k_1*k_11
   Resulting cost 0 has complexity: Unknown

Computing asymptotic complexity for rule 61
   Resulting cost 0 has complexity: Unknown

Computing asymptotic complexity for rule 59
   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:  []

WORST_CASE(Omega(1),?)