// This is the master plan for the for loops
// [Single Loop]
//    Skip - Zero Iteration 
// 
//    PassThrough - One Iteration
// 
//    Infinite
// 
//    [Many Iterations] - Normal case, not mentioned
//       Initialization
//          No
//          Assignment
//             [Single]
//             [Multiple]
//          Declaration
//             [Single]
//             [Multiple]
//                Same variable declared both before and in header,
//                     and printed both in and after loop
// 
//       Condition
//          No
//          [Exists]
//             Arithmetic
//                [True]
//                [False]
//             Logical
//                [Short Circuit + Side Effect]
//                [No Short Circuit]
//             Assignment
//                [True]
//                [False]
//             Relational
// 	          Boundary does not change
// 	          Boundary changes
//	       Declaration
//	          [Single]
//		  [Multiple]
//                Same variable declared both before and in header,
//                     and printed both in and after loop
//
// 
//       Action
//          Empty [statement]
//          Simple [statement]
//          Compound [statement]
//             Revises [LoopVar]
//	          Before [Action]
//		  After [Action]
//             [Does not revise LoopVar]
// 
//       Update
//          None
//          Up [Counting]
//             One
//             Many
//          Down [Counting]
//             One
//             Many
//
//       PostLoop [Resume after loop]
// 
// 
// Multiple [Back to back]
//    Dependent
//       [2 loop problems] - degrees of hardness
//       [3 loop problems] - degrees of hardness
//       [All loops of same type] - degrees of hardness
//       [Loops of different types] - degrees of hardness
//          Up [Counting]
//          Down [Counting]
// 
//    Independent
//       [2 loop problems] - degrees of hardness
//       [3 loop problems] - degrees of hardness
//       [All loops of same type] - degrees of hardness
//       [Loops of different types] - degrees of hardness
//          Up [Counting]
//          Down [Counting]
// 
// Nested
//    Dependent
//       [2 loop problems] - degrees of hardness
//       [3 loop problems] - degrees of hardness
//       [All loops of same type] - degrees of hardness
//       [Loops of different types] - degrees of hardness
//          Up [Counting]
//          Down [Counting]
// 
//    Independent
//       [2 loop problems] - degrees of hardness
//       [3 loop problems] - degrees of hardness
//       [All loops of same type] - degrees of hardness
//       [Loops of different types] - degrees of hardness
//          Up [Counting]
//          Down [Counting]
// 
// -------------------------------------------------------------------
// Other factors that affect template hardness:
// Loop body:
// Just a print statement
//     a constant
//     the loop counter
//     a simple expression involving the loopvar
//     the loopvar, boundary value (when boundary is a variable or expression)
//     an expression involving the loopvar and boundary value (when
//         it is a variable) - No, too complicated
//     an if-else statement with different variables in the two clauses 
//
// Note that the type of operator, and its subtypes determine hardness,
// not learning objectives.
// Number of iterations:
//   Zero iterations
//    <  >  
//      far off value
//       boundary value
//    <=  >=
//      far off value
//    ==
//      far off value
//    !=
//      same value
//      Only One iteration
// Multiple iterations
//    <  >
//      far off value
//    <=   >=
//      far off value
//      boundary value
//    ==
//      same value
//    !=
//      n-removed value
// ----------------------------------------------------
// 100
// Iteration.Counter.Skip
// Iteration.Counter.PassThrough
// 150
// Iteration.Counter.Initialization.No
// Iteration.Counter.Initialization.Assignment
// Iteration.Counter.Initialization.Declaration
// 225
// Iteration.Counter.Condition.No
// Iteration.Counter.Condition.Arithmetic
// Iteration.Counter.Condition.Logical
// Iteration.Counter.Condition.Assignment
// Iteration.Counter.Condition.Relational
// Iteration.Counter.Condition.Declaration
// Iteration.Counter.Condition.Changing
// 400
// Iteration.Counter.Action.Empty
// Iteration.Counter.Action.Simple
// Iteration.Counter.Action.Compound
// Iteration.Counter.Action.Changing.Before
// Iteration.Counter.Action.Changing.After
// 525
// Iteration.Counter.Update.No
// Iteration.Counter.Update.Up.One
// Iteration.Counter.Update.Up.Many
// Iteration.Counter.Update.Down.One
// Iteration.Counter.Update.Down.Many
// 650
// Iteration.Counter.PostLoop
// 675
// Iteration.Counter.Multiple.Dependent
//          [Up Counting]
//          [Down Counting]
// Iteration.Counter.Multiple.Independent
//          [Up Counting]
//          [Down Counting]
// 
// Iteration.Counter.Nested.Dependent
//          [Up Counting]
//          [Down Counting]
// Iteration.Counter.Nested.Independent
//          [Up Counting]
//          [Down Counting]
// break 800
// continue 825
// Iteration.Counter.Infinite 900
// 
// Up.One, Up.Many, Down.One, Down.Many are intertwined with the templates of most other learning objectives.
// Could either 
//  1) elilminate all but Up.One for all other learning objectives and introduce them as templates for 
//     Up.Many, Down.One, Down.Many
//  2) Add a few token learning objectives for Up.One, Up.Many, Down.One, Down.Many, and
//     either designate the other learning objectives as meeting these objectives, are 
//     provide credit for these learning objectives alongside the other learning objectives.
// In Fall 2004, not creating any templates for or giving credit for these learning objectives.
//
//
// Visual Basic works only with templates such that
//   condition is of the type var <= value or var >= value
//   update is of the type var = var op value
// 
//************** FOR LOOPS ************************************************
// ------------------------------------------------------------------------
// Counter.Skip ************************************ 100

//Empty Loops *************************** 100
# 100
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> > <R2#integer;6<=R2<=10;#>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 101
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> == <R2#integer;6<=R2<=10;#>;<V1> = <V1> + 1){<<<V1>;<<<R1>;}}}
>
Type: output
Hardness: 50

# 102
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=10;#>;<V1> < <R2#integer;1<=R2<=5;#>;<V1> = <V1> + 1){<<<V1>;<<<R2>;}}}
>
Type: output
Hardness: 50

# 103
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> >= <R2#integer;6<=R2<=10;#>;<V1> = <V1> - 1){<<<R1>;<<<V1>;}}}
>
Type: output
Hardness: 50

# 104
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <R1>;<V1> = <V1> + 1){<<<V1>;<<<R1>;}}}
>
Type: output
Hardness: 50

