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, arg3'=arg3P_1, [ arg2==arg2P_1 && arg3==arg3P_1 ], cost: 1
      1: f2 -> f3 : arg1'=arg1P_2, arg2'=arg2P_2, arg3'=arg3P_2, [ arg1==arg1P_2 && 20==arg2P_2 && arg3==arg3P_2 ], cost: 1
      2: f3 -> f4 : arg1'=arg1P_3, arg2'=arg2P_3, arg3'=arg3P_3, [ arg1==arg1P_3 && arg2==arg2P_3 && 0==arg3P_3 ], cost: 1
     33: f4 -> f5 : arg1'=arg1P_34, arg2'=arg2P_34, arg3'=arg3P_34, [ 0<=arg1 && arg1<=arg2 && arg1==arg1P_34 && arg2==arg2P_34 && arg3==arg3P_34 ], cost: 1
     35: f4 -> f26 : arg1'=arg1P_36, arg2'=arg2P_36, arg3'=arg3P_36, [ 0>arg1 && arg1==arg1P_36 && arg2==arg2P_36 && arg3==arg3P_36 ], cost: 1
     36: f4 -> f26 : arg1'=arg1P_37, arg2'=arg2P_37, arg3'=arg3P_37, [ arg1>arg2 && arg1==arg1P_37 && arg2==arg2P_37 && arg3==arg3P_37 ], cost: 1
      3: f6 -> f9 : arg1'=arg1P_4, arg2'=arg2P_4, arg3'=arg3P_4, [ arg1==arg1P_4 && arg2==arg2P_4 && 1==arg3P_4 ], cost: 1
      7: f9 -> f8 : arg1'=arg1P_8, arg2'=arg2P_8, arg3'=arg3P_8, [ arg1==arg1P_8 && arg2==arg2P_8 && arg3==arg3P_8 ], cost: 1
      4: f5 -> f6 : arg1'=arg1P_5, arg2'=arg2P_5, arg3'=arg3P_5, [ arg1==0 && arg1==arg1P_5 && arg2==arg2P_5 && arg3==arg3P_5 ], cost: 1
      5: f5 -> f7 : arg1'=arg1P_6, arg2'=arg2P_6, arg3'=arg3P_6, [ arg1<0 && arg1==arg1P_6 && arg2==arg2P_6 && arg3==arg3P_6 ], cost: 1
      6: f5 -> f7 : arg1'=arg1P_7, arg2'=arg2P_7, arg3'=arg3P_7, [ arg1>0 && arg1==arg1P_7 && arg2==arg2P_7 && arg3==arg3P_7 ], cost: 1
      8: f7 -> f8 : arg1'=arg1P_9, arg2'=arg2P_9, arg3'=arg3P_9, [ arg1==arg1P_9 && arg2==arg2P_9 && arg3==arg3P_9 ], cost: 1
     10: f8 -> f10 : arg1'=arg1P_11, arg2'=arg2P_11, arg3'=arg3P_11, [ arg1==arg2 && arg1==arg1P_11 && arg2==arg2P_11 && arg3==arg3P_11 ], cost: 1
     11: f8 -> f11 : arg1'=arg1P_12, arg2'=arg2P_12, arg3'=arg3P_12, [ arg1<arg2 && arg1==arg1P_12 && arg2==arg2P_12 && arg3==arg3P_12 ], cost: 1
     12: f8 -> f11 : arg1'=arg1P_13, arg2'=arg2P_13, arg3'=arg3P_13, [ arg1>arg2 && arg1==arg1P_13 && arg2==arg2P_13 && arg3==arg3P_13 ], cost: 1
      9: f10 -> f13 : arg1'=arg1P_10, arg2'=arg2P_10, arg3'=arg3P_10, [ arg1==arg1P_10 && arg2==arg2P_10 && 0==arg3P_10 ], cost: 1
     13: f13 -> f12 : arg1'=arg1P_14, arg2'=arg2P_14, arg3'=arg3P_14, [ arg1==arg1P_14 && arg2==arg2P_14 && arg3==arg3P_14 ], cost: 1
     14: f11 -> f12 : arg1'=arg1P_15, arg2'=arg2P_15, arg3'=arg3P_15, [ arg1==arg1P_15 && arg2==arg2P_15 && arg3==arg3P_15 ], cost: 1
     16: f12 -> f14 : arg1'=arg1P_17, arg2'=arg2P_17, arg3'=arg3P_17, [ arg3==1 && arg1==arg1P_17 && arg2==arg2P_17 && arg3==arg3P_17 ], cost: 1
     17: f12 -> f15 : arg1'=arg1P_18, arg2'=arg2P_18, arg3'=arg3P_18, [ arg3<1 && arg1==arg1P_18 && arg2==arg2P_18 && arg3==arg3P_18 ], cost: 1
     18: f12 -> f15 : arg1'=arg1P_19, arg2'=arg2P_19, arg3'=arg3P_19, [ arg3>1 && arg1==arg1P_19 && arg2==arg2P_19 && arg3==arg3P_19 ], cost: 1
     15: f14 -> f17 : arg1'=arg1P_16, arg2'=arg2P_16, arg3'=arg3P_16, [ arg1P_16==1+arg1 && arg2==arg2P_16 && arg3==arg3P_16 ], cost: 1
     19: f17 -> f16 : arg1'=arg1P_20, arg2'=arg2P_20, arg3'=arg3P_20, [ arg1==arg1P_20 && arg2==arg2P_20 && arg3==arg3P_20 ], cost: 1
     20: f15 -> f16 : arg1'=arg1P_21, arg2'=arg2P_21, arg3'=arg3P_21, [ arg1==arg1P_21 && arg2==arg2P_21 && arg3==arg3P_21 ], cost: 1
     22: f16 -> f18 : arg1'=arg1P_23, arg2'=arg2P_23, arg3'=arg3P_23, [ arg3==0 && arg1==arg1P_23 && arg2==arg2P_23 && arg3==arg3P_23 ], cost: 1
     23: f16 -> f19 : arg1'=arg1P_24, arg2'=arg2P_24, arg3'=arg3P_24, [ arg3<0 && arg1==arg1P_24 && arg2==arg2P_24 && arg3==arg3P_24 ], cost: 1
     24: f16 -> f19 : arg1'=arg1P_25, arg2'=arg2P_25, arg3'=arg3P_25, [ arg3>0 && arg1==arg1P_25 && arg2==arg2P_25 && arg3==arg3P_25 ], cost: 1
     21: f18 -> f21 : arg1'=arg1P_22, arg2'=arg2P_22, arg3'=arg3P_22, [ arg1P_22==-1+arg1 && arg2==arg2P_22 && arg3==arg3P_22 ], cost: 1
     25: f21 -> f20 : arg1'=arg1P_26, arg2'=arg2P_26, arg3'=arg3P_26, [ arg1==arg1P_26 && arg2==arg2P_26 && arg3==arg3P_26 ], cost: 1
     26: f19 -> f20 : arg1'=arg1P_27, arg2'=arg2P_27, arg3'=arg3P_27, [ arg1==arg1P_27 && arg2==arg2P_27 && arg3==arg3P_27 ], cost: 1
     28: f20 -> f22 : arg1'=arg1P_29, arg2'=arg2P_29, arg3'=arg3P_29, [ arg1==-2+arg2 && arg1==arg1P_29 && arg2==arg2P_29 && arg3==arg3P_29 ], cost: 1
     29: f20 -> f23 : arg1'=arg1P_30, arg2'=arg2P_30, arg3'=arg3P_30, [ arg1<-2+arg2 && arg1==arg1P_30 && arg2==arg2P_30 && arg3==arg3P_30 ], cost: 1
     30: f20 -> f23 : arg1'=arg1P_31, arg2'=arg2P_31, arg3'=arg3P_31, [ arg1>-2+arg2 && arg1==arg1P_31 && arg2==arg2P_31 && arg3==arg3P_31 ], cost: 1
     27: f22 -> f25 : arg1'=arg1P_28, arg2'=arg2P_28, arg3'=arg3P_28, [ arg2P_28==-1+arg2 && arg1==arg1P_28 && arg3==arg3P_28 ], cost: 1
     31: f25 -> f24 : arg1'=arg1P_32, arg2'=arg2P_32, arg3'=arg3P_32, [ arg1==arg1P_32 && arg2==arg2P_32 && arg3==arg3P_32 ], cost: 1
     32: f23 -> f24 : arg1'=arg1P_33, arg2'=arg2P_33, arg3'=arg3P_33, [ arg1==arg1P_33 && arg2==arg2P_33 && arg3==arg3P_33 ], cost: 1
     34: f24 -> f4 : arg1'=arg1P_35, arg2'=arg2P_35, arg3'=arg3P_35, [ arg1==arg1P_35 && arg2==arg2P_35 && arg3==arg3P_35 ], cost: 1
     37: __init -> f1 : arg1'=arg1P_38, arg2'=arg2P_38, arg3'=arg3P_38, [], cost: 1

