Trying to load file: main.koat

Initial Control flow graph problem:
  Start location: f0
      0: f0 -> f8 : A'=-1, B'=-1, C'=1, [], cost: 1
      1: f8 -> f8 : C'=1+C, [ 100>=C ], cost: 1
     11: f8 -> f18 : D'=1, E'=0, [ C>=101 ], cost: 1
      2: f18 -> f22 : E'=1, F'=1, [ 99>=D ], cost: 1
      8: f18 -> f40 : [ D>=100 ], cost: 1
      5: f22 -> f22 : F'=1+F, [ 99>=F && 100>=F+D ], cost: 1
      6: f22 -> f22 : E'=0, F'=1+F, G'=free, [ 99>=F && 100>=F+D ], cost: 1
      3: f22 -> f33 : [ F>=100 ], cost: 1
      4: f22 -> f33 : [ 99>=F && F+D>=101 ], cost: 1
      7: f33 -> f18 : D'=1+D, E'=0, [ E==0 ], cost: 1
      9: f33 -> f40 : [ 0>=1+E ], cost: 1
     10: f33 -> f40 : [ E>=1 ], cost: 1


Simplified the transitions:
  Start location: f0
      0: f0 -> f8 : A'=-1, B'=-1, C'=1, [], cost: 1
      1: f8 -> f8 : C'=1+C, [ 100>=C ], cost: 1
     11: f8 -> f18 : D'=1, E'=0, [ C>=101 ], cost: 1
      2: f18 -> f22 : E'=1, F'=1, [ 99>=D ], cost: 1
      5: f22 -> f22 : F'=1+F, [ 99>=F && 100>=F+D ], cost: 1
      6: f22 -> f22 : E'=0, F'=1+F, G'=free, [ 99>=F && 100>=F+D ], cost: 1
      3: f22 -> f33 : [ F>=100 ], cost: 1
      4: f22 -> f33 : [ 99>=F && F+D>=101 ], cost: 1
      7: f33 -> f18 : D'=1+D, E'=0, [ E==0 ], cost: 1

Eliminating 1 self-loops for location f8
  Self-Loop 1 has the metering function: 101-C, resulting in the new transition 12.
  Removing the self-loops: 1.
Eliminating 2 self-loops for location f22
  Removing the self-loops: 5 6.
Adding an epsilon transition (to model nonexecution of the loops): 15.

Removed all Self-loops using metering functions (where possible):
  Start location: f0
      0: f0 -> f8 : A'=-1, B'=-1, C'=1, [], cost: 1
     12: f8 -> [6] : C'=101, [ 100>=C ], cost: 101-C
      2: f18 -> f22 : E'=1, F'=1, [ 99>=D ], cost: 1
     13: f22 -> [7] : F'=1+F, [ 99>=F && 100>=F+D ], cost: 1
     14: f22 -> [7] : E'=0, F'=1+F, G'=free, [ 99>=F && 100>=F+D ], cost: 1
     15: f22 -> [7] : [], cost: 0
      7: f33 -> f18 : D'=1+D, E'=0, [ E==0 ], cost: 1
     11: [6] -> f18 : D'=1, E'=0, [ C>=101 ], cost: 1
      3: [7] -> f33 : [ F>=100 ], cost: 1
      4: [7] -> f33 : [ 99>=F && F+D>=101 ], cost: 1


Applied simple chaining:
  Start location: f0
      0: f0 -> f18 : A'=-1, B'=-1, C'=101, D'=1, E'=0, [ 100>=1 && 101>=101 ], cost: 102
      2: f18 -> f22 : E'=1, F'=1, [ 99>=D ], cost: 1
     13: f22 -> [7] : F'=1+F, [ 99>=F && 100>=F+D ], cost: 1
     14: f22 -> [7] : E'=0, F'=1+F, G'=free, [ 99>=F && 100>=F+D ], cost: 1
     15: f22 -> [7] : [], cost: 0
      7: f33 -> f18 : D'=1+D, E'=0, [ E==0 ], cost: 1
      3: [7] -> f33 : [ F>=100 ], cost: 1
      4: [7] -> f33 : [ 99>=F && F+D>=101 ], cost: 1


Applied chaining over branches and pruning:
  Start location: f0
      0: f0 -> f18 : A'=-1, B'=-1, C'=101, D'=1, E'=0, [ 100>=1 && 101>=101 ], cost: 102
     16: f18 -> [7] : E'=1, F'=2, [ 99>=D && 99>=1 && 100>=1+D ], cost: 2
     17: f18 -> [7] : E'=0, F'=2, G'=free, [ 99>=D && 99>=1 && 100>=1+D ], cost: 2
     18: f18 -> [7] : E'=1, F'=1, [ 99>=D ], cost: 1
     19: [7] -> f18 : D'=1+D, E'=0, [ F>=100 && E==0 ], cost: 2
     20: [7] -> f18 : D'=1+D, E'=0, [ 99>=F && F+D>=101 && E==0 ], cost: 2


Applied chaining over branches and pruning:
  Start location: f0
      0: f0 -> f18 : A'=-1, B'=-1, C'=101, D'=1, E'=0, [ 100>=1 && 101>=101 ], cost: 102
     21: f18 -> f18 : D'=1+D, E'=0, F'=2, G'=free, [ 99>=D && 99>=1 && 100>=1+D && 99>=2 && 2+D>=101 && 0==0 ], cost: 4

Eliminating 1 self-loops for location f18
  Self-Loop 21 has the metering function: 100-D, resulting in the new transition 22.
  Removing the self-loops: 21.

Removed all Self-loops using metering functions (where possible):
  Start location: f0
      0: f0 -> f18 : A'=-1, B'=-1, C'=101, D'=1, E'=0, [ 100>=1 && 101>=101 ], cost: 102
     22: f18 -> [8] : D'=100, E'=0, F'=2, G'=free, [ -99+D==0 ], cost: 400-4*D


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),?)