NO

### 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 && arg1==arg2P_2 ], cost: 1
     38: f3 -> f4 : arg1'=arg1P_39, arg2'=arg2P_39, [ arg1>0 && arg1==arg1P_39 && arg2==arg2P_39 ], cost: 1
     40: f3 -> f34 : arg1'=arg1P_41, arg2'=arg2P_41, [ arg1<=0 && arg1==arg1P_41 && arg2==arg2P_41 ], cost: 1
      2: f5 -> f8 : arg1'=arg1P_3, arg2'=arg2P_3, [ arg1P_3==1+arg1 && arg2==arg2P_3 ], cost: 1
     11: f8 -> f9 : arg1'=arg1P_12, arg2'=arg2P_12, [ arg2<5 && arg1==arg1P_12 && arg2==arg2P_12 ], cost: 1
     12: f8 -> f10 : arg1'=arg1P_13, arg2'=arg2P_13, [ arg2>=5 && arg1==arg1P_13 && arg2==arg2P_13 ], cost: 1
      3: f9 -> f12 : arg1'=arg1P_4, arg2'=arg2P_4, [ arg2P_4==1+arg2 && arg1==arg1P_4 ], cost: 1
      6: f12 -> f13 : arg1'=arg1P_7, arg2'=arg2P_7, [ -arg2+arg1>2 && arg1==arg1P_7 && arg2==arg2P_7 ], cost: 1
      7: f12 -> f14 : arg1'=arg1P_8, arg2'=arg2P_8, [ -arg2+arg1<=2 && arg1==arg1P_8 && arg2==arg2P_8 ], cost: 1
      4: f13 -> f16 : arg1'=arg1P_5, arg2'=arg2P_5, [ arg1P_5==1+arg1 && arg2==arg2P_5 ], cost: 1
      8: f16 -> f15 : arg1'=arg1P_9, arg2'=arg2P_9, [ arg1==arg1P_9 && arg2==arg2P_9 ], cost: 1
      5: f14 -> f17 : arg1'=arg1P_6, arg2'=arg2P_6, [ arg2P_6==1+arg2 && arg1==arg1P_6 ], cost: 1
      9: f17 -> f15 : arg1'=arg1P_10, arg2'=arg2P_10, [ arg1==arg1P_10 && arg2==arg2P_10 ], cost: 1
     13: f15 -> f11 : arg1'=arg1P_14, arg2'=arg2P_14, [ arg1==arg1P_14 && arg2==arg2P_14 ], cost: 1
     10: f10 -> f18 : arg1'=arg1P_11, arg2'=arg2P_11, [ arg2P_11==-1+arg2 && arg1==arg1P_11 ], cost: 1
     14: f18 -> f11 : arg1'=arg1P_15, arg2'=arg2P_15, [ arg1==arg1P_15 && arg2==arg2P_15 ], cost: 1
     36: f11 -> f7 : arg1'=arg1P_37, arg2'=arg2P_37, [ arg1==arg1P_37 && arg2==arg2P_37 ], cost: 1
     15: f19 -> f22 : arg1'=arg1P_16, arg2'=arg2P_16, [ arg1P_16==-1+arg1 && arg2==arg2P_16 ], cost: 1
     18: f22 -> f23 : arg1'=arg1P_19, arg2'=arg2P_19, [ arg2<-1 && arg1==arg1P_19 && arg2==arg2P_19 ], cost: 1
     19: f22 -> f24 : arg1'=arg1P_20, arg2'=arg2P_20, [ arg2>=-1 && arg1==arg1P_20 && arg2==arg2P_20 ], cost: 1
     16: f23 -> f26 : arg1'=arg1P_17, arg2'=arg2P_17, [ arg2P_17==1+arg2 && arg1==arg1P_17 ], cost: 1
     20: f26 -> f25 : arg1'=arg1P_21, arg2'=arg2P_21, [ arg1==arg1P_21 && arg2==arg2P_21 ], cost: 1
     17: f24 -> f27 : arg1'=arg1P_18, arg2'=arg2P_18, [ arg1P_18==1+arg1 && arg2==arg2P_18 ], cost: 1
     21: f27 -> f25 : arg1'=arg1P_22, arg2'=arg2P_22, [ arg1==arg1P_22 && arg2==arg2P_22 ], cost: 1
     32: f25 -> f21 : arg1'=arg1P_33, arg2'=arg2P_33, [ arg1==arg1P_33 && arg2==arg2P_33 ], cost: 1
     22: f20 -> f28 : arg1'=arg1P_23, arg2'=arg2P_23, [ arg1P_23==1+arg1 && arg2==arg2P_23 ], cost: 1
     25: f28 -> f29 : arg1'=arg1P_26, arg2'=arg2P_26, [ 2*arg2>arg1 && arg1==arg1P_26 && arg2==arg2P_26 ], cost: 1
     26: f28 -> f30 : arg1'=arg1P_27, arg2'=arg2P_27, [ 2*arg2<=arg1 && arg1==arg1P_27 && arg2==arg2P_27 ], cost: 1
     23: f29 -> f32 : arg1'=arg1P_24, arg2'=arg2P_24, [ arg2P_24==-1+arg2 && arg1==arg1P_24 ], cost: 1
     27: f32 -> f31 : arg1'=arg1P_28, arg2'=arg2P_28, [ arg1==arg1P_28 && arg2==arg2P_28 ], cost: 1
     24: f30 -> f33 : arg1'=arg1P_25, arg2'=arg2P_25, [ arg2P_25==1+arg2 && arg1==arg1P_25 ], cost: 1
     28: f33 -> f31 : arg1'=arg1P_29, arg2'=arg2P_29, [ arg1==arg1P_29 && arg2==arg2P_29 ], cost: 1
     33: f31 -> f21 : arg1'=arg1P_34, arg2'=arg2P_34, [ arg1==arg1P_34 && arg2==arg2P_34 ], cost: 1
     29: f6 -> f19 : arg1'=arg1P_30, arg2'=arg2P_30, [ arg1>0 && arg2<0 && arg1==arg1P_30 && arg2==arg2P_30 ], cost: 1
     30: f6 -> f20 : arg1'=arg1P_31, arg2'=arg2P_31, [ arg1<=0 && arg1==arg1P_31 && arg2==arg2P_31 ], cost: 1
     31: f6 -> f20 : arg1'=arg1P_32, arg2'=arg2P_32, [ arg2>=0 && arg1==arg1P_32 && arg2==arg2P_32 ], cost: 1
     37: f21 -> f7 : arg1'=arg1P_38, arg2'=arg2P_38, [ arg1==arg1P_38 && arg2==arg2P_38 ], cost: 1
     34: f4 -> f5 : arg1'=arg1P_35, arg2'=arg2P_35, [ arg1>=arg2 && arg1==arg1P_35 && arg2==arg2P_35 ], cost: 1
     35: f4 -> f6 : arg1'=arg1P_36, arg2'=arg2P_36, [ arg1<arg2 && arg1==arg1P_36 && arg2==arg2P_36 ], cost: 1
     39: f7 -> f3 : arg1'=arg1P_40, arg2'=arg2P_40, [ arg1==arg1P_40 && arg2==arg2P_40 ], cost: 1
     41: __init -> f1 : arg1'=arg1P_42, arg2'=arg2P_42, [], cost: 1