Checking for constant complexity:
   The following rule is satisfiable with cost >= 1, yielding constant complexity:
     37: __init -> f1 : arg1'=arg1P_38, arg2'=arg2P_38, arg3'=arg3P_38, [], cost: 1

Removed unreachable and leaf rules:
   Start location: __init
      0: f1 -> f2 : arg1'=arg1P_1, arg2'=arg2P_1, arg3'=arg3P_1, [ arg2==arg2P_1 && arg3==arg3P_1 ], cost: 1
      1: f2 -> f3 : arg1'=arg1P_2, arg2'=arg2P_2, arg3'=arg3P_2, [ arg1==arg1P_2 && 20==arg2P_2 && arg3==arg3P_2 ], cost: 1
      2: f3 -> f4 : arg1'=arg1P_3, arg2'=arg2P_3, arg3'=arg3P_3, [ arg1==arg1P_3 && arg2==arg2P_3 && 0==arg3P_3 ], cost: 1
     33: f4 -> f5 : arg1'=arg1P_34, arg2'=arg2P_34, arg3'=arg3P_34, [ 0<=arg1 && arg1<=arg2 && arg1==arg1P_34 && arg2==arg2P_34 && arg3==arg3P_34 ], cost: 1
      3: f6 -> f9 : arg1'=arg1P_4, arg2'=arg2P_4, arg3'=arg3P_4, [ arg1==arg1P_4 && arg2==arg2P_4 && 1==arg3P_4 ], cost: 1
      7: f9 -> f8 : arg1'=arg1P_8, arg2'=arg2P_8, arg3'=arg3P_8, [ arg1==arg1P_8 && arg2==arg2P_8 && arg3==arg3P_8 ], cost: 1
      4: f5 -> f6 : arg1'=arg1P_5, arg2'=arg2P_5, arg3'=arg3P_5, [ arg1==0 && arg1==arg1P_5 && arg2==arg2P_5 && arg3==arg3P_5 ], cost: 1
      5: f5 -> f7 : arg1'=arg1P_6, arg2'=arg2P_6, arg3'=arg3P_6, [ arg1<0 && arg1==arg1P_6 && arg2==arg2P_6 && arg3==arg3P_6 ], cost: 1
      6: f5 -> f7 : arg1'=arg1P_7, arg2'=arg2P_7, arg3'=arg3P_7, [ arg1>0 && arg1==arg1P_7 && arg2==arg2P_7 && arg3==arg3P_7 ], cost: 1
      8: f7 -> f8 : arg1'=arg1P_9, arg2'=arg2P_9, arg3'=arg3P_9, [ arg1==arg1P_9 && arg2==arg2P_9 && arg3==arg3P_9 ], cost: 1
     10: f8 -> f10 : arg1'=arg1P_11, arg2'=arg2P_11, arg3'=arg3P_11, [ arg1==arg2 && arg1==arg1P_11 && arg2==arg2P_11 && arg3==arg3P_11 ], cost: 1
     11: f8 -> f11 : arg1'=arg1P_12, arg2'=arg2P_12, arg3'=arg3P_12, [ arg1<arg2 && arg1==arg1P_12 && arg2==arg2P_12 && arg3==arg3P_12 ], cost: 1
     12: f8 -> f11 : arg1'=arg1P_13, arg2'=arg2P_13, arg3'=arg3P_13, [ arg1>arg2 && arg1==arg1P_13 && arg2==arg2P_13 && arg3==arg3P_13 ], cost: 1
      9: f10 -> f13 : arg1'=arg1P_10, arg2'=arg2P_10, arg3'=arg3P_10, [ arg1==arg1P_10 && arg2==arg2P_10 && 0==arg3P_10 ], cost: 1
     13: f13 -> f12 : arg1'=arg1P_14, arg2'=arg2P_14, arg3'=arg3P_14, [ arg1==arg1P_14 && arg2==arg2P_14 && arg3==arg3P_14 ], cost: 1
     14: f11 -> f12 : arg1'=arg1P_15, arg2'=arg2P_15, arg3'=arg3P_15, [ arg1==arg1P_15 && arg2==arg2P_15 && arg3==arg3P_15 ], cost: 1
     16: f12 -> f14 : arg1'=arg1P_17, arg2'=arg2P_17, arg3'=arg3P_17, [ arg3==1 && arg1==arg1P_17 && arg2==arg2P_17 && arg3==arg3P_17 ], cost: 1
     17: f12 -> f15 : arg1'=arg1P_18, arg2'=arg2P_18, arg3'=arg3P_18, [ arg3<1 && arg1==arg1P_18 && arg2==arg2P_18 && arg3==arg3P_18 ], cost: 1
     18: f12 -> f15 : arg1'=arg1P_19, arg2'=arg2P_19, arg3'=arg3P_19, [ arg3>1 && arg1==arg1P_19 && arg2==arg2P_19 && arg3==arg3P_19 ], cost: 1
     15: f14 -> f17 : arg1'=arg1P_16, arg2'=arg2P_16, arg3'=arg3P_16, [ arg1P_16==1+arg1 && arg2==arg2P_16 && arg3==arg3P_16 ], cost: 1
     19: f17 -> f16 : arg1'=arg1P_20, arg2'=arg2P_20, arg3'=arg3P_20, [ arg1==arg1P_20 && arg2==arg2P_20 && arg3==arg3P_20 ], cost: 1
     20: f15 -> f16 : arg1'=arg1P_21, arg2'=arg2P_21, arg3'=arg3P_21, [ arg1==arg1P_21 && arg2==arg2P_21 && arg3==arg3P_21 ], cost: 1
     22: f16 -> f18 : arg1'=arg1P_23, arg2'=arg2P_23, arg3'=arg3P_23, [ arg3==0 && arg1==arg1P_23 && arg2==arg2P_23 && arg3==arg3P_23 ], cost: 1
     23: f16 -> f19 : arg1'=arg1P_24, arg2'=arg2P_24, arg3'=arg3P_24, [ arg3<0 && arg1==arg1P_24 && arg2==arg2P_24 && arg3==arg3P_24 ], cost: 1
     24: f16 -> f19 : arg1'=arg1P_25, arg2'=arg2P_25, arg3'=arg3P_25, [ arg3>0 && arg1==arg1P_25 && arg2==arg2P_25 && arg3==arg3P_25 ], cost: 1
     21: f18 -> f21 : arg1'=arg1P_22, arg2'=arg2P_22, arg3'=arg3P_22, [ arg1P_22==-1+arg1 && arg2==arg2P_22 && arg3==arg3P_22 ], cost: 1
     25: f21 -> f20 : arg1'=arg1P_26, arg2'=arg2P_26, arg3'=arg3P_26, [ arg1==arg1P_26 && arg2==arg2P_26 && arg3==arg3P_26 ], cost: 1
     26: f19 -> f20 : arg1'=arg1P_27, arg2'=arg2P_27, arg3'=arg3P_27, [ arg1==arg1P_27 && arg2==arg2P_27 && arg3==arg3P_27 ], cost: 1
     28: f20 -> f22 : arg1'=arg1P_29, arg2'=arg2P_29, arg3'=arg3P_29, [ arg1==-2+arg2 && arg1==arg1P_29 && arg2==arg2P_29 && arg3==arg3P_29 ], cost: 1
     29: f20 -> f23 : arg1'=arg1P_30, arg2'=arg2P_30, arg3'=arg3P_30, [ arg1<-2+arg2 && arg1==arg1P_30 && arg2==arg2P_30 && arg3==arg3P_30 ], cost: 1
     30: f20 -> f23 : arg1'=arg1P_31, arg2'=arg2P_31, arg3'=arg3P_31, [ arg1>-2+arg2 && arg1==arg1P_31 && arg2==arg2P_31 && arg3==arg3P_31 ], cost: 1
     27: f22 -> f25 : arg1'=arg1P_28, arg2'=arg2P_28, arg3'=arg3P_28, [ arg2P_28==-1+arg2 && arg1==arg1P_28 && arg3==arg3P_28 ], cost: 1
     31: f25 -> f24 : arg1'=arg1P_32, arg2'=arg2P_32, arg3'=arg3P_32, [ arg1==arg1P_32 && arg2==arg2P_32 && arg3==arg3P_32 ], cost: 1
     32: f23 -> f24 : arg1'=arg1P_33, arg2'=arg2P_33, arg3'=arg3P_33, [ arg1==arg1P_33 && arg2==arg2P_33 && arg3==arg3P_33 ], cost: 1
     34: f24 -> f4 : arg1'=arg1P_35, arg2'=arg2P_35, arg3'=arg3P_35, [ arg1==arg1P_35 && arg2==arg2P_35 && arg3==arg3P_35 ], cost: 1
     37: __init -> f1 : arg1'=arg1P_38, arg2'=arg2P_38, arg3'=arg3P_38, [], cost: 1

