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

Checking for constant complexity:
   The following rule is satisfiable with cost >= 1, yielding constant complexity:
     24: __init -> f1 : arg1'=arg1P_25, arg2'=arg2P_25, [], 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 && 0==arg2P_2 ], cost: 1
     21: f3 -> f4 : arg1'=arg1P_22, arg2'=arg2P_22, [ arg1>0 && arg1==arg1P_22 && arg2==arg2P_22 ], cost: 1
      2: f5 -> f8 : arg1'=arg1P_3, arg2'=arg2P_3, [ arg1==arg1P_3 && 1==arg2P_3 ], cost: 1
      6: f8 -> f7 : arg1'=arg1P_7, arg2'=arg2P_7, [ arg1==arg1P_7 && arg2==arg2P_7 ], cost: 1
      3: f4 -> f5 : arg1'=arg1P_4, arg2'=arg2P_4, [ arg1==1 && arg1==arg1P_4 && arg2==arg2P_4 ], cost: 1
      4: f4 -> f6 : arg1'=arg1P_5, arg2'=arg2P_5, [ arg1<1 && arg1==arg1P_5 && arg2==arg2P_5 ], cost: 1
      5: f4 -> f6 : arg1'=arg1P_6, arg2'=arg2P_6, [ arg1>1 && arg1==arg1P_6 && arg2==arg2P_6 ], cost: 1
      7: f6 -> f7 : arg1'=arg1P_8, arg2'=arg2P_8, [ arg1==arg1P_8 && arg2==arg2P_8 ], cost: 1
      9: f7 -> f9 : arg1'=arg1P_10, arg2'=arg2P_10, [ arg1==10 && arg1==arg1P_10 && arg2==arg2P_10 ], cost: 1
     10: f7 -> f10 : arg1'=arg1P_11, arg2'=arg2P_11, [ arg1<10 && arg1==arg1P_11 && arg2==arg2P_11 ], cost: 1
     11: f7 -> f10 : arg1'=arg1P_12, arg2'=arg2P_12, [ arg1>10 && arg1==arg1P_12 && arg2==arg2P_12 ], cost: 1
      8: f9 -> f12 : arg1'=arg1P_9, arg2'=arg2P_9, [ arg1==arg1P_9 && 0==arg2P_9 ], cost: 1
     12: f12 -> f11 : arg1'=arg1P_13, arg2'=arg2P_13, [ arg1==arg1P_13 && arg2==arg2P_13 ], cost: 1
     13: f10 -> f11 : arg1'=arg1P_14, arg2'=arg2P_14, [ arg1==arg1P_14 && arg2==arg2P_14 ], cost: 1
     16: f11 -> f13 : arg1'=arg1P_17, arg2'=arg2P_17, [ arg2==1 && arg1==arg1P_17 && arg2==arg2P_17 ], cost: 1
     17: f11 -> f14 : arg1'=arg1P_18, arg2'=arg2P_18, [ arg2<1 && arg1==arg1P_18 && arg2==arg2P_18 ], cost: 1
     18: f11 -> f14 : arg1'=arg1P_19, arg2'=arg2P_19, [ arg2>1 && arg1==arg1P_19 && arg2==arg2P_19 ], cost: 1
     14: f13 -> f16 : arg1'=arg1P_15, arg2'=arg2P_15, [ arg1P_15==1+arg1 && arg2==arg2P_15 ], cost: 1
     19: f16 -> f15 : arg1'=arg1P_20, arg2'=arg2P_20, [ arg1==arg1P_20 && arg2==arg2P_20 ], cost: 1
     15: f14 -> f17 : arg1'=arg1P_16, arg2'=arg2P_16, [ arg1P_16==-1+arg1 && arg2==arg2P_16 ], cost: 1
     20: f17 -> f15 : arg1'=arg1P_21, arg2'=arg2P_21, [ arg1==arg1P_21 && arg2==arg2P_21 ], cost: 1
     22: f15 -> f3 : arg1'=arg1P_23, arg2'=arg2P_23, [ arg1==arg1P_23 && arg2==arg2P_23 ], cost: 1
     24: __init -> f1 : arg1'=arg1P_25, arg2'=arg2P_25, [], cost: 1

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

### Simplification by acceleration and chaining ###