Checking for constant complexity:
   The following rule is satisfiable with cost >= 1, yielding constant complexity:
     41: __init -> f1 : arg1'=arg1P_42, arg2'=arg2P_42, [], 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 && arg1==arg2P_2 ], cost: 1
     38: f3 -> f4 : arg1'=arg1P_39, arg2'=arg2P_39, [ arg1>0 && arg1==arg1P_39 && arg2==arg2P_39 ], cost: 1
      2: f5 -> f8 : arg1'=arg1P_3, arg2'=arg2P_3, [ arg1P_3==1+arg1 && arg2==arg2P_3 ], cost: 1
     11: f8 -> f9 : arg1'=arg1P_12, arg2'=arg2P_12, [ arg2<5 && arg1==arg1P_12 && arg2==arg2P_12 ], cost: 1
     12: f8 -> f10 : arg1'=arg1P_13, arg2'=arg2P_13, [ arg2>=5 && arg1==arg1P_13 && arg2==arg2P_13 ], cost: 1
      3: f9 -> f12 : arg1'=arg1P_4, arg2'=arg2P_4, [ arg2P_4==1+arg2 && arg1==arg1P_4 ], cost: 1
      6: f12 -> f13 : arg1'=arg1P_7, arg2'=arg2P_7, [ -arg2+arg1>2 && arg1==arg1P_7 && arg2==arg2P_7 ], cost: 1
      7: f12 -> f14 : arg1'=arg1P_8, arg2'=arg2P_8, [ -arg2+arg1<=2 && arg1==arg1P_8 && arg2==arg2P_8 ], cost: 1
      4: f13 -> f16 : arg1'=arg1P_5, arg2'=arg2P_5, [ arg1P_5==1+arg1 && arg2==arg2P_5 ], cost: 1
      8: f16 -> f15 : arg1'=arg1P_9, arg2'=arg2P_9, [ arg1==arg1P_9 && arg2==arg2P_9 ], cost: 1
      5: f14 -> f17 : arg1'=arg1P_6, arg2'=arg2P_6, [ arg2P_6==1+arg2 && arg1==arg1P_6 ], cost: 1
      9: f17 -> f15 : arg1'=arg1P_10, arg2'=arg2P_10, [ arg1==arg1P_10 && arg2==arg2P_10 ], cost: 1
     13: f15 -> f11 : arg1'=arg1P_14, arg2'=arg2P_14, [ arg1==arg1P_14 && arg2==arg2P_14 ], cost: 1
     10: f10 -> f18 : arg1'=arg1P_11, arg2'=arg2P_11, [ arg2P_11==-1+arg2 && arg1==arg1P_11 ], cost: 1
     14: f18 -> f11 : arg1'=arg1P_15, arg2'=arg2P_15, [ arg1==arg1P_15 && arg2==arg2P_15 ], cost: 1
     36: f11 -> f7 : arg1'=arg1P_37, arg2'=arg2P_37, [ arg1==arg1P_37 && arg2==arg2P_37 ], cost: 1
     15: f19 -> f22 : arg1'=arg1P_16, arg2'=arg2P_16, [ arg1P_16==-1+arg1 && arg2==arg2P_16 ], cost: 1
     18: f22 -> f23 : arg1'=arg1P_19, arg2'=arg2P_19, [ arg2<-1 && arg1==arg1P_19 && arg2==arg2P_19 ], cost: 1
     19: f22 -> f24 : arg1'=arg1P_20, arg2'=arg2P_20, [ arg2>=-1 && arg1==arg1P_20 && arg2==arg2P_20 ], cost: 1
     16: f23 -> f26 : arg1'=arg1P_17, arg2'=arg2P_17, [ arg2P_17==1+arg2 && arg1==arg1P_17 ], cost: 1
     20: f26 -> f25 : arg1'=arg1P_21, arg2'=arg2P_21, [ arg1==arg1P_21 && arg2==arg2P_21 ], cost: 1
     17: f24 -> f27 : arg1'=arg1P_18, arg2'=arg2P_18, [ arg1P_18==1+arg1 && arg2==arg2P_18 ], cost: 1
     21: f27 -> f25 : arg1'=arg1P_22, arg2'=arg2P_22, [ arg1==arg1P_22 && arg2==arg2P_22 ], cost: 1
     32: f25 -> f21 : arg1'=arg1P_33, arg2'=arg2P_33, [ arg1==arg1P_33 && arg2==arg2P_33 ], cost: 1
     22: f20 -> f28 : arg1'=arg1P_23, arg2'=arg2P_23, [ arg1P_23==1+arg1 && arg2==arg2P_23 ], cost: 1
     25: f28 -> f29 : arg1'=arg1P_26, arg2'=arg2P_26, [ 2*arg2>arg1 && arg1==arg1P_26 && arg2==arg2P_26 ], cost: 1
     26: f28 -> f30 : arg1'=arg1P_27, arg2'=arg2P_27, [ 2*arg2<=arg1 && arg1==arg1P_27 && arg2==arg2P_27 ], cost: 1
     23: f29 -> f32 : arg1'=arg1P_24, arg2'=arg2P_24, [ arg2P_24==-1+arg2 && arg1==arg1P_24 ], cost: 1
     27: f32 -> f31 : arg1'=arg1P_28, arg2'=arg2P_28, [ arg1==arg1P_28 && arg2==arg2P_28 ], cost: 1
     24: f30 -> f33 : arg1'=arg1P_25, arg2'=arg2P_25, [ arg2P_25==1+arg2 && arg1==arg1P_25 ], cost: 1
     28: f33 -> f31 : arg1'=arg1P_29, arg2'=arg2P_29, [ arg1==arg1P_29 && arg2==arg2P_29 ], cost: 1
     33: f31 -> f21 : arg1'=arg1P_34, arg2'=arg2P_34, [ arg1==arg1P_34 && arg2==arg2P_34 ], cost: 1
     29: f6 -> f19 : arg1'=arg1P_30, arg2'=arg2P_30, [ arg1>0 && arg2<0 && arg1==arg1P_30 && arg2==arg2P_30 ], cost: 1
     30: f6 -> f20 : arg1'=arg1P_31, arg2'=arg2P_31, [ arg1<=0 && arg1==arg1P_31 && arg2==arg2P_31 ], cost: 1
     31: f6 -> f20 : arg1'=arg1P_32, arg2'=arg2P_32, [ arg2>=0 && arg1==arg1P_32 && arg2==arg2P_32 ], cost: 1
     37: f21 -> f7 : arg1'=arg1P_38, arg2'=arg2P_38, [ arg1==arg1P_38 && arg2==arg2P_38 ], cost: 1
     34: f4 -> f5 : arg1'=arg1P_35, arg2'=arg2P_35, [ arg1>=arg2 && arg1==arg1P_35 && arg2==arg2P_35 ], cost: 1
     35: f4 -> f6 : arg1'=arg1P_36, arg2'=arg2P_36, [ arg1<arg2 && arg1==arg1P_36 && arg2==arg2P_36 ], cost: 1
     39: f7 -> f3 : arg1'=arg1P_40, arg2'=arg2P_40, [ arg1==arg1P_40 && arg2==arg2P_40 ], cost: 1
     41: __init -> f1 : arg1'=arg1P_42, arg2'=arg2P_42, [], cost: 1

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