Simplified all rules, resulting in:
   Start location: __init
      0: f1 -> f2 : arg1'=arg1P_1, [], cost: 1
      1: f2 -> f3 : arg2'=20, [], cost: 1
      2: f3 -> f4 : arg3'=0, [], cost: 1
     33: f4 -> f5 : [ 0<=arg1 && arg1<=arg2 ], cost: 1
      3: f6 -> f9 : arg3'=1, [], cost: 1
      7: f9 -> f8 : [], cost: 1
      4: f5 -> f6 : [ arg1==0 ], cost: 1
      5: f5 -> f7 : [ arg1<0 ], cost: 1
      6: f5 -> f7 : [ arg1>0 ], cost: 1
      8: f7 -> f8 : [], cost: 1
     10: f8 -> f10 : [ arg1==arg2 ], cost: 1
     11: f8 -> f11 : [ arg1<arg2 ], cost: 1
     12: f8 -> f11 : [ arg1>arg2 ], cost: 1
      9: f10 -> f13 : arg3'=0, [], cost: 1
     13: f13 -> f12 : [], cost: 1
     14: f11 -> f12 : [], cost: 1
     16: f12 -> f14 : [ arg3==1 ], cost: 1
     17: f12 -> f15 : [ arg3<1 ], cost: 1
     18: f12 -> f15 : [ arg3>1 ], cost: 1
     15: f14 -> f17 : arg1'=1+arg1, [], cost: 1
     19: f17 -> f16 : [], cost: 1
     20: f15 -> f16 : [], cost: 1
     22: f16 -> f18 : [ arg3==0 ], cost: 1
     23: f16 -> f19 : [ arg3<0 ], cost: 1
     24: f16 -> f19 : [ arg3>0 ], cost: 1
     21: f18 -> f21 : arg1'=-1+arg1, [], cost: 1
     25: f21 -> f20 : [], cost: 1
     26: f19 -> f20 : [], cost: 1
     28: f20 -> f22 : [ arg1==-2+arg2 ], cost: 1
     29: f20 -> f23 : [ arg1<-2+arg2 ], cost: 1
     30: f20 -> f23 : [ arg1>-2+arg2 ], cost: 1
     27: f22 -> f25 : arg2'=-1+arg2, [], cost: 1
     31: f25 -> f24 : [], cost: 1
     32: f23 -> f24 : [], cost: 1
     34: f24 -> f4 : [], cost: 1
     37: __init -> f1 : arg1'=arg1P_38, arg2'=arg2P_38, arg3'=arg3P_38, [], cost: 1