# 105
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=10;#>;<V1> <= <R2#integer;1<=R2<=5;#>;<V1> = <V1> + 1){<<<V1>;<<<R2>;}}}
>
Type: output
Hardness: 50


# 106
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=10;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> > <V2>;<V1> = <V1> - 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 107
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=10;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> == <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 108
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=10;#>;<V1> < <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 109
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=10;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> >= <V2>;<V1> = <V1> - 1){<<<V2>;<<<V1>;}}}
>
Type: output
Hardness: 50

# 110
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R1#1<=R1<=5;#>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 111
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=10;#>;<V1> <= <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 112
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=9;#>;<V1> > <R1>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 60

# 113
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=9;#>;<V1> < <R1>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 60

# 114
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=9;#>;<V1> != <R1>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 60


// Introduced for the sake of Visual Basic
# 115
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=10;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> >= <V2>;<V1> = <V1> - <R3#integer;1<=R3<=3;#>){<<<V2>;<<<V1>;}}}
>
Type: output
Hardness: 50

# 116
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=10;#>;<V1> <= <V2>;<V1> = <V1> + <R3#integer;1<=R3<=3;#>){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50
// ------------------------------------------------------------------------
// Counter.PassThrough ************************************ 125

# 125
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>=<R1#3<=R1<=9;#>;for(<V1> = <V1> - 1;<V1> < <R1>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 126
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>=<R1#3<=R1<=9;#>;for(<V1> = <V1> + 1;<V1> > <R1>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 127
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=9;#>;<V1> == <R1>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 128
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=9;#>;<V1> <= <R1>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 60

# 129
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=9;#>;<V1> >= <R1>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 60

# 130
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <R2#integer;6<=R2<=9;#>;<V1> = <R2>){<<<V1>;}}}
>
Type: output
Hardness: 50

# 131
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;6<=R2<=10;#>;<V1> = <R2>){<<<V1>;}}}
>
Type: output
Hardness: 50

# 132
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=9;#>;<V1> > 0;<V1> = <V1> - <R1>){<<<V1>;}}}
>
Type: output
Hardness: 60

# 133
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=9;#>;<T1><V2>;for(<V2> = <R1>;<V1> == <V2>;<V2> = <V2> - 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 134
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;6<=R2<=10;#>;<V1> = <R2> * 2){<<<V1>;}}}
>
Type: output
Hardness: 50

# 135
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;3<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <R2>;<V1> = <V2> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 136
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R1#1<=R1<=9;#>;<V2> = <V2> + 1;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 137
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R1#1<=R1<=9;#>;<V2> = <V2> + 1;for(<V1> = <R1>;<V1> < <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 138
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R1#3<=R1<=9;#>;<V2> = <V2> - 1;for(<V1> = <R1>;<V1> > <V2>;<V1> = <V1> - 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 139
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R1>;<V1> == <V2>;<V2> = <R2#integer;6<=R2<=9;#>){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 140
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=10;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V2> + 1){<<<V1>;}}}
>
Type: output
Hardness: 60

# 141
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <V2>;<V1> = <V2> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 142
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V1> != <V2>;<V2> = <V1>){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50




# 143
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R1#1<=R1<=9;#>;for(<V1> = <R1>;<V1> <= <V2>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 60

# 144
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R1#1<=R1<=9;#>;for(<V1> = <R1>;<V1> >= <V2>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50


# 145
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=10;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <R2>){<<<V1>;}}}
>
Type: output
Hardness: 60

# 146
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <V2>;<V1> = <V1> - <R1>){<<<V1>;}}}
>
Type: output
Hardness: 50

// ------------------------------------------------------------------------
// Counter.Initialization.No ************************************ 150

// ------------------------------------------------------------------------
// Counter.Initialization.Assignment ************************************ 175
// ------------------------------------------------------------------------
// Counter.Initialization.Declaration ************************************ 200

// ------------------------------------------------------------------------
// Counter.Condition.No ************************************ 225
// ------------------------------------------------------------------------
// Counter.Condition.Arithmetic ************************************ 250
// ------------------------------------------------------------------------
// Counter.Condition.Logical ************************************ 275
// ------------------------------------------------------------------------
// Counter.Condition.Assignment ************************************ 300
// ------------------------------------------------------------------------
// Counter.Condition.Relational ************************************ 325

// Using a constant as boundary value, update by one
# 325
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 20

# 326
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=9;#>;<V1> > <R2#integer;1<=R2<=5;#>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 327
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 20

# 328
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <R2#integer;1<=R2<=5;#>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 329
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 50

// Using a variable to hold boundary value, update by one
# 330
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 331
Counter.Condition.Relational
?
Counter.Update.After
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;<T1><V2>;for(<V2> = <R2#integer;1<=R2<=5;#>;<V1> > <V2>;<V2> = <V2> + 1){<<<V2>;}}}
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> > <V2>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 332
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + 1){<<<V1>;}}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V1> <= <V2>;<V2> = <V2> - 1){<<<V2>;}}}
>
Type: output
Hardness: 60

# 333
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <V2>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 60

# 334
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <V2>;<V1> = <V1> + 1){<<<V1>;}}}
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}} // Simplified for S08
>
Type: output
Hardness: 50

# 335
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V2> != <V1>;<V2> = <V2> - 1){<<<V2>;}}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V2> != <V1>;<V2> = <V2> - 1){<<<V2>;<<<V1>;}}} // Simplified for S08
>
Type: output
Hardness: 50

// Using a constant to hold boundary value, update by more than one
# 336
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
>
Type: output
Hardness: 20

# 337
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
>
Type: output
Hardness: 50

# 338
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
>
Type: output
Hardness: 20

# 339
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
>
Type: output
Hardness: 50

// Using a variable to hold boundary value, update by more than one
# 340
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
>
Type: output
Hardness: 50

# 341
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <V2>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
>
Type: output
Hardness: 50