### Simplification by acceleration and chaining ###

Eliminated locations (on linear paths):
   Start location: __init
     38: f3 -> f4 : [ arg1>0 ], cost: 1
     45: f8 -> f12 : arg2'=1+arg2, [ arg2<5 ], cost: 2
     47: f8 -> f11 : arg2'=-1+arg2, [ arg2>=5 ], cost: 3
     50: f12 -> f15 : arg1'=1+arg1, [ -arg2+arg1>2 ], cost: 3
     51: f12 -> f15 : arg2'=1+arg2, [ -arg2+arg1<=2 ], cost: 3
     13: f15 -> f11 : [], cost: 1
     36: f11 -> f7 : [], cost: 1
     55: f22 -> f25 : arg2'=1+arg2, [ arg2<-1 ], cost: 3
     56: f22 -> f25 : arg1'=1+arg1, [ arg2>=-1 ], cost: 3
     32: f25 -> f21 : [], cost: 1
     22: f20 -> f28 : arg1'=1+arg1, [], cost: 1
     59: f28 -> f31 : arg2'=-1+arg2, [ 2*arg2>arg1 ], cost: 3
     60: f28 -> f31 : arg2'=1+arg2, [ 2*arg2<=arg1 ], cost: 3
     33: f31 -> f21 : [], cost: 1
     30: f6 -> f20 : [ arg1<=0 ], cost: 1
     31: f6 -> f20 : [ arg2>=0 ], cost: 1
     52: f6 -> f22 : arg1'=-1+arg1, [ arg1>0 && arg2<0 ], cost: 2
     37: f21 -> f7 : [], cost: 1
     35: f4 -> f6 : [ arg1<arg2 ], cost: 1
     44: f4 -> f8 : arg1'=1+arg1, [ arg1>=arg2 ], cost: 2
     39: f7 -> f3 : [], cost: 1
     43: __init -> f3 : arg1'=arg1P_1, arg2'=arg1P_1, [], cost: 3