### Simplification by acceleration and chaining ###

Eliminated locations (on linear paths):
   Start location: __init
     33: f4 -> f5 : [ 0<=arg1 && arg1<=arg2 ], cost: 1
      5: f5 -> f7 : [ arg1<0 ], cost: 1
      6: f5 -> f7 : [ arg1>0 ], cost: 1
     42: f5 -> f8 : arg3'=1, [ arg1==0 ], cost: 3
      8: f7 -> f8 : [], cost: 1
     11: f8 -> f11 : [ arg1<arg2 ], cost: 1
     12: f8 -> f11 : [ arg1>arg2 ], cost: 1
     44: f8 -> f12 : arg3'=0, [ arg1==arg2 ], cost: 3
     14: f11 -> f12 : [], cost: 1
     17: f12 -> f15 : [ arg3<1 ], cost: 1
     18: f12 -> f15 : [ arg3>1 ], cost: 1
     46: f12 -> f16 : arg1'=1+arg1, [ arg3==1 ], cost: 3
     20: f15 -> f16 : [], cost: 1
     23: f16 -> f19 : [ arg3<0 ], cost: 1
     24: f16 -> f19 : [ arg3>0 ], cost: 1
     48: f16 -> f20 : arg1'=-1+arg1, [ arg3==0 ], cost: 3
     26: f19 -> f20 : [], cost: 1
     29: f20 -> f23 : [ arg1<-2+arg2 ], cost: 1
     30: f20 -> f23 : [ arg1>-2+arg2 ], cost: 1
     50: f20 -> f24 : arg2'=-1+arg2, [ arg1==-2+arg2 ], cost: 3
     32: f23 -> f24 : [], cost: 1
     34: f24 -> f4 : [], cost: 1
     40: __init -> f4 : arg1'=arg1P_1, arg2'=20, arg3'=0, [], cost: 4

