Loop Comparison Trace summary:

Step 1: State 0 -- gradeCountSpec.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 1
Step 2: State 1 -- gradeCountSpec.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 2
Step 3: State 2 -- gradeCountSpec.c line 15 [main@2->main@0] "i++" -> State 3
Step 4: State 3 -- gradeCountSpec.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 4
Step 5: State 4 -- gradeCountSpec.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 5
Step 6: State 5 -- gradeCountSpec.c line 15 [main@2->main@0] "i++" -> State 6
Step 7: State 6 -- gradeCountSpec.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 7
Step 8: State 7 -- gradeCountSpec.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 8
Step 9: State 8 -- gradeCountSpec.c line 15 [main@2->main@0] "i++" -> State 9
Step 10: State 9 -- gradeCountSpec.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 10
Step 11: State 10 -- gradeCountSpec.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 11
Step 12: State 11 -- gradeCountSpec.c line 15 [main@2->main@0] "i++" -> State 12
Step 13: State 12 -- gradeCountSpec.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 13
Step 14: State 13 -- gradeCountSpec.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 14
Step 15: State 14 -- gradeCountSpec.c line 15 [main@2->main@0] "i++" -> State 15
Step 16: State 15 -- gradeCountSpec.c line 15 [main@0->main@3] "for(; i < 5; i++)" [false] -> State 16
Step 17: State 16 -- gradeCountSpec.c line 17 [main@3->main@4] "i=0;" -> State 17
Step 18: State 17 -- gradeCountImpl.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 18
Step 19: State 18 -- gradeCountImpl.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 19
Step 20: State 19 -- gradeCountImpl.c line 15 [main@2->main@0] "i++" -> State 20
Step 21: State 20 -- gradeCountImpl.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 21
Step 22: State 21 -- gradeCountImpl.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 22
Step 23: State 22 -- gradeCountImpl.c line 15 [main@2->main@0] "i++" -> State 23
Step 24: State 23 -- gradeCountImpl.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 24
Step 25: State 24 -- gradeCountImpl.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 25
Step 26: State 25 -- gradeCountImpl.c line 15 [main@2->main@0] "i++" -> State 26
Step 27: State 26 -- gradeCountImpl.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 27
Step 28: State 27 -- gradeCountImpl.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 28
Step 29: State 28 -- gradeCountImpl.c line 15 [main@2->main@0] "i++" -> State 29
Step 30: State 29 -- gradeCountImpl.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 30
Step 31: State 30 -- gradeCountImpl.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 31
Step 32: State 31 -- gradeCountImpl.c line 15 [main@2->main@0] "i++" -> State 32
Step 33: State 32 -- gradeCountImpl.c line 15 [main@0->main@3] "for(; i < 5; i++)" [false] -> State 33
Step 34: State 33 -- gradeCountImpl.c line 17 [main@3->main@4] "i=0;" -> State 34
Step 35: State 34 -- gradeCountSpec.c line 19 [main@4->main@5] "while(i < N)" [true]gradeCountImpl.c line 20 [main@4->main@5] "while(i < N)" [true] -> State 35
Step 36: State 35 -- gradeCountSpec.c line 20 [main@5->main@6] "if(scores[i] >= 90.0)" [true] -> State 36
Step 37: State 36 -- gradeCountSpec.c line 21 [main@6->main@14] "numGrade[0]++;" -> State 37
Step 38: State 37 -- gradeCountSpec.c line 30 [main@14->main@15] "if(numGrade[4] > 10)" [true] -> State 38
Step 39: State 38 -- gradeCountSpec.c line 31 [main@15->main@16] "failureFlag = 1;" -> State 39
Step 40: State 39 -- gradeCountSpec.c line 32 [main@16->main@4] "i++;" -> State 40
Step 41: State 40 -- gradeCountImpl.c line 21 [main@5->main@6] "if(scores[i] >= 90.0)" [true] -> State 41
Step 42: State 41 -- gradeCountImpl.c line 22 [main@6->main@14] "numGrade[0]++;" -> State 42
Step 43: State 42 -- gradeCountImpl.c line 31 [main@14->main@16] "if(numGrade[3] > 10)" [false] -> State 51
Step 44: State 51 -- gradeCountImpl.c line 33 [main@16->main@4] "i++;" -> State 52
Step 45: State 52