Eliminated locations (on linear paths):
   Start location: __init
     21: f3 -> f4 : [ arg1>0 ], cost: 1
      4: f4 -> f6 : [ arg1<1 ], cost: 1
      5: f4 -> f6 : [ arg1>1 ], cost: 1
     28: f4 -> f7 : arg2'=1, [ arg1==1 ], cost: 3
      7: f6 -> f7 : [], cost: 1
     10: f7 -> f10 : [ arg1<10 ], cost: 1
     11: f7 -> f10 : [ arg1>10 ], cost: 1
     30: f7 -> f11 : arg2'=0, [ arg1==10 ], cost: 3
     13: f10 -> f11 : [], cost: 1
     17: f11 -> f14 : [ arg2<1 ], cost: 1
     18: f11 -> f14 : [ arg2>1 ], cost: 1
     32: f11 -> f15 : arg1'=1+arg1, [ arg2==1 ], cost: 3
     33: f14 -> f15 : arg1'=-1+arg1, [], cost: 2
     22: f15 -> f3 : [], cost: 1
     26: __init -> f3 : arg1'=arg1P_1, arg2'=0, [], cost: 3

Eliminated locations (on tree-shaped paths):
   Start location: __init
     34: f3 -> f6 : [ arg1>1 ], cost: 2
     35: f3 -> f7 : arg2'=1, [ arg1==1 ], cost: 4
      7: f6 -> f7 : [], cost: 1
     38: f7 -> f14 : arg2'=0, [ arg1==10 ], cost: 4
     39: f7 -> f14 : [ arg1<10 && arg2<1 ], cost: 3
     40: f7 -> f14 : [ arg1<10 && arg2>1 ], cost: 3
     41: f7 -> f15 : arg1'=1+arg1, [ arg1<10 && arg2==1 ], cost: 5
     42: f7 -> f14 : [ arg1>10 && arg2<1 ], cost: 3
     43: f7 -> f14 : [ arg1>10 && arg2>1 ], cost: 3
     44: f7 -> f15 : arg1'=1+arg1, [ arg1>10 && arg2==1 ], cost: 5
     33: f14 -> f15 : arg1'=-1+arg1, [], cost: 2
     22: f15 -> f3 : [], cost: 1
     26: __init -> f3 : arg1'=arg1P_1, arg2'=0, [], cost: 3

Eliminated locations (on linear paths):
   Start location: __init
     35: f3 -> f7 : arg2'=1, [ arg1==1 ], cost: 4
     45: f3 -> f7 : [ arg1>1 ], cost: 3
     38: f7 -> f14 : arg2'=0, [ arg1==10 ], cost: 4
     39: f7 -> f14 : [ arg1<10 && arg2<1 ], cost: 3
     40: f7 -> f14 : [ arg1<10 && arg2>1 ], cost: 3
     41: f7 -> f15 : arg1'=1+arg1, [ arg1<10 && arg2==1 ], cost: 5
     42: f7 -> f14 : [ arg1>10 && arg2<1 ], cost: 3
     43: f7 -> f14 : [ arg1>10 && arg2>1 ], cost: 3
     44: f7 -> f15 : arg1'=1+arg1, [ arg1>10 && arg2==1 ], cost: 5
     33: f14 -> f15 : arg1'=-1+arg1, [], cost: 2
     22: f15 -> f3 : [], cost: 1
     26: __init -> f3 : arg1'=arg1P_1, arg2'=0, [], cost: 3

Eliminated locations (on tree-shaped paths):
   Start location: __init
     46: f3 -> f15 : arg1'=1+arg1, arg2'=1, [ arg1==1 ], cost: 9
     47: f3 -> f14 : arg2'=0, [ arg1==10 ], cost: 7
     48: f3 -> f14 : [ arg1>1 && arg1<10 && arg2<1 ], cost: 6
     49: f3 -> f14 : [ arg1>1 && arg1<10 && arg2>1 ], cost: 6
     50: f3 -> f15 : arg1'=1+arg1, [ arg1>1 && arg1<10 && arg2==1 ], cost: 8
     51: f3 -> f14 : [ arg1>10 && arg2<1 ], cost: 6
     52: f3 -> f14 : [ arg1>10 && arg2>1 ], cost: 6
     53: f3 -> f15 : arg1'=1+arg1, [ arg1>10 && arg2==1 ], cost: 8
     33: f14 -> f15 : arg1'=-1+arg1, [], cost: 2
     22: f15 -> f3 : [], cost: 1
     26: __init -> f3 : arg1'=arg1P_1, arg2'=0, [], cost: 3

Eliminated locations (on tree-shaped paths):
   Start location: __init
     59: f3 -> f3 : arg1'=1+arg1, arg2'=1, [ arg1==1 ], cost: 10
     60: f3 -> f3 : arg1'=1+arg1, [ arg1>1 && arg1<10 && arg2==1 ], cost: 9
     61: f3 -> f3 : arg1'=1+arg1, [ arg1>10 && arg2==1 ], cost: 9
     62: f3 -> f3 : arg1'=-1+arg1, arg2'=0, [ arg1==10 ], cost: 10
     63: f3 -> f3 : arg1'=-1+arg1, [ arg1>1 && arg1<10 && arg2<1 ], cost: 9
     64: f3 -> f3 : arg1'=-1+arg1, [ arg1>1 && arg1<10 && arg2>1 ], cost: 9
     65: f3 -> f3 : arg1'=-1+arg1, [ arg1>10 && arg2<1 ], cost: 9
     66: f3 -> f3 : arg1'=-1+arg1, [ arg1>10 && arg2>1 ], cost: 9
     26: __init -> f3 : arg1'=arg1P_1, arg2'=0, [], cost: 3