Eliminated locations (on tree-shaped paths):
   Start location: __init
     51: f4 -> f7 : [ arg1<=arg2 && arg1>0 ], cost: 2
     52: f4 -> f8 : arg3'=1, [ arg1<=arg2 && arg1==0 ], cost: 4
      8: f7 -> f8 : [], cost: 1
     55: f8 -> f15 : arg3'=0, [ arg1==arg2 ], cost: 4
     56: f8 -> f15 : [ arg1<arg2 && arg3<1 ], cost: 3
     57: f8 -> f15 : [ arg1<arg2 && arg3>1 ], cost: 3
     58: f8 -> f16 : arg1'=1+arg1, [ arg1<arg2 && arg3==1 ], cost: 5
     59: f8 -> f15 : [ arg1>arg2 && arg3<1 ], cost: 3
     60: f8 -> f15 : [ arg1>arg2 && arg3>1 ], cost: 3
     61: f8 -> f16 : arg1'=1+arg1, [ arg1>arg2 && arg3==1 ], cost: 5
     20: f15 -> f16 : [], cost: 1
     64: f16 -> f23 : arg1'=-1+arg1, [ arg3==0 && -1+arg1<-2+arg2 ], cost: 4
     65: f16 -> f23 : arg1'=-1+arg1, [ arg3==0 && -1+arg1>-2+arg2 ], cost: 4
     66: f16 -> f24 : arg1'=-1+arg1, arg2'=-1+arg2, [ arg3==0 && -1+arg1==-2+arg2 ], cost: 6
     67: f16 -> f23 : [ arg3<0 && arg1<-2+arg2 ], cost: 3
     68: f16 -> f23 : [ arg3<0 && arg1>-2+arg2 ], cost: 3
     69: f16 -> f24 : arg2'=-1+arg2, [ arg3<0 && arg1==-2+arg2 ], cost: 5
     70: f16 -> f23 : [ arg3>0 && arg1<-2+arg2 ], cost: 3
     71: f16 -> f23 : [ arg3>0 && arg1>-2+arg2 ], cost: 3
     72: f16 -> f24 : arg2'=-1+arg2, [ arg3>0 && arg1==-2+arg2 ], cost: 5
     32: f23 -> f24 : [], cost: 1
     34: f24 -> f4 : [], cost: 1
     40: __init -> f4 : arg1'=arg1P_1, arg2'=20, arg3'=0, [], cost: 4