Eliminated locations (on tree-shaped paths):
   Start location: __init
     61: f3 -> f6 : [ arg1>0 && arg1<arg2 ], cost: 2
     62: f3 -> f8 : arg1'=1+arg1, [ arg1>0 && arg1>=arg2 ], cost: 3
     47: f8 -> f11 : arg2'=-1+arg2, [ arg2>=5 ], cost: 3
     63: f8 -> f15 : arg1'=1+arg1, arg2'=1+arg2, [ arg2<5 && -1-arg2+arg1>2 ], cost: 5
     64: f8 -> f15 : arg2'=2+arg2, [ arg2<5 && -1-arg2+arg1<=2 ], cost: 5
     13: f15 -> f11 : [], cost: 1
     36: f11 -> f7 : [], cost: 1
     32: f25 -> f21 : [], cost: 1
     69: f28 -> f21 : arg2'=-1+arg2, [ 2*arg2>arg1 ], cost: 4
     70: f28 -> f21 : arg2'=1+arg2, [ 2*arg2<=arg1 ], cost: 4
     65: f6 -> f25 : arg1'=-1+arg1, arg2'=1+arg2, [ arg1>0 && arg2<-1 ], cost: 5
     66: f6 -> f25 : arg1'=arg1, [ arg1>0 && arg2<0 && arg2>=-1 ], cost: 5
     67: f6 -> f28 : arg1'=1+arg1, [ arg1<=0 ], cost: 2
     68: f6 -> f28 : arg1'=1+arg1, [ arg2>=0 ], cost: 2
     37: f21 -> f7 : [], cost: 1
     39: f7 -> f3 : [], cost: 1
     43: __init -> f3 : arg1'=arg1P_1, arg2'=arg1P_1, [], cost: 3