Loop Comparison Trace details:

begin State 0
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 0

Step 1: State 0 -- gradeCountSpec.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 1

begin State 1
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 1;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 1

Step 2: State 1 -- gradeCountSpec.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 2

begin State 2
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 2;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 2

Step 3: State 2 -- gradeCountSpec.c line 15 [main@2->main@0] "i++" -> State 3

begin State 3
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 1 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 3

Step 4: State 3 -- gradeCountSpec.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 4

begin State 4
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 1;
        i = 1 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 4

Step 5: State 4 -- gradeCountSpec.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 5

begin State 5
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 2;
        i = 1 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 5

Step 6: State 5 -- gradeCountSpec.c line 15 [main@2->main@0] "i++" -> State 6

begin State 6
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 2 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 6

Step 7: State 6 -- gradeCountSpec.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 7

begin State 7
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 1;
        i = 2 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 7

Step 8: State 7 -- gradeCountSpec.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 8

begin State 8
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 2;
        i = 2 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 8

Step 9: State 8 -- gradeCountSpec.c line 15 [main@2->main@0] "i++" -> State 9

begin State 9
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 3 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 9

Step 10: State 9 -- gradeCountSpec.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 10

begin State 10
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 1;
        i = 3 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 10

Step 11: State 10 -- gradeCountSpec.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 11

begin State 11
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 2;
        i = 3 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 11

Step 12: State 11 -- gradeCountSpec.c line 15 [main@2->main@0] "i++" -> State 12

begin State 12
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 4 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 12

Step 13: State 12 -- gradeCountSpec.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 13

begin State 13
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 1;
        i = 4 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 13

Step 14: State 13 -- gradeCountSpec.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 14

begin State 14
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 2;
        i = 4 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 14

Step 15: State 14 -- gradeCountSpec.c line 15 [main@2->main@0] "i++" -> State 15

begin State 15
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 5 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 15

Step 16: State 15 -- gradeCountSpec.c line 15 [main@0->main@3] "for(; i < 5; i++)" [false] -> State 16

begin State 16
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 3;
        i = 5 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 16

Step 17: State 16 -- gradeCountSpec.c line 17 [main@3->main@4] "i=0;" -> State 17

begin State 17
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 17

Step 18: State 17 -- gradeCountImpl.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 18

begin State 18
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 1;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 18

Step 19: State 18 -- gradeCountImpl.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 19

begin State 19
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 2;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 19

Step 20: State 19 -- gradeCountImpl.c line 15 [main@2->main@0] "i++" -> State 20

begin State 20
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 1 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 20

Step 21: State 20 -- gradeCountImpl.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 21

begin State 21
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 1;
        i = 1 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 21

Step 22: State 21 -- gradeCountImpl.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 22

begin State 22
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0><1,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 2;
        i = 1 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 22

Step 23: State 22 -- gradeCountImpl.c line 15 [main@2->main@0] "i++" -> State 23

begin State 23
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0><1,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 2 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 23

Step 24: State 23 -- gradeCountImpl.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 24

begin State 24
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0><1,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 1;
        i = 2 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 24

Step 25: State 24 -- gradeCountImpl.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 25

begin State 25
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0><1,0><2,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 2;
        i = 2 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 25

Step 26: State 25 -- gradeCountImpl.c line 15 [main@2->main@0] "i++" -> State 26

begin State 26
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0><1,0><2,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 3 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 26

Step 27: State 26 -- gradeCountImpl.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 27