Accelerating simple loops of location 2.
   Accelerating the following rules:
     59: f3 -> f3 : arg1'=1+arg1, arg2'=1, [ arg1==1 ], cost: 10
     60: f3 -> f3 : arg1'=1+arg1, [ arg1>1 && arg1<10 && arg2==1 ], cost: 9
     61: f3 -> f3 : arg1'=1+arg1, [ arg1>10 && arg2==1 ], cost: 9
     62: f3 -> f3 : arg1'=-1+arg1, arg2'=0, [ arg1==10 ], cost: 10
     63: f3 -> f3 : arg1'=-1+arg1, [ arg1>1 && arg1<10 && arg2<1 ], cost: 9
     64: f3 -> f3 : arg1'=-1+arg1, [ arg1>1 && arg1<10 && arg2>1 ], cost: 9
     65: f3 -> f3 : arg1'=-1+arg1, [ arg1>10 && arg2<1 ], cost: 9
     66: f3 -> f3 : arg1'=-1+arg1, [ arg1>10 && arg2>1 ], cost: 9

   Failed to prove monotonicity of the guard of rule 59.
   Accelerated rule 60 with backward acceleration, yielding the new rule 67.
   Accelerated rule 61 with non-termination, yielding the new rule 68.
   Failed to prove monotonicity of the guard of rule 62.
   Accelerated rule 63 with backward acceleration, yielding the new rule 69.
   Accelerated rule 64 with backward acceleration, yielding the new rule 70.
   Accelerated rule 65 with backward acceleration, yielding the new rule 71.
   Accelerated rule 66 with backward acceleration, yielding the new rule 72.
[accelerate] Nesting with 7 inner and 7 outer candidates
   Removing the simple loops: 60 61 63 64 65 66.

Accelerated all simple loops using metering functions (where possible):
   Start location: __init
     59: f3 -> f3 : arg1'=1+arg1, arg2'=1, [ arg1==1 ], cost: 10
     62: f3 -> f3 : arg1'=-1+arg1, arg2'=0, [ arg1==10 ], cost: 10
     67: f3 -> f3 : arg1'=10, [ arg1>1 && arg2==1 && 10-arg1>=0 ], cost: 90-9*arg1
     68: f3 -> [19] : [ arg1>10 && arg2==1 ], cost: NONTERM
     69: f3 -> f3 : arg1'=1, [ arg1<10 && arg2<1 && -1+arg1>=0 ], cost: -9+9*arg1
     70: f3 -> f3 : arg1'=1, [ arg1<10 && arg2>1 && -1+arg1>=0 ], cost: -9+9*arg1
     71: f3 -> f3 : arg1'=10, [ arg2<1 && -10+arg1>=0 ], cost: -90+9*arg1
     72: f3 -> f3 : arg1'=10, [ arg2>1 && -10+arg1>=0 ], cost: -90+9*arg1
     26: __init -> f3 : arg1'=arg1P_1, arg2'=0, [], cost: 3

Chained accelerated rules (with incoming rules):
   Start location: __init
     26: __init -> f3 : arg1'=arg1P_1, arg2'=0, [], cost: 3
     73: __init -> f3 : arg1'=2, arg2'=1, [], cost: 13
     74: __init -> f3 : arg1'=9, arg2'=0, [], cost: 13
     75: __init -> f3 : arg1'=1, arg2'=0, [ arg1P_1<10 && -1+arg1P_1>=0 ], cost: -6+9*arg1P_1
     76: __init -> f3 : arg1'=10, arg2'=0, [ -10+arg1P_1>=0 ], cost: -87+9*arg1P_1

Removed unreachable locations (and leaf rules with constant cost):
   Start location: __init
     75: __init -> f3 : arg1'=1, arg2'=0, [ arg1P_1<10 && -1+arg1P_1>=0 ], cost: -6+9*arg1P_1
     76: __init -> f3 : arg1'=10, arg2'=0, [ -10+arg1P_1>=0 ], cost: -87+9*arg1P_1

### Computing asymptotic complexity ###

Fully simplified ITS problem
   Start location: __init
     75: __init -> f3 : arg1'=1, arg2'=0, [ arg1P_1<10 && -1+arg1P_1>=0 ], cost: -6+9*arg1P_1
     76: __init -> f3 : arg1'=10, arg2'=0, [ -10+arg1P_1>=0 ], cost: -87+9*arg1P_1

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

Computing asymptotic complexity for rule 75
   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),?)