Eliminated locations (on linear paths):
   Start location: __init
     52: f4 -> f8 : arg3'=1, [ arg1<=arg2 && arg1==0 ], cost: 4
     73: f4 -> f8 : [ arg1<=arg2 && arg1>0 ], cost: 3
     55: f8 -> f15 : arg3'=0, [ arg1==arg2 ], cost: 4
     56: f8 -> f15 : [ arg1<arg2 && arg3<1 ], cost: 3
     57: f8 -> f15 : [ arg1<arg2 && arg3>1 ], cost: 3
     58: f8 -> f16 : arg1'=1+arg1, [ arg1<arg2 && arg3==1 ], cost: 5
     59: f8 -> f15 : [ arg1>arg2 && arg3<1 ], cost: 3
     60: f8 -> f15 : [ arg1>arg2 && arg3>1 ], cost: 3
     61: f8 -> f16 : arg1'=1+arg1, [ arg1>arg2 && arg3==1 ], cost: 5
     20: f15 -> f16 : [], cost: 1
     64: f16 -> f23 : arg1'=-1+arg1, [ arg3==0 && -1+arg1<-2+arg2 ], cost: 4
     65: f16 -> f23 : arg1'=-1+arg1, [ arg3==0 && -1+arg1>-2+arg2 ], cost: 4
     66: f16 -> f24 : arg1'=-1+arg1, arg2'=-1+arg2, [ arg3==0 && -1+arg1==-2+arg2 ], cost: 6
     67: f16 -> f23 : [ arg3<0 && arg1<-2+arg2 ], cost: 3
     68: f16 -> f23 : [ arg3<0 && arg1>-2+arg2 ], cost: 3
     69: f16 -> f24 : arg2'=-1+arg2, [ arg3<0 && arg1==-2+arg2 ], cost: 5
     70: f16 -> f23 : [ arg3>0 && arg1<-2+arg2 ], cost: 3
     71: f16 -> f23 : [ arg3>0 && arg1>-2+arg2 ], cost: 3
     72: f16 -> f24 : arg2'=-1+arg2, [ arg3>0 && arg1==-2+arg2 ], cost: 5
     32: f23 -> f24 : [], cost: 1
     34: f24 -> f4 : [], cost: 1
     40: __init -> f4 : arg1'=arg1P_1, arg2'=20, arg3'=0, [], cost: 4

Eliminated locations (on tree-shaped paths):
   Start location: __init
     74: f4 -> f15 : arg3'=0, [ arg1==0 && arg1==arg2 ], cost: 8
     75: f4 -> f16 : arg1'=1+arg1, arg3'=1, [ arg1==0 && arg1<arg2 ], cost: 9
     76: f4 -> f15 : arg3'=0, [ arg1>0 && arg1==arg2 ], cost: 7
     77: f4 -> f15 : [ arg1>0 && arg1<arg2 && arg3<1 ], cost: 6
     78: f4 -> f15 : [ arg1>0 && arg1<arg2 && arg3>1 ], cost: 6
     79: f4 -> f16 : arg1'=1+arg1, [ arg1>0 && arg1<arg2 && arg3==1 ], cost: 8
     20: f15 -> f16 : [], cost: 1
     86: f16 -> f4 : arg1'=-1+arg1, arg2'=-1+arg2, [ arg3==0 && -1+arg1==-2+arg2 ], cost: 7
     87: f16 -> f4 : arg2'=-1+arg2, [ arg3<0 && arg1==-2+arg2 ], cost: 6
     88: f16 -> f4 : arg2'=-1+arg2, [ arg3>0 && arg1==-2+arg2 ], cost: 6
     89: f16 -> f4 : arg1'=-1+arg1, [ arg3==0 && -1+arg1<-2+arg2 ], cost: 6
     90: f16 -> f4 : arg1'=-1+arg1, [ arg3==0 && -1+arg1>-2+arg2 ], cost: 6
     91: f16 -> f4 : [ arg3<0 && arg1<-2+arg2 ], cost: 5
     92: f16 -> f4 : [ arg3<0 && arg1>-2+arg2 ], cost: 5
     93: f16 -> f4 : [ arg3>0 && arg1<-2+arg2 ], cost: 5
     94: f16 -> f4 : [ arg3>0 && arg1>-2+arg2 ], cost: 5
     40: __init -> f4 : arg1'=arg1P_1, arg2'=20, arg3'=0, [], cost: 4