# 342
Counter.Condition.Relational
?
Counter.Update.After
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;15<=R2<=20;#>;<V1> <= <V2>;<V2> = <V2> - <R3#integer;2<=R3<=5;#>){<<<V2>;}}}
{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
>
Type: output
Hardness: 60

# 343
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <V2>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#15<=R1<=20;#>;<T1><V2>;for(<V2> = <R2#integer;1<=R2<=5;#>;<V1> >= <V2>;<V2> = <V2> + <R3#integer;2<=R3<=5;#>){<<<V2>;}}}
>
Type: output
Hardness: 60

# 344
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<V2> = <R1#1<=R1<=5;#> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + <R2>){<<<V1>;}}}
>
Type: output
Hardness: 70

# 345
Counter.Condition.Relational
?
Counter.Update.After
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <V1> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>;<V2> != <V1>;<V2> = <V2> - <R2>){<<<V2>;}}}
[<R1#1<=R1<=5;#>,<R2#integer;2<=R2<=5;#>,<R3#integer;2<=R3<=4;#>,<R4#R4 = R1 + R2 * R3;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>;for(<V2> = <R4>;<V2> != <V1>;<V2> = <V2> - <R2>){<<<V2>;}}}
>
Type: output
Hardness: 70

# 346
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;50<=R2<=60;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <V1>){<<<V1>;}}}
>
Type: output
Hardness: 70

# 347
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;40<=R2<=50;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <V1>){<<<V1>;}}}
>
Type: output
Hardness: 70

// ------------------------------------------------------------------------
// Counter.Condition.Declaration ************************************ 350
// ------------------------------------------------------------------------
// Counter.Condition.Changing ************************************ 375
// NOT simplified for S08 since multiple outputs in the loop help student correctly understand behavior of loop

// Loop variable and Boundary variable changing in the opposite directions by 1
# 375
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;10<=R2<=15;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;<V2> = <V2> - 1;}}}
>
Type: output
Hardness: 60

# 376
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#10<=R1<=15;#>;<V1> > <V2>;<V1> = <V1> - 1){<<<V1>;<<<V2>;<V2> = <V2> + 1;}}}
>
Type: output
Hardness: 60

# 377
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;10<=R2<=15;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;<V2> = <V2> - 1;}}}
>
Type: output
Hardness: 70

# 378
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#10<=R1<=15;#>;<V1> >= <V2>;<V1> = <V1> - 1){<<<V1>;<<<V2>;<V2> = <V2> + 1;}}}
>
Type: output
Hardness: 70

# 379
Counter.Condition.Changing
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R1>;for(<V2> = <V2> + 6 * <R2#integer;1<=R2<=5;#>;<V2> != <V1>;<V2> = <V2> - <R2>){<<<V1>;<<<V2>;<V1> = <V1> + <R2>;}}}
[<R1#1<=R1<=5;#>,<R2#integer;1<=R2<=5;#><R3#R3 = R1 + 6 * R2;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>=<R1>;for(<V2> = <R3>;<V2> != <V1>;<V2> = <V2> - <R2>){<<<V1>;<<<V2>;<V1> = <V1> + <R2>;}}}
>
Type: output
Hardness: 60

// Loop variable and Boundary variable changing in the opposite directions by the same amount, not 1
# 380
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;16<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <R3#integer;3<=R3<=5;#>){<<<V1>;<<<V2>;<V2> = <V2> - <R3>;}}}
>
Type: output
Hardness: 70

# 381
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#16<=R1<=20;#>;<V1> > <V2>;<V1> = <V1> - <R3#integer;3<=R3<=5;#>){<<<V1>;<<<V2>;<V2> = <V2> + <R3>;}}}
>
Type: output
Hardness: 70

# 382
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <R3#integer;3<=R3<=5;#>){<<<V1>;<<<V2>;<V2> = <V2> - <R3>;}}}
>
Type: output
Hardness: 70

# 383
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <V2>;<V1> = <V1> - <R3#integer;3<=R3<=5;#>){<<<V1>;<<<V2>;<V2> = <V2> + <R3>;}}}
>
Type: output
Hardness: 70

# 384
Counter.Condition.Changing
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R1>;for(<V1> = <V1> + 4 * <R2#integer;1<=R2<=5;#>;<V1> != <V2>;<V1> = <V1> - <R2>){<<<V1>;<<<V2>;<V2> = <V2> + <R2>;}}}
[<R1#1<=R1<=5;#>,<R2#integer;1<=R2<=5;#>,<R3#R3 = R1 + 4 * R2;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>=<R1>;for(<V1> = <R3>;<V1> != <V2>;<V1> = <V1> - <R2>){<<<V1>;<<<V2>;<V2> = <V2> + <R2>;}}}
>
Type: output
Hardness: 70

// Loop variable and Boundary variable changing in the same direction, but by different amounts
# 385
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;12<=R2<=15;#>;for(<V1> = <R1#1<=R1<=4;#>;<V1> < <V2>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;<<<V2>;<V2> = <V2> + 1;}}}
>
Type: output
Hardness: 80

# 386
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;10<=R2<=15;#>;for(<V1> = <R1#1<=R1<=4;#>;<V1> <= <V2>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;<<<V2>;<V2> = <V2> + 1;}}}
>
Type: output
Hardness: 80

# 387
Counter.Condition.Changing
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#15<=R1<=18;#>;<V1> > <V2>;<V1> = <V1> - <R3#integer;3<=R3<=5;#>){<<<V1>;<<<V2>;<V2> = <V2> - 1;}}}
>
Type: output
Hardness: 80

# 388
Counter.Condition.Changing
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#15<=R1<=18;#>;<V1> >= <V2>;<V1> = <V1> - <R3#integer;3<=R3<=5;#>){<<<V1>;<<<V2>;<V2> = <V2> - 1;}}}
>
Type: output
Hardness: 80


// ------------------------------------------------------------------------
// Counter.Action.Empty ************************************ 400
// ------------------------------------------------------------------------
// Counter.Action.Simple ************************************ 425

// Using a constant as boundary value, update by one
# 425
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=4;#>;<V1> < <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1)<<<V1>;}}
>
Type: output
Hardness: 60

# 426
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=9;#>;<V1> > <R2#integer;1<=R2<=4;#>;<V1> = <V1> - 1)<<<V1>;}}
>
Type: output
Hardness: 60

# 427
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1)<<<V1>;}}
>
Type: output
Hardness: 60

# 428
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <R2#integer;1<=R2<=5;#>;<V1> = <V1> - 1)<<<V1>;}}
>
Type: output
Hardness: 60

# 429
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=4;#>;<V1> != <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1)<<<V1>;}}
>
Type: output
Hardness: 60

// Using a variable to hold boundary value, update by one
# 430
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=4;#>;<V1> < <V2>;<V1> = <V1> + 1)<<<V1>;<V2> = <V2> - 1;}}
>
Type: output
Hardness: 70

# 431
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=4;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> > <V2>;<V1> = <V1> - 1)<<<V1>;<V2> = <V2> + 1;}}
>
Type: output
Hardness: 70