Eliminated locations (on tree-shaped paths):
   Start location: __init
     71: f3 -> f11 : arg1'=1+arg1, arg2'=-1+arg2, [ arg1>0 && arg1>=arg2 && arg2>=5 ], cost: 6
     72: f3 -> f15 : arg1'=2+arg1, arg2'=1+arg2, [ arg1>0 && arg2<5 && -arg2+arg1>2 ], cost: 8
     73: f3 -> f15 : arg1'=1+arg1, arg2'=2+arg2, [ arg1>0 && arg1>=arg2 && arg2<5 && -arg2+arg1<=2 ], cost: 8
     74: f3 -> f28 : arg1'=1+arg1, [ arg1>0 && arg1<arg2 && arg2>=0 ], cost: 4
     13: f15 -> f11 : [], cost: 1
     36: f11 -> f7 : [], cost: 1
     32: f25 -> f21 : [], cost: 1
     69: f28 -> f21 : arg2'=-1+arg2, [ 2*arg2>arg1 ], cost: 4
     70: f28 -> f21 : arg2'=1+arg2, [ 2*arg2<=arg1 ], cost: 4
     37: f21 -> f7 : [], cost: 1
     39: f7 -> f3 : [], cost: 1
     43: __init -> f3 : arg1'=arg1P_1, arg2'=arg1P_1, [], cost: 3