Eliminated locations (on tree-shaped paths):
   Start location: __init
     99: f4 -> f4 : arg1'=1+arg1, arg2'=-1+arg2, arg3'=1, [ arg1==0 && 1+arg1==-2+arg2 ], cost: 15
    100: f4 -> f4 : arg1'=1+arg1, arg3'=1, [ arg1==0 && 1+arg1<-2+arg2 ], cost: 14
    101: f4 -> f4 : arg1'=1+arg1, arg3'=1, [ arg1==0 && arg1<arg2 && 1+arg1>-2+arg2 ], cost: 14
    102: f4 -> f4 : arg1'=1+arg1, arg2'=-1+arg2, [ arg1>0 && arg3==1 && 1+arg1==-2+arg2 ], cost: 14
    103: f4 -> f4 : arg1'=1+arg1, [ arg1>0 && arg3==1 && 1+arg1<-2+arg2 ], cost: 13
    104: f4 -> f4 : arg1'=1+arg1, [ arg1>0 && arg1<arg2 && arg3==1 && 1+arg1>-2+arg2 ], cost: 13
    105: f4 -> f4 : arg1'=-1+arg1, arg3'=0, [ arg1==0 && arg1==arg2 ], cost: 15
    106: f4 -> f4 : arg1'=-1+arg1, arg3'=0, [ arg1>0 && arg1==arg2 ], cost: 14
    107: f4 -> f4 : arg1'=-1+arg1, arg2'=-1+arg2, [ arg1>0 && arg3==0 && -1+arg1==-2+arg2 ], cost: 14
    108: f4 -> f4 : arg2'=-1+arg2, [ arg1>0 && arg3<0 && arg1==-2+arg2 ], cost: 13
    109: f4 -> f4 : arg1'=-1+arg1, [ arg1>0 && arg3==0 && -1+arg1<-2+arg2 ], cost: 13
    110: f4 -> f4 : [ arg1>0 && arg3<0 && arg1<-2+arg2 ], cost: 12
    111: f4 -> f4 : [ arg1>0 && arg1<arg2 && arg3<0 && arg1>-2+arg2 ], cost: 12
    112: f4 -> f4 : arg2'=-1+arg2, [ arg1>0 && arg3>1 && arg1==-2+arg2 ], cost: 13
    113: f4 -> f4 : [ arg1>0 && arg3>1 && arg1<-2+arg2 ], cost: 12
    114: f4 -> f4 : [ arg1>0 && arg1<arg2 && arg3>1 && arg1>-2+arg2 ], cost: 12
     40: __init -> f4 : arg1'=arg1P_1, arg2'=20, arg3'=0, [], cost: 4

Accelerating simple loops of location 3.
   Simplified some of the simple loops (and removed duplicate rules).
   Accelerating the following rules:
     99: f4 -> f4 : arg1'=1+arg1, arg2'=-1+arg2, arg3'=1, [ arg1==0 && 1+arg1==-2+arg2 ], cost: 15
    100: f4 -> f4 : arg1'=1+arg1, arg3'=1, [ arg1==0 && 1+arg1<-2+arg2 ], cost: 14
    101: f4 -> f4 : arg1'=1+arg1, arg3'=1, [ arg1==0 && arg1<arg2 && 1+arg1>-2+arg2 ], cost: 14
    102: f4 -> f4 : arg1'=1+arg1, arg2'=-1+arg2, [ arg1>0 && arg3==1 && 1+arg1==-2+arg2 ], cost: 14
    103: f4 -> f4 : arg1'=1+arg1, [ arg1>0 && arg3==1 && 1+arg1<-2+arg2 ], cost: 13
    104: f4 -> f4 : arg1'=1+arg1, [ arg1>0 && arg1<arg2 && arg3==1 && 1+arg1>-2+arg2 ], cost: 13
    105: f4 -> f4 : arg1'=-1+arg1, arg3'=0, [ arg1==0 && arg1==arg2 ], cost: 15
    106: f4 -> f4 : arg1'=-1+arg1, arg3'=0, [ arg1>0 && arg1==arg2 ], cost: 14
    107: f4 -> f4 : arg1'=-1+arg1, arg2'=-1+arg2, [ arg1>0 && arg3==0 && -1+arg1==-2+arg2 ], cost: 14
    108: f4 -> f4 : arg2'=-1+arg2, [ arg1>0 && arg3<0 && arg1==-2+arg2 ], cost: 13
    109: f4 -> f4 : arg1'=-1+arg1, [ arg1>0 && arg3==0 && -1+arg1<-2+arg2 ], cost: 13
    110: f4 -> f4 : [ arg1>0 && arg3<0 && arg1<-2+arg2 ], cost: 12
    111: f4 -> f4 : [ arg1>0 && 1-arg2+arg1==0 && arg3<0 ], cost: 12
    112: f4 -> f4 : arg2'=-1+arg2, [ arg1>0 && arg3>1 && arg1==-2+arg2 ], cost: 13
    113: f4 -> f4 : [ arg1>0 && arg3>1 && arg1<-2+arg2 ], cost: 12
    114: f4 -> f4 : [ arg1>0 && 1-arg2+arg1==0 && arg3>1 ], cost: 12

   Failed to prove monotonicity of the guard of rule 99.
   Failed to prove monotonicity of the guard of rule 100.
   Failed to prove monotonicity of the guard of rule 101.
   Failed to prove monotonicity of the guard of rule 102.
   Accelerated rule 103 with backward acceleration, yielding the new rule 115.
   Accelerated rule 104 with backward acceleration, yielding the new rule 116.
   Failed to prove monotonicity of the guard of rule 105.
   Failed to prove monotonicity of the guard of rule 106.
   Accelerated rule 107 with backward acceleration, yielding the new rule 117.
   Failed to prove monotonicity of the guard of rule 108.
   Accelerated rule 109 with backward acceleration, yielding the new rule 118.
   Accelerated rule 110 with non-termination, yielding the new rule 119.
   Accelerated rule 111 with non-termination, yielding the new rule 120.
   Failed to prove monotonicity of the guard of rule 112.
   Accelerated rule 113 with non-termination, yielding the new rule 121.
   Accelerated rule 114 with non-termination, yielding the new rule 122.
