Trying to load file: main.koat

Initial Control flow graph problem:
  Start location: f0
      0: f0 -> f18 : A'=3, B'=3, C'=0, D'=3, [], cost: 1
      3: f18 -> f25 : E'=D, F'=D, G'=-3, H'=4, Q'=0, [], cost: 1
     13: f10 -> f18 : D'=B, [ C>=1+A ], cost: 1
      1: f10 -> f10 : [ 0>=A && A>=C ], cost: 1
      2: f10 -> f10 : B'=B+A, [ A>=1 && A>=C ], cost: 1
      4: f25 -> f25 : [ 0>=G && G>=Q ], cost: 1
      5: f25 -> f25 : H'=H+G, [ G>=1 && G>=Q ], cost: 1
     12: f25 -> f33 : K'=H, [ Q>=1+G ], cost: 1
      6: f33 -> f40 : J'=K, L'=K, M'=3, N'=-6, O'=0, [], cost: 1
      7: f40 -> f40 : [ 0>=M && M>=O ], cost: 1
      8: f40 -> f40 : N'=N+M, [ M>=1 && M>=O ], cost: 1
     11: f40 -> f48 : Q_1'=N, [ O>=1+M ], cost: 1
      9: f48 -> f52 : P'=Q_1, R'=Q_1, [ 4>=F ], cost: 1
     10: f48 -> f52 : P'=Q_1, R'=Q_1, [ F>=5 ], cost: 1


Simplified the transitions:
  Start location: f0
      0: f0 -> f18 : A'=3, B'=3, C'=0, D'=3, [], cost: 1
      3: f18 -> f25 : E'=D, F'=D, G'=-3, H'=4, Q'=0, [], cost: 1
      4: f25 -> f25 : [ 0>=G && G>=Q ], cost: 1
      5: f25 -> f25 : H'=H+G, [ G>=1 && G>=Q ], cost: 1
     12: f25 -> f33 : K'=H, [ Q>=1+G ], cost: 1
      6: f33 -> f40 : J'=K, L'=K, M'=3, N'=-6, O'=0, [], cost: 1
      7: f40 -> f40 : [ 0>=M && M>=O ], cost: 1
      8: f40 -> f40 : N'=N+M, [ M>=1 && M>=O ], cost: 1

Eliminating 2 self-loops for location f25
  Self-Loop 4 has unbounded runtime, resulting in the new transition 14.
  Self-Loop 5 has unbounded runtime, resulting in the new transition 15.
  Removing the self-loops: 4 5.
Eliminating 2 self-loops for location f40
  Self-Loop 7 has unbounded runtime, resulting in the new transition 16.
  Self-Loop 8 has unbounded runtime, resulting in the new transition 17.
  Removing the self-loops: 7 8.

Removed all Self-loops using metering functions (where possible):
  Start location: f0
      0: f0 -> f18 : A'=3, B'=3, C'=0, D'=3, [], cost: 1
      3: f18 -> f25 : E'=D, F'=D, G'=-3, H'=4, Q'=0, [], cost: 1
     14: f25 -> [8] : [ 0>=G && G>=Q ], cost: INF
     15: f25 -> [8] : [ G>=1 && G>=Q ], cost: INF
      6: f33 -> f40 : J'=K, L'=K, M'=3, N'=-6, O'=0, [], cost: 1
     16: f40 -> [9] : [ 0>=M && M>=O ], cost: INF
     17: f40 -> [9] : [ M>=1 && M>=O ], cost: INF
     12: [8] -> f33 : K'=H, [ Q>=1+G ], cost: 1


Applied simple chaining:
  Start location: f0
      0: f0 -> f25 : A'=3, B'=3, C'=0, D'=3, E'=3, F'=3, G'=-3, H'=4, Q'=0, [], cost: 2
     14: f25 -> [8] : [ 0>=G && G>=Q ], cost: INF
     15: f25 -> [8] : [ G>=1 && G>=Q ], cost: INF
     16: f40 -> [9] : [ 0>=M && M>=O ], cost: INF
     17: f40 -> [9] : [ M>=1 && M>=O ], cost: INF
     12: [8] -> f40 : J'=H, K'=H, L'=H, M'=3, N'=-6, O'=0, [ Q>=1+G ], cost: 2


Applied chaining over branches and pruning:
  Start location: f0
    <empty>


Final control flow graph problem, now checking costs for infinitely many models:
  Start location: f0
    <empty>


Computing complexity for remaining 0 transitions.


The final runtime is determined by this resulting transition:
  Final Guard: 
  Final Cost:  1

Obtained the following complexity w.r.t. the length of the input n:
  Complexity class: const
  Complexity value: 0

WORST_CASE(Omega(1),?)