Removed unreachable locations (and leaf rules with constant cost):
   Start location: __init
     71: f3 -> f11 : arg1'=1+arg1, arg2'=-1+arg2, [ arg1>0 && arg1>=arg2 && arg2>=5 ], cost: 6
     72: f3 -> f15 : arg1'=2+arg1, arg2'=1+arg2, [ arg1>0 && arg2<5 && -arg2+arg1>2 ], cost: 8
     73: f3 -> f15 : arg1'=1+arg1, arg2'=2+arg2, [ arg1>0 && arg1>=arg2 && arg2<5 && -arg2+arg1<=2 ], cost: 8
     74: f3 -> f28 : arg1'=1+arg1, [ arg1>0 && arg1<arg2 && arg2>=0 ], cost: 4
     13: f15 -> f11 : [], cost: 1
     36: f11 -> f7 : [], cost: 1
     69: f28 -> f21 : arg2'=-1+arg2, [ 2*arg2>arg1 ], cost: 4
     70: f28 -> f21 : arg2'=1+arg2, [ 2*arg2<=arg1 ], cost: 4
     37: f21 -> f7 : [], cost: 1
     39: f7 -> f3 : [], cost: 1
     43: __init -> f3 : arg1'=arg1P_1, arg2'=arg1P_1, [], cost: 3

Eliminated locations (on tree-shaped paths):
   Start location: __init
     77: f3 -> f7 : arg1'=1+arg1, arg2'=-1+arg2, [ arg1>0 && arg1>=arg2 && arg2>=5 ], cost: 7
     78: f3 -> f7 : arg1'=2+arg1, arg2'=1+arg2, [ arg1>0 && arg2<5 && -arg2+arg1>2 ], cost: 10
     79: f3 -> f7 : arg1'=1+arg1, arg2'=2+arg2, [ arg1>0 && arg1>=arg2 && arg2<5 && -arg2+arg1<=2 ], cost: 10
     80: f3 -> f21 : arg1'=1+arg1, arg2'=-1+arg2, [ arg1>0 && arg1<arg2 && arg2>=0 && 2*arg2>1+arg1 ], cost: 8
     37: f21 -> f7 : [], cost: 1
     39: f7 -> f3 : [], cost: 1
     43: __init -> f3 : arg1'=arg1P_1, arg2'=arg1P_1, [], cost: 3

Eliminated locations (on linear paths):
   Start location: __init
     77: f3 -> f7 : arg1'=1+arg1, arg2'=-1+arg2, [ arg1>0 && arg1>=arg2 && arg2>=5 ], cost: 7
     78: f3 -> f7 : arg1'=2+arg1, arg2'=1+arg2, [ arg1>0 && arg2<5 && -arg2+arg1>2 ], cost: 10
     79: f3 -> f7 : arg1'=1+arg1, arg2'=2+arg2, [ arg1>0 && arg1>=arg2 && arg2<5 && -arg2+arg1<=2 ], cost: 10
     81: f3 -> f7 : arg1'=1+arg1, arg2'=-1+arg2, [ arg1>0 && arg1<arg2 && arg2>=0 && 2*arg2>1+arg1 ], cost: 9
     39: f7 -> f3 : [], cost: 1
     43: __init -> f3 : arg1'=arg1P_1, arg2'=arg1P_1, [], cost: 3