# 432
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + 1)<<<V1>;<V2> = <V2> - 1;}}
>
Type: output
Hardness: 80

# 433
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <V2>;<V1> = <V1> - 1)<<<V1>;<V2> = <V2> + 1;}}
>
Type: output
Hardness: 80

# 434
Counter.Action.Simple
?
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=4;#>;<V1> != <V2>;<V1> = <V1> + 1)<<<V1>;<<<V2>;}} 
>
Type: output
Hardness: 70

# 435
Counter.Action.Simple
?
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V2> != <V1>;<V2> = <V2> - 1)<<<V2>;<<<V1>;}} 
>
Type: output
Hardness: 70

// Using a constant to hold boundary value, update by more than one
# 436
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>)<<<V1>;}}
>
Type: output
Hardness: 50

# 437
Counter.Action.Simple
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>)<<<V1>;}}
>
Type: output
Hardness: 60

# 438
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>)<<<V1>;}}
>
Type: output
Hardness: 50

# 439
Counter.Action.Simple
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>)<<<V1>;}}
>
Type: output
Hardness: 60

// Using a variable to hold boundary value, update by more than one
# 440
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>)<<<V1>;<V2> = <V2> - <R3>;}}
>
Type: output
Hardness: 70

# 441
Counter.Action.Simple
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <V2>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>)<<<V1>;<V2> = <V2> + <R3>;}}
>
Type: output
Hardness: 70

# 442
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>)<<<V1>;<V2> = <V2> - <R3>;}}
>
Type: output
Hardness: 80

# 443
Counter.Action.Simple
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <V2>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>)<<<V1>;<V2> = <V2> + <R3>;}}
>
Type: output
Hardness: 80

# 444
Counter.Action.Simple
?
Counter.PostLoop
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R1#1<=R1<=5;#> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + <R2>)<<<V1>;<<<V2>;}}
[<R1#1<=R1<=5;#>,<R2#integer;2<=R2<=5;#>,<R3#integer;2<=R3<=4;#>,<R4#R4 = R1 + R2 * R3;#>]{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R4>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + <R2>)<<<V1>;<<<V2>;}}
>
Type: output
Hardness: 80

# 445
Counter.Action.Simple
?
Counter.PostLoop
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <V1> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>;<V2> != <V1>;<V2> = <V2> - <R2>)<<<V2>;<<<V1>;}}
[<R1#1<=R1<=5;#>,<R2#integer;2<=R2<=5;#>,<R3#integer;2<=R3<=4;#>,<R4#R4 = R1 + R2 * R3;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>;for(<V2> = <R4>;<V2> != <V1>;<V2> = <V2> - <R2>)<<<V2>;<<<V1>;}}
>
Type: output
Hardness: 80

# 446
Counter.Action.Simple
?
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;50<=R2<=60;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <V1>)<<<V1>;<<<V2>;}}
>
Type: output
Hardness: 80

# 447
Counter.Action.Simple
?
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;40<=R2<=50;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <V1>)<<<V1>;<<<V2>;}}
>
Type: output
Hardness: 80

// ------------------------------------------------------------------------
// Counter.Action.Compound ************************************ 450
// ------------------------------------------------------------------------
// Counter.Action.Changing.Before ************************************ 475
// Counter loop being changed in the body, before the body

// Using a constant as boundary value, update by one
# 475
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=3;#>;<V1> < <R2#integer;7<=R2<=9;#>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 20

# 476
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#7<=R1<=9;#>;<V1> > <R2#integer;1<=R2<=3;#>;<V1> = <V1> - 1){<V1> = <V1> - 1;<<<V1>;}}}
>
Type: output
Hardness: 50

# 477
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=3;#>;<V1> <= <R2#integer;7<=R2<=9;#>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 20

# 478
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#7<=R1<=9;#>;<V1> >= <R2#integer;1<=R2<=3;#>;<V1> = <V1> - 1){<V1> = <V1> - 1;<<<V1>;}}}
>
Type: output
Hardness: 50

# 479
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R1#1<=R1<=3;#> + <R2#integer;2<=R2<=5;#> * 2;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 50

// Using a variable to hold boundary value, update by one
# 480
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;7<=R2<=9;#>;for(<V1> = <R1#1<=R1<=3;#>;<V1> < <V2>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 50

# 481
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=3;#>;for(<V1> = <R1#7<=R1<=9;#>;<V1> > <V2>;<V1> = <V1> - 1){<V1> = <V1> - 1;<<<V1>;}}}
>
Type: output
Hardness: 50

# 482
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;7<=R2<=9;#>;for(<V1> = <R1#1<=R1<=3;#>;<V1> <= <V2>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 60

# 483
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=3;#>;for(<V1> = <R1#7<=R1<=9;#>;<V1> >= <V2>;<V1> = <V1> - 1){<V1> = <V1> - 1;<<<V1>;}}}
>
Type: output
Hardness: 60

# 484
Counter.Action.Changing.Before
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R1#1<=R1<=3;#> + 2 * <R2#integer;2<=R2<=5;#>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;<<<V2>;}}} // Simplified for S08
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=3;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> = 2 * <V2> + <R1>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;}}}
[<R1#1<=R1<=3;#>,<R2#integer;2<=R2<=5;#>,<R3#R3 = 2 * R2 + R1;#>]{<T0><F0>(){<T1#integer#><V1> = <R1>;<T1><V2> = <R3>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 50

# 485
Counter.Action.Changing.Before
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=3;#>;<T1><V2>;for(<V2> = <R1> + 2 * <R2#integer;3<=R2<=6;#>;<V2> != <V1>;<V2> = <V2> - 1){<V2> = <V2> - 1;<<<V2>;<<<V1>;}}} // Simplified for S08
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=3;#>;<T1><V2> = <R2#integer;3<=R2<=6;#>;for(<V2> = 2 * <V2> + <R1>;<V2> != <V1>;<V2> = <V2> - 1){<V2> = <V2> - 1;<<<V2>;}}}
[<R1#1<=R1<=3;#>,<R2#integer;3<=R2<=6;#>,<R3#R3 = 2 * R2 + R1;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>;for(<V2> = <R3>;<V2> != <V1>;<V2> = <V2> - 1){<V2> = <V2> - 1;<<<V2>;}}}
>
Type: output
Hardness: 50

// Using a constant to hold boundary value, update by more than one
# 486
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<V1> = <V1> + <R3>;<<<V1>;}}}
>
Type: output
Hardness: 20