begin State 27
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0><1,0><2,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 1;
        i = 3 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 27

Step 28: State 27 -- gradeCountImpl.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 28

begin State 28
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0><1,0><2,0><3,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 2;
        i = 3 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 28

Step 29: State 28 -- gradeCountImpl.c line 15 [main@2->main@0] "i++" -> State 29

begin State 29
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0><1,0><2,0><3,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 4 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 29

Step 30: State 29 -- gradeCountImpl.c line 15 [main@0->main@1] "for(; i < 5; i++)" [true] -> State 30

begin State 30
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0><1,0><2,0><3,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 1;
        i = 4 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 30

Step 31: State 30 -- gradeCountImpl.c line 16 [main@1->main@2] "numGrade[i] = 0;" -> State 31

begin State 31
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 2;
        i = 4 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 31

Step 32: State 31 -- gradeCountImpl.c line 15 [main@2->main@0] "i++" -> State 32

begin State 32
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 0;
        i = 5 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 32

Step 33: State 32 -- gradeCountImpl.c line 15 [main@0->main@3] "for(; i < 5; i++)" [false] -> State 33

begin State 33
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 3;
        i = 5 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 33

Step 34: State 33 -- gradeCountImpl.c line 17 [main@3->main@4] "i=0;" -> State 34

begin State 34
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  loopPathCondition : 
 Null
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m0v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 0 (int);
        numGrade = m1v5<0,0><1,0><2,0><3,0><4,0> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = 0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 34

Step 35: State 34 -- gradeCountSpec.c line 19 [main@4->main@5] "while(i < N)" [true]gradeCountImpl.c line 20 [main@4->main@5] "while(i < N)" [true] -> State 35

begin State 35
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0 && gradeCountImpl_numGrade_l_0[0] + -1*gradeCountSpec_numGrade_l_0[0] = 0 && gradeCountImpl_numGrade_l_0[1] + -1*gradeCountSpec_numGrade_l_0[1] = 0 && gradeCountImpl_numGrade_l_0[2] + -1*gradeCountSpec_numGrade_l_0[2] = 0 && gradeCountImpl_numGrade_l_0[3] + -1*gradeCountSpec_numGrade_l_0[3] = 0 && gradeCountImpl_numGrade_l_0[4] + -1*gradeCountSpec_numGrade_l_0[4] = 0 && gradeCountSpec_failureFlag_l_0 + -1*gradeCountImpl_failureFlag_l_0 = 0 && gradeCountImpl_i_l_0 >= 0 && gradeCountSpec_i_l_0 + -1*gradeCountImpl_i_l_0 = 0 && X1 + -1*gradeCountImpl_i_l_0 + -1 >= 0
  loopPathCondition : 
l[4]: X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = gradeCountSpec_failureFlag_l_0 (int);
        numGrade = gradeCountSpec_numGrade_l_0 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 5;
        i = gradeCountSpec_i_l_0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = gradeCountImpl_failureFlag_l_0 (int);
        numGrade = gradeCountImpl_numGrade_l_0 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 5;
        i = gradeCountImpl_i_l_0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 35

Step 36: State 35 -- gradeCountSpec.c line 20 [main@5->main@6] "if(scores[i] >= 90.0)" [true] -> State 36

begin State 36
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0 && gradeCountImpl_numGrade_l_0[0] + -1*gradeCountSpec_numGrade_l_0[0] = 0 && gradeCountImpl_numGrade_l_0[1] + -1*gradeCountSpec_numGrade_l_0[1] = 0 && gradeCountImpl_numGrade_l_0[2] + -1*gradeCountSpec_numGrade_l_0[2] = 0 && gradeCountImpl_numGrade_l_0[3] + -1*gradeCountSpec_numGrade_l_0[3] = 0 && gradeCountImpl_numGrade_l_0[4] + -1*gradeCountSpec_numGrade_l_0[4] = 0 && gradeCountSpec_failureFlag_l_0 + -1*gradeCountImpl_failureFlag_l_0 = 0 && gradeCountImpl_i_l_0 >= 0 && gradeCountSpec_i_l_0 + -1*gradeCountImpl_i_l_0 = 0 && X1 + -1*gradeCountImpl_i_l_0 + -1 >= 0 && X2[gradeCountSpec_i_l_0] + -90 >= 0
  loopPathCondition : 