Eliminated locations (on tree-shaped paths):
   Start location: __init
     82: f3 -> f3 : arg1'=1+arg1, arg2'=-1+arg2, [ arg1>0 && arg1>=arg2 && arg2>=5 ], cost: 8
     83: f3 -> f3 : arg1'=2+arg1, arg2'=1+arg2, [ arg1>0 && arg2<5 && -arg2+arg1>2 ], cost: 11
     84: f3 -> f3 : arg1'=1+arg1, arg2'=2+arg2, [ arg1>0 && arg1>=arg2 && arg2<5 && -arg2+arg1<=2 ], cost: 11
     85: f3 -> f3 : arg1'=1+arg1, arg2'=-1+arg2, [ arg1>0 && arg1<arg2 && arg2>=0 && 2*arg2>1+arg1 ], cost: 10
     43: __init -> f3 : arg1'=arg1P_1, arg2'=arg1P_1, [], cost: 3

Accelerating simple loops of location 2.
   Accelerating the following rules:
     82: f3 -> f3 : arg1'=1+arg1, arg2'=-1+arg2, [ arg1>0 && arg1>=arg2 && arg2>=5 ], cost: 8
     83: f3 -> f3 : arg1'=2+arg1, arg2'=1+arg2, [ arg1>0 && arg2<5 && -arg2+arg1>2 ], cost: 11
     84: f3 -> f3 : arg1'=1+arg1, arg2'=2+arg2, [ arg1>0 && arg1>=arg2 && arg2<5 && -arg2+arg1<=2 ], cost: 11
     85: f3 -> f3 : arg1'=1+arg1, arg2'=-1+arg2, [ arg1>0 && arg1<arg2 && arg2>=0 && 2*arg2>1+arg1 ], cost: 10

   Accelerated rule 82 with backward acceleration, yielding the new rule 86.
   Accelerated rule 83 with backward acceleration, yielding the new rule 87.
   Accelerated rule 84 with backward acceleration, yielding the new rule 88.
   Accelerated rule 85 with backward acceleration, yielding the new rule 89.
[accelerate] Nesting with 4 inner and 4 outer candidates
   Nested simple loops 83 (outer loop) and 86 (inner loop) with Rule(2 | arg1>0, arg1>=arg2, -4+arg2>=0, -8+arg2+arg1>2, | NONTERM || 35 | ), resulting in the new rules: 90, 91.
   Nested simple loops 82 (outer loop) and 87 (inner loop) with Rule(2 | arg1>0, -arg2+arg1>2, 5-arg2>=0, 10-2*arg2+arg1>=5, | NONTERM || 35 | ), resulting in the new rules: 92, 93.
   Removing the simple loops: 82 83 84 85.

Accelerated all simple loops using metering functions (where possible):
   Start location: __init
     86: f3 -> f3 : arg1'=-4+arg2+arg1, arg2'=4, [ arg1>0 && arg1>=arg2 && -4+arg2>=0 ], cost: -32+8*arg2
     87: f3 -> f3 : arg1'=10-2*arg2+arg1, arg2'=5, [ arg1>0 && -arg2+arg1>2 && 5-arg2>=0 ], cost: 55-11*arg2
     88: f3 -> f3 : arg1'=k_2+arg1, arg2'=arg2+2*k_2, [ arg1>0 && -arg2+arg1<=2 && k_2>=0 && -1+k_2+arg1>=-2+arg2+2*k_2 && -2+arg2+2*k_2<5 ], cost: 11*k_2
     89: f3 -> f3 : arg1'=k_3+arg1, arg2'=arg2-k_3, [ arg1>0 && arg2>=0 && k_3>=0 && -1+k_3+arg1<1+arg2-k_3 && 2+2*arg2-2*k_3>k_3+arg1 ], cost: 10*k_3
     90: f3 -> [35] : [ arg1>0 && arg1>=arg2 && -4+arg2>=0 && -8+arg2+arg1>2 ], cost: NONTERM
     91: f3 -> [35] : [ arg1>0 && arg2<5 && -arg2+arg1>2 && -3+arg2>=0 && -5+arg2+arg1>2 ], cost: NONTERM
     92: f3 -> [35] : [ arg1>0 && -arg2+arg1>2 && 5-arg2>=0 && 10-2*arg2+arg1>=5 ], cost: NONTERM
     93: f3 -> [35] : [ arg1>0 && arg2>=5 && 2-arg2+arg1>2 && 6-arg2>=0 && 13-2*arg2+arg1>=5 ], cost: NONTERM
     43: __init -> f3 : arg1'=arg1P_1, arg2'=arg1P_1, [], cost: 3