# 487
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<V1> = <V1> - <R3>;<<<V1>;}}}
>
Type: output
Hardness: 50

# 488
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<V1> = <V1> + <R3>;<<<V1>;}}}
>
Type: output
Hardness: 20

# 489
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<V1> = <V1> - <R3>;<<<V1>;}}}
>
Type: output
Hardness: 50

// Using a variable to hold boundary value, update by more than one
# 490
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<V1> = <V1> + <R3>;<<<V1>;}}}
>
Type: output
Hardness: 50

# 491
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <V2>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<V1> = <V1> - <R3>;<<<V1>;}}}
>
Type: output
Hardness: 50

# 492
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<V1> = <V1> + <R3>;<<<V1>;}}}
>
Type: output
Hardness: 60

# 493
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <V2>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<V1> = <V1> - <R3>;<<<V1>;}}}
>
Type: output
Hardness: 60

# 494
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;50<=R2<=60;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <V1>){<V1> = <V1> + <V1>;<<<V1>;}}}
>
Type: output
Hardness: 70

# 495
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;40<=R2<=50;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <V1>){<V1> = <V1> + <V1>;<<<V1>;}}}
>
Type: output
Hardness: 70

// ------------------------------------------------------------------------
// Counter.Action.Changing.After ************************************ 500

// ------------------------------------------------------------------------
// Counter.Update.No ************************************ 525

// ------------------------------------------------------------------------
// Counter.Update.Before ************************************ 550

// ------------------------------------------------------------------------
// Do we need this? This is general case
// Counter.Update.Up.One ************************************ 550

// ------------------------------------------------------------------------
// Counter.PostLoop ************************************ 650


// Using a constant as boundary value, update by one
# 650
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 651
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=9;#>;<V1> > <R2#integer;1<=R2<=5;#>;<V1> = <V1> - 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 40

# 652
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 653
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <R2#integer;1<=R2<=5;#>;<V1> = <V1> - 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 40

# 654
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

// Using a variable to hold boundary value, update by one
# 655
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 656
Counter.PostLoop
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;<T1><V2>;for(<V2> = <R2#integer;1<=R2<=5;#>;<V1> > <V2>;<V2> = <V2> + 1){<<<V2>;}<<<V2>;}}
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> > <V2>;<V1> = <V1> - 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 657
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + 1){<<<V1>;}<<<V1>;}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V1> <= <V2>;<V2> = <V2> - 1){<<<V2>;}<<<V2>;}}
>
Type: output
Hardness: 40

# 658
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <V2>;<V1> = <V1> - 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 40

# 659
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <V2>;<V1> = <V1> + 1){<<<V1>;}<<<V1>;}}
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}<<<V1>;}} // Simplified for S08
>
Type: output
Hardness: 30

# 660
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V2> != <V1>;<V2> = <V2> - 1){<<<V2>;}<<<V2>;}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V2> != <V1>;<V2> = <V2> - 1){<<<V2>;<<<V1>;}<<<V2>;}} // Simplified for S08
>
Type: output
Hardness: 40

// Using a constant to hold boundary value, update by more than one
# 661
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 662
Counter.PostLoop
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 40

# 663
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 664
Counter.PostLoop
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 40

// Using a variable to hold boundary value, update by more than one
# 665
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 666
Counter.PostLoop
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <V2>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 40

# 667
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;15<=R2<=20;#>;<V1> <= <V2>;<V2> = <V2> - <R3#integer;2<=R3<=5;#>){<<<V2>;}<<<V2>;}}
>
Type: output
Hardness: 40

# 668
Counter.PostLoop
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <V2>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#15<=R1<=20;#>;<T1><V2>;for(<V2> = <R2#integer;1<=R2<=5;#>;<V1> >= <V2>;<V2> = <V2> + <R3#integer;2<=R3<=5;#>){<<<V2>;}<<<V2>;}}
>
Type: output
Hardness: 30