l[4]: X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = gradeCountSpec_failureFlag_l_0 (int);
        numGrade = gradeCountSpec_numGrade_l_0 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 6;
        i = gradeCountSpec_i_l_0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = gradeCountImpl_failureFlag_l_0 (int);
        numGrade = gradeCountImpl_numGrade_l_0 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 5;
        i = gradeCountImpl_i_l_0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 36

Step 37: State 36 -- gradeCountSpec.c line 21 [main@6->main@14] "numGrade[0]++;" -> State 37

begin State 37
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0 && gradeCountImpl_numGrade_l_0[0] + -1*gradeCountSpec_numGrade_l_0[0] = 0 && gradeCountImpl_numGrade_l_0[1] + -1*gradeCountSpec_numGrade_l_0[1] = 0 && gradeCountImpl_numGrade_l_0[2] + -1*gradeCountSpec_numGrade_l_0[2] = 0 && gradeCountImpl_numGrade_l_0[3] + -1*gradeCountSpec_numGrade_l_0[3] = 0 && gradeCountImpl_numGrade_l_0[4] + -1*gradeCountSpec_numGrade_l_0[4] = 0 && gradeCountSpec_failureFlag_l_0 + -1*gradeCountImpl_failureFlag_l_0 = 0 && gradeCountImpl_i_l_0 >= 0 && gradeCountSpec_i_l_0 + -1*gradeCountImpl_i_l_0 = 0 && X1 + -1*gradeCountImpl_i_l_0 + -1 >= 0 && X2[gradeCountSpec_i_l_0] + -90 >= 0
  loopPathCondition : 
l[4]: X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = gradeCountSpec_failureFlag_l_0 (int);
        numGrade = gradeCountSpec_numGrade_l_0<0,gradeCountSpec_numGrade_l_0[0] + 1> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 14;
        i = gradeCountSpec_i_l_0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = gradeCountImpl_failureFlag_l_0 (int);
        numGrade = gradeCountImpl_numGrade_l_0 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 5;
        i = gradeCountImpl_i_l_0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 37

Step 38: State 37 -- gradeCountSpec.c line 30 [main@14->main@15] "if(numGrade[4] > 10)" [true] -> State 38

begin State 38
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0 && gradeCountImpl_numGrade_l_0[0] + -1*gradeCountSpec_numGrade_l_0[0] = 0 && gradeCountImpl_numGrade_l_0[1] + -1*gradeCountSpec_numGrade_l_0[1] = 0 && gradeCountImpl_numGrade_l_0[2] + -1*gradeCountSpec_numGrade_l_0[2] = 0 && gradeCountImpl_numGrade_l_0[3] + -1*gradeCountSpec_numGrade_l_0[3] = 0 && gradeCountImpl_numGrade_l_0[4] + -1*gradeCountSpec_numGrade_l_0[4] = 0 && gradeCountSpec_failureFlag_l_0 + -1*gradeCountImpl_failureFlag_l_0 = 0 && gradeCountImpl_i_l_0 >= 0 && gradeCountSpec_i_l_0 + -1*gradeCountImpl_i_l_0 = 0 && X1 + -1*gradeCountImpl_i_l_0 + -1 >= 0 && X2[gradeCountSpec_i_l_0] + -90 >= 0 && gradeCountSpec_numGrade_l_0[4] + -11 >= 0
  loopPathCondition : 