Chained accelerated rules (with incoming rules):
   Start location: __init
     43: __init -> f3 : arg1'=arg1P_1, arg2'=arg1P_1, [], cost: 3
     94: __init -> f3 : arg1'=-4+2*arg1P_1, arg2'=4, [ -4+arg1P_1>=0 ], cost: -29+8*arg1P_1
     95: __init -> f3 : arg1'=arg1P_1+k_2, arg2'=arg1P_1+2*k_2, [ arg1P_1>0 && k_2>=0 && -1+arg1P_1+k_2>=-2+arg1P_1+2*k_2 && -2+arg1P_1+2*k_2<5 ], cost: 3+11*k_2
     96: __init -> f3 : arg1'=arg1P_1+k_3, arg2'=arg1P_1-k_3, [ arg1P_1>0 && k_3>=0 && -1+arg1P_1+k_3<1+arg1P_1-k_3 && 2+2*arg1P_1-2*k_3>arg1P_1+k_3 ], cost: 3+10*k_3
     97: __init -> [35] : [ -4+arg1P_1>=0 && -8+2*arg1P_1>2 ], cost: NONTERM

Removed unreachable locations (and leaf rules with constant cost):
   Start location: __init
     94: __init -> f3 : arg1'=-4+2*arg1P_1, arg2'=4, [ -4+arg1P_1>=0 ], cost: -29+8*arg1P_1
     95: __init -> f3 : arg1'=arg1P_1+k_2, arg2'=arg1P_1+2*k_2, [ arg1P_1>0 && k_2>=0 && -1+arg1P_1+k_2>=-2+arg1P_1+2*k_2 && -2+arg1P_1+2*k_2<5 ], cost: 3+11*k_2
     96: __init -> f3 : arg1'=arg1P_1+k_3, arg2'=arg1P_1-k_3, [ arg1P_1>0 && k_3>=0 && -1+arg1P_1+k_3<1+arg1P_1-k_3 && 2+2*arg1P_1-2*k_3>arg1P_1+k_3 ], cost: 3+10*k_3
     97: __init -> [35] : [ -4+arg1P_1>=0 && -8+2*arg1P_1>2 ], cost: NONTERM

### Computing asymptotic complexity ###

Fully simplified ITS problem
   Start location: __init
     94: __init -> f3 : arg1'=-4+2*arg1P_1, arg2'=4, [ -4+arg1P_1>=0 ], cost: -29+8*arg1P_1
     95: __init -> f3 : arg1'=arg1P_1+k_2, arg2'=arg1P_1+2*k_2, [ arg1P_1>0 && k_2>=0 && -1+arg1P_1+k_2>=-2+arg1P_1+2*k_2 && -2+arg1P_1+2*k_2<5 ], cost: 3+11*k_2
     96: __init -> f3 : arg1'=arg1P_1+k_3, arg2'=arg1P_1-k_3, [ arg1P_1>0 && k_3>=0 && -1+arg1P_1+k_3<1+arg1P_1-k_3 && 2+2*arg1P_1-2*k_3>arg1P_1+k_3 ], cost: 3+10*k_3
     97: __init -> [35] : [ -4+arg1P_1>=0 && -8+2*arg1P_1>2 ], cost: NONTERM

Computing asymptotic complexity for rule 97
   Simplified the guard:
     97: __init -> [35] : [ -8+2*arg1P_1>2 ], cost: NONTERM
   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:  [ -8+2*arg1P_1>2 ]

NO