# 669
Counter.PostLoop
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R1#1<=R1<=5;#> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + <R2>){<<<V1>;}<<<V1>;}}
[<R1#1<=R1<=5;#>,<R2#integer;2<=R2<=5;#>,<R3#integer;2<=R3<=4;#>,<R4#R4 = R1 + R2 * R3;#>]{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R4>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + <R2>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 670
Counter.PostLoop
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>;for(<V2> = <V2> + <V1>;<V2> != <V1>;<V2> = <V2> - <R2>){<<<V2>;}<<<V2>;}}
[<R1#1<=R1<=5;#>,<R2#integer;2<=R2<=5;#>,<R3#integer;2<=R3<=4;#>,<R4#R4 = R2 * R3;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2> = <R4>;for(<V2> = <V2> + <V1>;<V2> != <V1>;<V2> = <V2> - <R2>){<<<V2>;}<<<V2>;}}
>
Type: output
Hardness: 40

# 671
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;50<=R2<=60;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <V1>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 672
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;40<=R2<=50;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <V1>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

// ------------------------------------------------------------------------
// Counter.Multiple.Dependent ************************************ 675
//          [Up Counting]
//          [Down Counting]


// 2 loops
// UpUp - Update by 1 vs many - use first loop variable's value as second loop's start value/end value
// UpDown - Update by 1 vs many
// DownUp - Update by 1 vs many
// DownDown - Update by 1 vs many

// ********************** Up X Up X update by 1 ********************** 
# 675
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=5;#>;<V1> = <V1> + 1){<<<V1>;}for(;<V1> <= <R3#integer;7<=R3<=9;#>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 80

# 676
Counter.Multiple.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=5;#>;<V1> = <V1> + 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;0<=R3<=2;#>;<V2> <= <V1>;<V2> = <V2> + 1){<<<V2>;}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=2;#>;<V1> <= <R2#integer;3<=R2<=5;#>;<V1> = <V1> + 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;1<=R3<=2;#>;<V2> <= <V1>;<V2> = <V2> + 1){<<<V2>;}}}
>
Type: output
Hardness: 80

// ********************** Up X Up X Update by many ********************** 
# 677
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;}for(;<V1> <= <R4#integer;20<=R4<=22;#>;<V1> = <V1> + <R5#integer;2<=R5<=4;#>){<<<V1>;}}}
>
Type: output
Hardness: 80

# 678
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <R4#integer;0<=R4<=2;#>;<V2> <= <V1>;<V2> = <V2> + <R5#integer;2<=R5<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80

// ********************** Up X Down X update by 1 ********************** 
# 679
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=5;#>;<V1> = <V1> + 1){<<<V1>;}for(;<V1> >= <R1>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 80

# 680
Counter.Multiple.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;4<=R2<=6;#>;<V1> = <V1> + 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;7<=R3<=9;#>;<V2> >= <V1>;<V2> = <V2> - 1){<<<V2>;}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=2;#>;<V1> <= <R2#integer;4<=R2<=6;#>;<V1> = <V1> + 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;7<=R3<=9;#>;<V2> >= <V1>;<V2> = <V2> - 1){<<<V2>;}}}
>
Type: output
Hardness: 80

// ********************** Up X Down X Update by many ********************** 
# 681
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;}for(;<V1> >= <R1>;<V1> = <V1> - <R4#integer;2<=R4<=4;#>){<<<V1>;}}}
>
Type: output
Hardness: 80

# 682
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <R4#integer;20<=R4<=25;#>;<V2> >= <V1>;<V2> = <V2> - <R5#integer;2<=R5<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80

// ********************** Down X Up X Update by 1 ********************** 
# 683
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#3<=R1<=5;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;}for(;<V1> <= <R1>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 80

# 684
Counter.Multiple.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#7<=R1<=9;#>;<V1> >= <R2#integer;4<=R2<=6;#>;<V1> = <V1> - 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;0<=R3<=2;#>;<V2> < <V1>;<V2> = <V2> + 1){<<<V2>;}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#7<=R1<=9;#>;<V1> >= <R2#integer;4<=R2<=6;#>;<V1> = <V1> - 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;1<=R3<=2;#>;<V2> <= <V1>;<V2> = <V2> + 1){<<<V2>;}}}
>
Type: output
Hardness: 80

// ********************** Down X Up X Update by many ********************** 
# 685
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<<<V1>;}for(;<V1> <= <R1>;<V1> = <V1> + <R4#integer;2<=R4<=4;#>){<<<V1>;}}}
>
Type: output
Hardness: 80

# 686
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#20<=R1<=25;#>;<V1> >= <R2#integer;10<=R2<=12;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <R4#integer;0<=R4<=2;#>;<V2> < <V1>;<V2> = <V2> + <R5#integer;2<=R5<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80

// ********************** Down X Down X Update by 1 ********************** 
# 687
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#7<=R1<=9;#>;<V1> > <R2#integer;3<=R2<=5;#>;<V1> = <V1> - 1){<<<V1>;}for(;<V1> >= <R3#integer;0<=R3<=2;#>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 80

# 688
Counter.Multiple.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#3<=R1<=5;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;4<=R3<=6;#>;<V2> >= <V1>;<V2> = <V2> - 1){<<<V2>;}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#3<=R1<=5;#>;<V1> >= <R2#integer;1<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;3<=R3<=5;#>;<V2> >= <V1>;<V2> = <V2> - 1){<<<V2>;}}}
>
Type: output
Hardness: 80

// ********************** Down X Down X Update by many ********************** 
# 689
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#20<=R1<=25;#>;<V1> > <R2#integer;10<=R2<=12;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<<<V1>;}for(;<V1> >= <R4#integer;0<=R4<=2;#>;<V1> = <V1> - <R5#integer;2<=R5<=4;#>){<<<V1>;}}}
>
Type: output
Hardness: 80

# 690
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <R4#integer;10<=R4<=12;#>;<V2> >= <V1>;<V2> = <V2> - <R5#integer;2<=R5<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80


// ********************** 3-levels ********************** 
# 691
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=5;#>;<V1> = <V1> + 1){<<<V1>;}for(;<V1> < <R3#integer;10<=R3<=12;#>;<V1> = <V1> + 2){<<<V1>;}for(;<V1> < <R4#integer;20<=R4<=25;#>;<V1> = <V1> + 3){<<<V1>;}}}
>
Type: output
Hardness: 90

# 692
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#20<=R1<=25;#>;<V1> > <R2#integer;10<=R2<=12;#>;<V1> = <V1> - 3){<<<V1>;}for(;<V1> > <R3#integer;3<=R3<=5;#>;<V1> = <V1> - 2){<<<V1>;}for(;<V1> > <R4#integer;0<=R4<=2;#>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 90

// ***************** Introduced for the benefit of Visual Basic ********************
// Trivial modification of 677
# 693
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=2;#>;<V1> <= <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <V1>;<V2> <= <R4#integer;20<=R4<=22;#>;<V2> = <V2> + <R5#integer;2<=R5<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80

// Trivial modification of 681
# 694
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#1<=R1<=2;#>;<V1> <= <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <V1>;<V2> >= <R1>;<V2> = <V2> - <R4#integer;2<=R4<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80

// Trivial modification of 685
# 695
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#10<=R1<=12;#>;<V1> >= <R2#integer;1<=R2<=4;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <V1>;<V2> <= <R1>;<V2> = <V2> + <R4#integer;2<=R4<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80

// Trivial modification of 689
# 696
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#20<=R1<=25;#>;<V1> >= <R2#integer;10<=R2<=12;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <V1>;<V2> >= <R4#integer;0<=R4<=2;#>;<V2> = <V2> - <R5#integer;2<=R5<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80


// ------------------------------------------------------------------------
// Counter.Multiple.Independent ************************************ 700
//          [Up Counting]
//          [Down Counting]


// ------------------------------------------------------------------------
// Counter.Nested.Dependent ************************************ 725
//          [Up Counting]
//          [Down Counting]


// 2 loops nested
// UpUp - Update by 1 vs many - use outside loop variable's value as inside loop's start value/end value/update value
// UpDown - Update by 1 vs many
// DownUp - Update by 1 vs many
// DownDown - Update by 1 vs many

// Up X Up X update by 1
# 725
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <V1>;<V2> <= <R2>;<V2> = <V2> + 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#1<=R1<=2;#>;<V1> <= <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <V1>;<V2> <= <R2>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 726
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R1>;<V2> <= <V1>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Up X Up X Update by many
# 727
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <V1>;<V2> <= <R2>;<V2> = <V2> + <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 728
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R1>;<V2> <= <V1>;<V2> = <V2> + <R3>){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> <= <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R1>;<V2> <= <V1>;<V2> = <V2> + <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 729
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#1<=R1<=3;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;for(<V2> = <R1>;<V2> <= <R2>;<V2> = <V2> + <V1>){<<<V2>;}}}}
>
Type: output
Hardness: 90

// Up X Down X update by 1
# 730
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <V1>;<V2> >= <R1>;<V2> = <V2> - 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#1<=R1<=2;#>;<V1> <= <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <V1>;<V2> >= <R1>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 731
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R2>;<V2> >= <V1>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Up X Down X Update by many
# 732
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <V1>;<V2> >= <R1>;<V2> = <V2> - <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 733
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> >= <V1>;<V2> = <V2> - <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 734
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#2<=R1<=4;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> >= <R1>;<V2> = <V2> - <V1>){<<<V2>;}}}}
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#2<=R1<=4;#>;<V1> <= <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> >= <R1>;<V2> = <V2> - <V1>){<<<V2>;}}}}
>
Type: output
Hardness: 90

// Down X Up X Update by 1
# 735
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <V1>;<V2> <= <R1>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 736
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R2>;<V2> <= <V1>;<V2> = <V2> + 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> >= <R2#integer;1<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R2>;<V2> <= <V1>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Down X Up X Update by many
# 737
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <V1>;<V2> <= <R1>;<V2> = <V2> + <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 738
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> <= <V1>;<V2> = <V2> + <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 739
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> <= <R1>;<V2> = <V2> + <V1>){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> >= <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> <= <R1>;<V2> = <V2> + <V1>){<<<V2>;}}}}
>
Type: output
Hardness: 90