l[4]: X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = gradeCountSpec_failureFlag_l_0 (int);
        numGrade = gradeCountSpec_numGrade_l_0<0,gradeCountSpec_numGrade_l_0[0] + 1> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 15;
        i = gradeCountSpec_i_l_0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = gradeCountImpl_failureFlag_l_0 (int);
        numGrade = gradeCountImpl_numGrade_l_0 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 5;
        i = gradeCountImpl_i_l_0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 38

Step 39: State 38 -- gradeCountSpec.c line 31 [main@15->main@16] "failureFlag = 1;" -> State 39

begin State 39
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0 && gradeCountImpl_numGrade_l_0[0] + -1*gradeCountSpec_numGrade_l_0[0] = 0 && gradeCountImpl_numGrade_l_0[1] + -1*gradeCountSpec_numGrade_l_0[1] = 0 && gradeCountImpl_numGrade_l_0[2] + -1*gradeCountSpec_numGrade_l_0[2] = 0 && gradeCountImpl_numGrade_l_0[3] + -1*gradeCountSpec_numGrade_l_0[3] = 0 && gradeCountImpl_numGrade_l_0[4] + -1*gradeCountSpec_numGrade_l_0[4] = 0 && gradeCountSpec_failureFlag_l_0 + -1*gradeCountImpl_failureFlag_l_0 = 0 && gradeCountImpl_i_l_0 >= 0 && gradeCountSpec_i_l_0 + -1*gradeCountImpl_i_l_0 = 0 && X1 + -1*gradeCountImpl_i_l_0 + -1 >= 0 && X2[gradeCountSpec_i_l_0] + -90 >= 0 && gradeCountSpec_numGrade_l_0[4] + -11 >= 0
  loopPathCondition : 
l[4]: X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 1 (int);
        numGrade = gradeCountSpec_numGrade_l_0<0,gradeCountSpec_numGrade_l_0[0] + 1> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 16;
        i = gradeCountSpec_i_l_0 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = gradeCountImpl_failureFlag_l_0 (int);
        numGrade = gradeCountImpl_numGrade_l_0 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 5;
        i = gradeCountImpl_i_l_0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 39

Step 40: State 39 -- gradeCountSpec.c line 32 [main@16->main@4] "i++;" -> State 40

begin State 40
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0 && gradeCountImpl_numGrade_l_0[0] + -1*gradeCountSpec_numGrade_l_0[0] = 0 && gradeCountImpl_numGrade_l_0[1] + -1*gradeCountSpec_numGrade_l_0[1] = 0 && gradeCountImpl_numGrade_l_0[2] + -1*gradeCountSpec_numGrade_l_0[2] = 0 && gradeCountImpl_numGrade_l_0[3] + -1*gradeCountSpec_numGrade_l_0[3] = 0 && gradeCountImpl_numGrade_l_0[4] + -1*gradeCountSpec_numGrade_l_0[4] = 0 && gradeCountSpec_failureFlag_l_0 + -1*gradeCountImpl_failureFlag_l_0 = 0 && gradeCountImpl_i_l_0 >= 0 && gradeCountSpec_i_l_0 + -1*gradeCountImpl_i_l_0 = 0 && X1 + -1*gradeCountImpl_i_l_0 + -1 >= 0 && X2[gradeCountSpec_i_l_0] + -90 >= 0 && gradeCountSpec_numGrade_l_0[4] + -11 >= 0
  loopPathCondition : 
l[4]: X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 1 (int);
        numGrade = gradeCountSpec_numGrade_l_0<0,gradeCountSpec_numGrade_l_0[0] + 1> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = gradeCountSpec_i_l_0 + 1 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = gradeCountImpl_failureFlag_l_0 (int);
        numGrade = gradeCountImpl_numGrade_l_0 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 5;
        i = gradeCountImpl_i_l_0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 40

Step 41: State 40 -- gradeCountImpl.c line 21 [main@5->main@6] "if(scores[i] >= 90.0)" [true] -> State 41