[accelerate] Nesting with 12 inner and 12 outer candidates
   Nested simple loops 106 (outer loop) and 101 (inner loop) with Rule(3 | arg1==0, 1+arg1==arg2, | NONTERM || 27 | ), resulting in the new rules: 123, 124.
   Nested simple loops 101 (outer loop) and 106 (inner loop) with Rule(3 | arg1==arg2, -1+arg1==0, | NONTERM || 27 | ), resulting in the new rules: 125, 126.
   Removing the simple loops: 101 103 104 106 107 109 110 111 113 114.
   Also removing duplicate rules: 123 124.

Accelerated all simple loops using metering functions (where possible):
   Start location: __init
     99: f4 -> f4 : arg1'=1+arg1, arg2'=-1+arg2, arg3'=1, [ arg1==0 && 1+arg1==-2+arg2 ], cost: 15
    100: f4 -> f4 : arg1'=1+arg1, arg3'=1, [ arg1==0 && 1+arg1<-2+arg2 ], cost: 14
    102: f4 -> f4 : arg1'=1+arg1, arg2'=-1+arg2, [ arg1>0 && arg3==1 && 1+arg1==-2+arg2 ], cost: 14
    105: f4 -> f4 : arg1'=-1+arg1, arg3'=0, [ arg1==0 && arg1==arg2 ], cost: 15
    108: f4 -> f4 : arg2'=-1+arg2, [ arg1>0 && arg3<0 && arg1==-2+arg2 ], cost: 13
    112: f4 -> f4 : arg2'=-1+arg2, [ arg1>0 && arg3>1 && arg1==-2+arg2 ], cost: 13
    115: f4 -> f4 : arg1'=-3+arg2, [ arg1>0 && arg3==1 && -3+arg2-arg1>=0 ], cost: -39+13*arg2-13*arg1
    116: f4 -> f4 : arg1'=arg2, [ arg1>0 && arg3==1 && 1+arg1>-2+arg2 && arg2-arg1>=0 ], cost: 13*arg2-13*arg1
    117: f4 -> f4 : arg1'=0, arg2'=arg2-arg1, [ arg3==0 && -1+arg1==-2+arg2 && arg1>=0 ], cost: 14*arg1
    118: f4 -> f4 : arg1'=0, [ arg3==0 && -1+arg1<-2+arg2 && arg1>=0 ], cost: 13*arg1
    119: f4 -> [27] : [ arg1>0 && arg3<0 && arg1<-2+arg2 ], cost: NONTERM
    120: f4 -> [27] : [ arg1>0 && 1-arg2+arg1==0 && arg3<0 ], cost: NONTERM
    121: f4 -> [27] : [ arg1>0 && arg3>1 && arg1<-2+arg2 ], cost: NONTERM
    122: f4 -> [27] : [ arg1>0 && 1-arg2+arg1==0 && arg3>1 ], cost: NONTERM
    125: f4 -> [27] : [ arg1==arg2 && -1+arg1==0 ], cost: NONTERM
    126: f4 -> [27] : [ arg1==0 && 1+arg1==arg2 ], cost: NONTERM
     40: __init -> f4 : arg1'=arg1P_1, arg2'=20, arg3'=0, [], cost: 4

Chained accelerated rules (with incoming rules):
   Start location: __init
     40: __init -> f4 : arg1'=arg1P_1, arg2'=20, arg3'=0, [], cost: 4
    127: __init -> f4 : arg1'=1, arg2'=20, arg3'=1, [], cost: 18
    128: __init -> f4 : arg1'=0, arg2'=1, arg3'=0, [], cost: 270
    129: __init -> f4 : arg1'=0, arg2'=20, arg3'=0, [ -1+arg1P_1<18 && arg1P_1>=0 ], cost: 4+13*arg1P_1

Removed unreachable locations (and leaf rules with constant cost):
   Start location: __init
    129: __init -> f4 : arg1'=0, arg2'=20, arg3'=0, [ -1+arg1P_1<18 && arg1P_1>=0 ], cost: 4+13*arg1P_1

### Computing asymptotic complexity ###

Fully simplified ITS problem
   Start location: __init
    129: __init -> f4 : arg1'=0, arg2'=20, arg3'=0, [ -1+arg1P_1<18 && arg1P_1>=0 ], cost: 4+13*arg1P_1

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