// Down X Down X Update by 1
# 740
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <V1>;<V2> >= <R2>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 741
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R1>;<V2> >= <V1>;<V2> = <V2> - 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> >= <R2#integer;1<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R1>;<V2> >= <V1>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Down X Down X Update by many
# 742
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <V1>;<V2> >= <R2>;<V2> = <V2> - <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 743
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R1>;<V2> >= <V1>;<V2> = <V2> - <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 744
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R1>;<V2> >= <R2>;<V2> = <V2> - <V1>){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> >= <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R1>;<V2> >= <R2>;<V2> = <V2> - <V1>){<<<V2>;}}}}
>
Type: output
Hardness: 90

//3-levels
# 745
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>;for(<V1> = <R1#0<=R1<=1;#>;<V1> < <R2#integer;2<=R2<=3;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <V1>;<V2> < <R2>;<V2> = <V2> + 1){<<<V2>;for(<V3> = <V2>;<V3> < <R2>;<V3> = <V3> + 1){<<<V3>;}}}}}
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>;for(<V1> = <R1#0<=R1<=1;#>;<V1> < <R2#integer;2<=R2<=3;#>;<V1> = <V1> + 1){for(<V2> = <V1>;<V2> < <R2>;<V2> = <V2> + 1){for(<V3> = <V2>;<V3> < <R2>;<V3> = <V3> + 1){<<<V1>;<<<V2>;<<<V3>;}}}}} // Simplified for S08
>
Type: output
Hardness: 90

# 746
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;<T1><V3>;for(<V1> = <R1#2<=R1<=3;#>;<V1> > <R2#integer;0<=R2<=1;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <V1>;<V2> > <R2>;<V2> = <V2> - 1){<<<V2>;for(<V3> = <V2>;<V3> > <R2>;<V3> = <V3> - 1){<<<V3>;}}}}}
// {<T0><F0>(){<T1#signed#><V1>;<T1><V2>;<T1><V3>;for(<V1> = <R1#2<=R1<=3;#>;<V1> > <R2#integer;0<=R2<=1;#>;<V1> = <V1> - 1){for(<V2> = <V1>;<V2> > <R2>;<V2> = <V2> - 1){for(<V3> = <V2>;<V3> > <R2>;<V3> = <V3> - 1){<<<V1>;<<<V2>;<<<V3>;}}}}} // Simplified for S08
>
Type: output
Hardness: 90

// ------------------------------------------------------------------------
// Counter.Nested.Independent ************************************ 750
//          [Up Counting]
//          [Down Counting]

// 2 loops nested
// UpUp - Update by 1 vs many - 2 constants for bounds, same constant for bounds, 2 variables for bounds both same
// UpDown - Update by 1 vs many
// DownUp - Update by 1 vs many
// DownDown - Update by 1 vs many

// Up X Up X update by 1
# 750
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R4#integer;3<=R4<=5;#>;<V2> = <V2> + 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#1<=R1<=2;#>;<V1> <= <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R3#1<=R3<=2;#>;<V2> <= <R4#integer;3<=R4<=5;#>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 751
Counter.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R2>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 752
Counter.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>=<R2#integer;3<=R2<=4;#>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <V3>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> < <V3>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Up X Up X Update by many
# 753
Counter.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R6#integer;3<=R6<=4;#>){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R4#integer;10<=R4<=12;#>;<V2> = <V2> + <R5#integer;3<=R5<=4;#>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 754
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R4#integer;3<=R4<=4;#>){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R2>;<V2> = <V2> + <R4>){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> <= <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R4#integer;3<=R4<=4;#>){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R2>;<V2> = <V2> + <R4>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 755
Counter.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>=<R2#integer;10<=R2<=12;#>;<T1><V4>=<R3#integer;3<=R3<=4;#>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <V3>;<V1> = <V1> + <V4>){<<<V1>;for(<V2> = <R4#0<=R4<=2;#>;<V2> <= <V3>;<V2> = <V2> + <V4>){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Up X Down X update by 1
# 756
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R3#3<=R3<=4;#>;<V2> >= <R4#integer;0<=R4<=2;#>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 757
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R2>;<V2> >= <R1>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 758
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>=<R1#integer;0<=R1<=2;#>;<T1><V4>=<R2#3<=R2<=4;#>;for(<V1> = <V3>;<V1> < <V4>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <V4>;<V2> >= <V3>;<V2> = <V2> - 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>=<R1#integer;1<=R1<=2;#>;<T1><V4>=<R2#3<=R2<=4;#>;for(<V1> = <V3>;<V1> <= <V4>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <V4>;<V2> >= <V3>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Up X Down X Update by many
# 759
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R6#integer;3<=R6<=4;#>){<<<V1>;for(<V2> = <R3#10<=R3<=12;#>;<V2> >= <R4#integer;0<=R4<=2;#>;<V2> = <V2> - <R5#integer;3<=R5<=4;#>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 760
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> >= <R1>;<V2> = <V2> - <R3>){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> <= <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> >= <R1>;<V2> = <V2> - <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 761
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>=<R1#0<=R1<=2;#>;<T1><V2>=<R2#integer;10<=R2<=12;#>;<T1><V3>=<R3#integer;3<=R3<=4;#>;<T1><V4>;<T1><V5>;for(<V4> = <R1>;<V4> < <V2>;<V4> = <V4> + <V3>){<<<V4>;for(<V5> = <V2>;<V5> >= <V1>;<V5> = <V5> - <V3>){<<<V5>;}}}}
>
Type: output
Hardness: 80

// Down X Up X Update by 1
# 762
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R4#integer;3<=R4<=5;#>;<V2> = <V2> + 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> >= <R2#integer;1<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R3#1<=R3<=2;#>;<V2> <= <R4#integer;3<=R4<=5;#>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 763
Counter.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R1>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 764
Counter.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>=<R1#integer;0<=R1<=2;#>;<T1><V4>=<R2#3<=R2<=4;#>;for(<V1> = <V4>;<V1> > <V3>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <V3>;<V2> <= <V4>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Down X Up X Update by many
# 765
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>=<R1#10<=R1<=12;#>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R6#integer;3<=R6<=4;#>){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R4#integer;10<=R4<=12;#>;<V2> = <V2> + <R5#integer;3<=R5<=4;#>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 766
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R4#integer;3<=R4<=4;#>){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R1>;<V2> = <V2> + <R4>){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> >= <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R4#integer;3<=R4<=4;#>){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R1>;<V2> = <V2> + <R4>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 767
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>=<R1#0<=R1<=2;#>;<T1><V2>=<R2#integer;10<=R2<=12;#>;<T1><V3>=<R3#integer;3<=R3<=4;#>;<T1><V4>;<T1><V5>;for(<V4> = <R2>;<V4> > <V1>;<V4> = <V4> - <V3>){<<<V4>;for(<V5> = <V1>;<V5> <= <V2>;<V5> = <V5> + <V3>){<<<V5>;}}}}
>
Type: output
Hardness: 80

// Down X Down X Update by 1
# 768
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R3#3<=R3<=4;#>;<V2> >= <R4#integer;0<=R4<=2;#>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 769
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R3#3<=R3<=4;#>;<V2> >= <R2>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 770
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>=<R1#integer;0<=R1<=2;#>;<T1><V4>=<R2#3<=R2<=4;#>;for(<V1> = <V4>;<V1> > <V3>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <V4>;<V2> >= <V3>;<V2> = <V2> - 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;<T1><V3>=<R1#integer;0<=R1<=2;#>;<T1><V4>=<R2#3<=R2<=4;#>;for(<V1> = <V4>;<V1> >= <V3>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <V4>;<V2> >= <V3>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Down X Down X Update by many
# 771
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R6#integer;3<=R6<=4;#>){<<<V1>;for(<V2> = <R3#10<=R3<=12;#>;<V2> >= <R4#integer;0<=R4<=2;#>;<V2> = <V2> - <R5#integer;3<=R5<=4;#>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 772
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R4#integer;3<=R4<=4;#>){<<<V1>;for(<V2> = <R3#10<=R3<=12;#>;<V2> >= <R2>;<V2> = <V2> - <R4>){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> >= <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R4#integer;3<=R4<=4;#>){<<<V1>;for(<V2> = <R3#10<=R3<=12;#>;<V2> >= <R2>;<V2> = <V2> - <R4>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 773
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>=<R1#0<=R1<=2;#>;<T1><V2>=<R2#integer;10<=R2<=12;#>;<T1><V3>=<R3#integer;3<=R3<=4;#>;<T1><V4>;<T1><V5>;for(<V4> = <R2>;<V4> > <V1>;<V4> = <V4> - <V3>){<<<V4>;for(<V5> = <V2>;<V5> >= <V1>;<V5> = <V5> - <V3>){<<<V5>;}}}}
>
Type: output
Hardness: 80

//3-levels
# 774
Counter.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>;for(<V1> = <R1#0<=R1<=1;#>;<V1> < <R4#integer;2<=R4<=3;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R2#0<=R2<=1;#>;<V2> < <R4>;<V2> = <V2> + 1){<<<V2>;for(<V3> = <R3#0<=R3<=1;#>;<V3> < <R4>;<V3> = <V3> + 1){<<<V3>;}}}}}
// {<T0><F0>(){<T1#integer#><V1>;<T1><V3>;for(<V1> = <R1#0<=R1<=1;#>;<V1> < <R4#integer;2<=R4<=3;#>;<V1> = <V1> + 1){<T1><V2>;for(<V2> = <R2#0<=R2<=1;#>;<V2> < <R4>;<V2> = <V2> + 1){for(<V3> = <R3#0<=R3<=1;#>;<V3> < <R4>;<V3> = <V3> + 1){<<<V1>;<<<V2>;<<<V3>;}}}}} // Simplified for S08
>
Type: output
Hardness: 90

//3-levels
# 775
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;<T1><V3>;for(<V1> = <R1#2<=R1<=3;#>;<V1> > <R4#integer;0<=R4<=1;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R2#2<=R2<=3;#>;<V2> > <R4>;<V2> = <V2> - 1){<<<V2>;for(<V3> = <R3#2<=R3<=3;#>;<V3> > <R4>;<V3> = <V3> - 1){<<<V3>;}}}}}
// {<T0><F0>(){<T1#signed#><V1>;<T1><V3>;for(<V1> = <R1#2<=R1<=3;#>;<V1> > <R4#integer;0<=R4<=1;#>;<V1> = <V1> - 1){<T1><V2>;for(<V2> = <R2#2<=R2<=3;#>;<V2> > <R4>;<V2> = <V2> - 1){for(<V3> = <R3#2<=R3<=3;#>;<V3> > <R4>;<V3> = <V3> - 1){<<<V1>;<<<V2>;<<<V3>;}}}}} // Simplified for S08
>
Type: output
Hardness: 90




// --------------------------------------------------------------------------
// Templates here are for demonstration purposes
// Included at the end so that regular practice does not pick up these templates

// How to enter 2 outputs
# 90
Demonstration
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<<<V1>;<T1><V2>=<R2#integer;6<=R2<=10;#>;<<<V2>;<< <V2> - <V1>;}}
>
Type: output
Hardness: 10

// How to enter multiple outputs from the same line
# 91
Demonstration
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = 1;<V1> <= 2;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 10

// How to enter multiple outputs from alternate lines
# 92
Demonstration
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<V2> = 5;for(<V1> = 1;<V1> <= 2;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 10
// --------------------------------------------------------------------------