begin State 41
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0 && gradeCountImpl_numGrade_l_0[0] + -1*gradeCountSpec_numGrade_l_0[0] = 0 && gradeCountImpl_numGrade_l_0[1] + -1*gradeCountSpec_numGrade_l_0[1] = 0 && gradeCountImpl_numGrade_l_0[2] + -1*gradeCountSpec_numGrade_l_0[2] = 0 && gradeCountImpl_numGrade_l_0[3] + -1*gradeCountSpec_numGrade_l_0[3] = 0 && gradeCountImpl_numGrade_l_0[4] + -1*gradeCountSpec_numGrade_l_0[4] = 0 && gradeCountSpec_failureFlag_l_0 + -1*gradeCountImpl_failureFlag_l_0 = 0 && gradeCountImpl_i_l_0 >= 0 && gradeCountSpec_i_l_0 + -1*gradeCountImpl_i_l_0 = 0 && X1 + -1*gradeCountImpl_i_l_0 + -1 >= 0 && X2[gradeCountSpec_i_l_0] + -90 >= 0 && gradeCountSpec_numGrade_l_0[4] + -11 >= 0
  loopPathCondition : 
l[4]: X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 1 (int);
        numGrade = gradeCountSpec_numGrade_l_0<0,gradeCountSpec_numGrade_l_0[0] + 1> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = gradeCountSpec_i_l_0 + 1 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = gradeCountImpl_failureFlag_l_0 (int);
        numGrade = gradeCountImpl_numGrade_l_0 (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 6;
        i = gradeCountImpl_i_l_0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 41

Step 42: State 41 -- gradeCountImpl.c line 22 [main@6->main@14] "numGrade[0]++;" -> State 42

begin State 42
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0 && gradeCountImpl_numGrade_l_0[0] + -1*gradeCountSpec_numGrade_l_0[0] = 0 && gradeCountImpl_numGrade_l_0[1] + -1*gradeCountSpec_numGrade_l_0[1] = 0 && gradeCountImpl_numGrade_l_0[2] + -1*gradeCountSpec_numGrade_l_0[2] = 0 && gradeCountImpl_numGrade_l_0[3] + -1*gradeCountSpec_numGrade_l_0[3] = 0 && gradeCountImpl_numGrade_l_0[4] + -1*gradeCountSpec_numGrade_l_0[4] = 0 && gradeCountSpec_failureFlag_l_0 + -1*gradeCountImpl_failureFlag_l_0 = 0 && gradeCountImpl_i_l_0 >= 0 && gradeCountSpec_i_l_0 + -1*gradeCountImpl_i_l_0 = 0 && X1 + -1*gradeCountImpl_i_l_0 + -1 >= 0 && X2[gradeCountSpec_i_l_0] + -90 >= 0 && gradeCountSpec_numGrade_l_0[4] + -11 >= 0
  loopPathCondition : 
l[4]: X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 1 (int);
        numGrade = gradeCountSpec_numGrade_l_0<0,gradeCountSpec_numGrade_l_0[0] + 1> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = gradeCountSpec_i_l_0 + 1 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = gradeCountImpl_failureFlag_l_0 (int);
        numGrade = gradeCountImpl_numGrade_l_0<0,gradeCountImpl_numGrade_l_0[0] + 1> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 14;
        i = gradeCountImpl_i_l_0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 42

Step 43: State 42 -- gradeCountImpl.c line 31 [main@14->main@16] "if(numGrade[3] > 10)" [false] -> State 51

begin State 51
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0 && gradeCountImpl_numGrade_l_0[0] + -1*gradeCountSpec_numGrade_l_0[0] = 0 && gradeCountImpl_numGrade_l_0[1] + -1*gradeCountSpec_numGrade_l_0[1] = 0 && gradeCountImpl_numGrade_l_0[2] + -1*gradeCountSpec_numGrade_l_0[2] = 0 && gradeCountImpl_numGrade_l_0[3] + -1*gradeCountSpec_numGrade_l_0[3] = 0 && gradeCountImpl_numGrade_l_0[4] + -1*gradeCountSpec_numGrade_l_0[4] = 0 && gradeCountSpec_failureFlag_l_0 + -1*gradeCountImpl_failureFlag_l_0 = 0 && gradeCountImpl_i_l_0 >= 0 && gradeCountSpec_i_l_0 + -1*gradeCountImpl_i_l_0 = 0 && X1 + -1*gradeCountImpl_i_l_0 + -1 >= 0 && X2[gradeCountSpec_i_l_0] + -90 >= 0 && gradeCountSpec_numGrade_l_0[4] + -11 >= 0 && -1*gradeCountImpl_numGrade_l_0[3] + 10 >= 0
  loopPathCondition : 
l[4]: X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 1 (int);
        numGrade = gradeCountSpec_numGrade_l_0<0,gradeCountSpec_numGrade_l_0[0] + 1> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = gradeCountSpec_i_l_0 + 1 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = gradeCountImpl_failureFlag_l_0 (int);
        numGrade = gradeCountImpl_numGrade_l_0<0,gradeCountImpl_numGrade_l_0[0] + 1> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 16;
        i = gradeCountImpl_i_l_0 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 51

Step 44: State 51 -- gradeCountImpl.c line 33 [main@16->main@4] "i++;" -> State 52

begin State 52
  onStack = true;
  seen = true;
  pathCondition : X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0 && gradeCountImpl_numGrade_l_0[0] + -1*gradeCountSpec_numGrade_l_0[0] = 0 && gradeCountImpl_numGrade_l_0[1] + -1*gradeCountSpec_numGrade_l_0[1] = 0 && gradeCountImpl_numGrade_l_0[2] + -1*gradeCountSpec_numGrade_l_0[2] = 0 && gradeCountImpl_numGrade_l_0[3] + -1*gradeCountSpec_numGrade_l_0[3] = 0 && gradeCountImpl_numGrade_l_0[4] + -1*gradeCountSpec_numGrade_l_0[4] = 0 && gradeCountSpec_failureFlag_l_0 + -1*gradeCountImpl_failureFlag_l_0 = 0 && gradeCountImpl_i_l_0 >= 0 && gradeCountSpec_i_l_0 + -1*gradeCountImpl_i_l_0 = 0 && X1 + -1*gradeCountImpl_i_l_0 + -1 >= 0 && X2[gradeCountSpec_i_l_0] + -90 >= 0 && gradeCountSpec_numGrade_l_0[4] + -11 >= 0 && -1*gradeCountImpl_numGrade_l_0[3] + 10 >= 0
  loopPathCondition : 
l[4]: X0 + -1 >= 0 && X1 + -1 >= 0 && X0 + -1*X1 + -1 >= 0
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = 1 (int);
        numGrade = gradeCountSpec_numGrade_l_0<0,gradeCountSpec_numGrade_l_0[0] + 1> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = gradeCountSpec_i_l_0 + 1 (int);
      end stack frame 0;
    end process 0;
  end model state
  begin model state
    begin shared variables
      N_BOUND = X0 (int);
      N = X1 (int);
      scores = X2 (real[X1]);
      excessiveFailure = undefined (int);
    end shared variables;
    begin process 0
      begin global variables
        failureFlag = gradeCountImpl_failureFlag_l_0 (int);
        numGrade = gradeCountImpl_numGrade_l_0<0,gradeCountImpl_numGrade_l_0[0] + 1> (int[5]);
      end global variables;
      begin stack frame 0
        function : main;
        location : 4;
        i = gradeCountImpl_i_l_0 + 1 (int);
      end stack frame 0;
    end process 0;
  end model state
end State 52

Step 45: State 52
