// This is the master plan for the different loops
// [Single Loop]
//    Skip - Zero Iteration 
// 
//    PassThrough - One Iteration
// 
//    Infinite
// 
//    [Many Iterations] - Normal case, not mentioned
//       Initialization
//          Yes
//          No
// 
//       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
//                same variable declared both before and in header,
//                    and printed both in and after loop
// 
//       Action
//          Empty [statement]
//          Simple [statement]
//          Compound [statement]
// 
//       Update
//          None
//          After [body]
//             [Keyboard input]
//             [Expression]
//          Before [body]
//             [Keyboard input]
//             [Expression]
// 
//       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.
//   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
// ----------------------------------------------------
// These are the actual learning objectives
// 100
// Iteration.Logic.Pretest.Skip
// Iteration.Logic.Pretest.PassThrough
// 150
// Iteration.Logic.Pretest.Initialization.No
// Iteration.Logic.Pretest.Initialization.Yes
// 225 
// Iteration.Logic.Pretest.Condition.No
// Iteration.Logic.Pretest.Condition.Arithmetic
// Iteration.Logic.Pretest.Condition.Logical
// Iteration.Logic.Pretest.Condition.Assignment
// Iteration.Logic.Pretest.Condition.Relational
// Iteration.Logic.Pretest.Condition.Declaration
// Iteration.Logic.Pretest.Condition.Changing
// 400
// Iteration.Logic.Pretest.Action.Empty
// Iteration.Logic.Pretest.Action.Simple
// Iteration.Logic.Pretest.Action.Compound
// 525
// Iteration.Logic.Pretest.Update.No
// Iteration.Logic.Pretest.Update.Before
// Iteration.Logic.Pretest.Update.After
// 650
// Iteration.Logic.Pretest.PostLoop
// 675
// Iteration.Logic.Pretest.Multiple.Dependent
// Iteration.Logic.Pretest.Multiple.Independent
// 
// Iteration.Logic.Pretest.Nested.Dependent
// Iteration.Logic.Pretest.Nested.Independent
// 800
// Iteration.Logic.Pretest.Infinite
//****************** WHILE LOOPS ***************************************

// ------------------------------------------------------------------------
// Pretest.Skip ************************************

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

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

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

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

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

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


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

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

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

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

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

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

// ------------------------------------------------------------------------
// Pretest.PassThrough ************************************ 125

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ------------------------------------------------------------------------
// Pretest.Initialization.No ************************************ 150

// # 125
// Pretest.Initialization.No
// >
// {<F0>(){<T1#integer#><V1>;while(<V1> < 6){<<<V1>;<V1> = <V1> + 1;}}}
// >
// Type: output
// Hardness: 20

// ------------------------------------------------------------------------
// Pretest.Initialization.Yes ************************************ 

// ------------------------------------------------------------------------
// Pretest.Condition.No ************************************ 225

// ------------------------------------------------------------------------
// Pretest.Condition.Arithmetic ************************************ 250

// ------------------------------------------------------------------------
// Pretest.Condition.Logical ************************************ 275

// ------------------------------------------------------------------------
// Pretest.Condition.Assignment ************************************ 300

// ------------------------------------------------------------------------
// Pretest.Condition.Relational ************************************ 325

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ------------------------------------------------------------------------
// Pretest.Condition.Declaration ************************************ 350
// # 350
// Pretest.Condition.Declaration
// ?
// Pretest.Update.After
// >
// {<F0>(){<T1#integer#><V1>=<R1#2<=R1<=5;#>;while(<T1><V2> = <R2#integer;40<=R2<=50;#>){<<<V1>;<V1> = <V1> - 1;break;}}}
// >
// Type: output
// Hardness: 70
// 
// # 351
// Pretest.Condition.Declaration
// ?
// Pretest.Update.After
// >
// {<F0>(){<T1#integer#><V1>=<R1#2<=R1<=5;#>;while(<T1><V2> = <R2#integer;40<=R2<=50;#>){<<<V1>;<V1> = <V1> - 1;if(<V1> < 2){break;}}}}
// >
// Type: output
// Hardness: 70
// 
// // ------------------------------------------------------------------------
// Pretest.Condition.Changing ************************************ 375


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

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

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

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

# 379
Pretest.Condition.Changing
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R1>;<V2> = <V2> + 6 * <R2#integer;1<=R2<=5;#>;while(<V1> != <V2>){<<<V1>;<<<V2>;<V1> = <V1> + <R2>;<V2> = <V2> - <R2>;}}}
>
Type: output
Hardness: 60

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

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

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

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

# 384
Pretest.Condition.Changing
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R1>;<V1> = <V1> + 4 * <R2#integer;1<=R2<=5;#>;while(<V1> != <V2>){<<<V1>;<<<V2>;<V1> = <V1> - <R2>;<V2> = <V2> + <R2>;}}}
>
Type: output
Hardness: 70

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

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

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

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

// ------------------------------------------------------------------------
// Pretest.Action.Empty ************************************ 400

// ------------------------------------------------------------------------
// Pretest.Action.Simple ************************************ 425

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

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

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

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

# 429
Pretest.Action.Simple
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;while(<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
Pretest.Action.Simple
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> < <V2>)<V1> = <V1> + 1;<<<V1>;}}
>
Type: output
Hardness: 60

# 431
Pretest.Action.Simple
>
{<F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;<T1><V2>=<R2#integer;1<=R2<=4;#>;while(<V1> > <V2>)<V1> = <V1> - 1;<<<V1>;}}
>
Type: output
Hardness: 60

# 432
Pretest.Action.Simple
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> <= <V2>)<V1> = <V1> + 1;<<<V1>;}}
>
Type: output
Hardness: 70

# 433
Pretest.Action.Simple
>
{<F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;<T1><V2>=<R2#integer;1<=R2<=5;#>;while(<V1> >= <V2>)<V1> = <V1> - 1;<<<V1>;}}
>
Type: output
Hardness: 70

# 434
Pretest.Action.Simple
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> != <V2>)<V1> = <V1> + 1;<<<V1>;<<<V2>;}}
>
Type: output
Hardness: 60

# 435
Pretest.Action.Simple
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V2> != <V1>)<V2> = <V2> - 1;<<<V2>;<<<V1>;}}
>
Type: output
Hardness: 60

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

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

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

# 439
Pretest.Action.Simple
>
{<F0>(){<T1#integer#><V1>=<R1#15<=R1<=20;#>;while(<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
Pretest.Action.Simple
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#integer;15<=R2<=20;#>;while(<V1> < <V2>)<V1> = <V1> + <R3#integer;2<=R3<=5;#>;<<<V1>;}}
>
Type: output
Hardness: 60

# 441
Pretest.Action.Simple
>
{<F0>(){<T1#integer#><V1>=<R1#15<=R1<=20;#>;<T1><V2>=<R2#integer;1<=R2<=5;#>;while(<V1> > <V2>)<V1> = <V1> - <R3#integer;2<=R3<=5;#>;<<<V1>;}}
>
Type: output
Hardness: 60

# 442
Pretest.Action.Simple
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#integer;15<=R2<=20;#>;while(<V1> <= <V2>)<V1> = <V1> + <R3#integer;2<=R3<=5;#>;<<<V1>;}}
>
Type: output
Hardness: 70

# 443
Pretest.Action.Simple
>
{<F0>(){<T1#integer#><V1>=<R1#15<=R1<=20;#>;<T1><V2>=<R2#integer;1<=R2<=5;#>;while(<V1> >= <V2>)<V1> = <V1> - <R3#integer;2<=R3<=5;#>;<<<V1>;}}
>
Type: output
Hardness: 70

# 444
Pretest.Action.Simple
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;<V2> = <V1> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>;while(<V1> != <V2>)<V1> = <V1> + <R2>;<<<V1>;}}
>
Type: output
Hardness: 80

# 445
Pretest.Action.Simple
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;<V2> = <V1> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>;while(<V2> != <V1>)<V2> = <V2> - <R2>;<<<V2>;}}
>
Type: output
Hardness: 80

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

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


// ------------------------------------------------------------------------
// Pretest.Action.Compound ************************************ 450

// ------------------------------------------------------------------------
// Pretest.Update.No ************************************ 525

// ------------------------------------------------------------------------
// Pretest.Update.Before ************************************ 550

// Using a constant for the boundary value, updating by one
# 550
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;while(<V1> < <R2#integer;6<=R2<=9;#>){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 30

# 551
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;while(<V1> > <R2#integer;1<=R2<=4;#>){<V1> = <V1> - 1;<<<V1>;}}}
>
Type: output
Hardness: 30

# 552
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;while(<V1> <= <R2#integer;6<=R2<=9;#>){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 30

# 553
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;while(<V1> >= <R2#integer;1<=R2<=4;#>){<V1> = <V1> - 1;<<<V1>;}}}
>
Type: output
Hardness: 30

# 554
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;while(<V1> != <R2#integer;6<=R2<=9;#>){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 30

// Using a variable for the bounday value also, updating by one
# 555
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> < <V2>){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 30

# 556
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;<T1><V2>=<R2#integer;1<=R2<=4;#>;while(<V1> > <V2>){<V1> = <V1> - 1;<<<V1>;}}}
>
Type: output
Hardness: 30

# 557
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> <= <V2>){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 40

# 558
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;<T1><V2>=<R2#integer;1<=R2<=4;#>;while(<V1> >= <V2>){<V1> = <V1> - 1;<<<V1>;}}}
>
Type: output
Hardness: 40

# 559
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> != <V2>){<V1> = <V1> + 1;<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 30

# 560
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V2> != <V1>){<V2> = <V2> - 1;<<<V2>;<<<V1>;}}}
>
Type: output
Hardness: 30

// Using a constant for the boundary value, updating by more than one
# 561
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;while(<V1> < <R2#integer;15<=R2<=20;#>){<V1> = <V1> + <R3#integer;2<=R3<=5;#>;<<<V1>;}}}
>
Type: output
Hardness: 30

# 562
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#15<=R1<=20;#>;while(<V1> > <R2#integer;1<=R2<=5;#>){<V1> = <V1> - <R3#integer;2<=R3<=5;#>;<<<V1>;}}}
>
Type: output
Hardness: 60

# 563
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;while(<V1> <= <R2#integer;15<=R2<=20;#>){<V1> = <V1> + <R3#integer;2<=R3<=5;#>;<<<V1>;}}}
>
Type: output
Hardness: 30

# 564
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#15<=R1<=20;#>;while(<V1> >= <R2#integer;1<=R2<=5;#>){<V1> = <V1> - <R3#integer;2<=R3<=5;#>;<<<V1>;}}}
>
Type: output
Hardness: 60

// Using a variable for the boundary value, updating by more than one
# 565
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#integer;15<=R2<=20;#>;while(<V1> < <V2>){<V1> = <V1> + <R3#integer;2<=R3<=5;#>;<<<V1>;}}}
>
Type: output
Hardness: 60

# 566
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#15<=R1<=20;#>;<T1><V2>=<R2#integer;1<=R2<=5;#>;while(<V1> > <V2>){<V1> = <V1> - <R3#integer;2<=R3<=5;#>;<<<V1>;}}}
>
Type: output
Hardness: 60

# 567
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#integer;15<=R2<=20;#>;while(<V1> <= <V2>){<V1> = <V1> + <R3#integer;2<=R3<=5;#>;<<<V1>;}}}
>
Type: output
Hardness: 70

# 568
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#15<=R1<=20;#>;<T1><V2>=<R2#integer;1<=R2<=5;#>;while(<V1> >= <V2>){<V1> = <V1> - <R3#integer;2<=R3<=5;#>;<<<V1>;}}}
>
Type: output
Hardness: 70

# 569
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;<V2> = <V1> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>; while(<V1> != <V2>){<V1> = <V1> + <R2>;<<<V1>;}}}
>
Type: output
Hardness: 70

# 570
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>;<V1> = <R1#1<=R1<=5;#> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>; while(<V1> != <R1>){<V1> = <V1> - <R2>;<<<V1>;}}}
>
Type: output
Hardness: 70

// Using a variable for the boundary value, updating by the loop variable itself
# 571
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#2<=R1<=5;#>;<T1><V2>=<R2#integer;50<=R2<=60;#>;while(<V1> < <V2>){<V1> = <V1> + <V1>;<<<V1>;}}}
>
Type: output
Hardness: 80

# 572
Pretest.Update.Before
>
{<F0>(){<T1#integer#><V1>=<R1#2<=R1<=5;#>;<T1><V2>=<R2#integer;40<=R2<=50;#>;while(<V1> <= <V2>){<V1> = <V1> + <V1>;<<<V1>;}}}
>
Type: output
Hardness: 80

// ------------------------------------------------------------------------
// Pretest.Update.After ************************************ 575

// All Condition.Relational templates are also Update.After (body) templates so far 

// ------------------------------------------------------------------------
// Pretest.PostLoop ************************************ 650

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

# 651
Pretest.PostLoop
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;while(<V1> <= <R2#integer;6<=R2<=9;#>){<<<V1>;<V1> = <V1> + 1;}<<<V1>;}}
>
Type: output
Hardness: 30

# 652
Pretest.PostLoop
>
{<F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;while(<V1> > <R2#integer;1<=R2<=5;#>){<<<V1>;<V1> = <V1> - 1;}<<<V1>;}}
>
Type: output
Hardness: 40

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

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

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

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

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

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

# 659
Pretest.PostLoop
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> != <V2>){<<<V1>;<V1> = <V1> + 1;<<<V2>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 660
Pretest.PostLoop
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V2> != <V1>){<<<V2>;<V2> = <V2> - 1;<<<V1>;}<<<V2>;}}
>
Type: output
Hardness: 40

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

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

# 663
Pretest.PostLoop
>
{<F0>(){<T1#integer#><V1>=<R1#15<=R1<=20;#>;while(<V1> > <R2#integer;1<=R2<=5;#>){<<<V1>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>;}<<<V1>;}}
>
Type: output
Hardness: 40

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

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

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

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

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

# 669
Pretest.PostLoop
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;<V2> = <V1> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>; while(<V1> != <V2>){<<<V1>;<V1> = <V1> + <R2>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 670
Pretest.PostLoop
>
{<F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;<V2> = <V1> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>; while(<V2> != <V1>){<<<V2>;<V2> = <V2> - <R2>;}<<<V2>;}}
>
Type: output
Hardness: 40

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

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

// ------------------------------------------------------------------------
// Pretest.Multiple.Dependent ************************************ 675

// 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
Pretest.Multiple.Dependent
>
{<F0>(){<T1#integer#><V1>=<R1#0<=R1<=2;#>;while(<V1> < <R2#integer;3<=R2<=5;#>){<<<V1>;<V1> = <V1> + 1;}while(<V1> <= <R3#integer;7<=R3<=9;#>){<<<V1>;<V1> = <V1> + 1;}}}
>
Type: output
Hardness: 80

# 676
Pretest.Multiple.Dependent
>
{<F0>(){<T1#integer#><V1>=<R1#0<=R1<=2;#>;while(<V1> < <R2#integer;3<=R2<=5;#>){<<<V1>;<V1> = <V1> + 1;}<T1><V2>=<R3#integer;0<=R3<=2;#>;while(<V2> <= <V1>){<<<V2>;<V2> = <V2> + 1;}}}
>
Type: output
Hardness: 80

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

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

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

# 680
Pretest.Multiple.Dependent
>
{<F0>(){<T1#integer#><V1>=<R1#0<=R1<=2;#>;while(<V1> < <R2#integer;4<=R2<=6;#>){<<<V1>;<V1> = <V1> + 1;}<T1><V2>=<R3#integer;7<=R3<=9;#>;while(<V2> >= <V1>){<<<V2>;<V2> = <V2> - 1;}}}
>
Type: output
Hardness: 80

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

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

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

# 684
Pretest.Multiple.Dependent
>
{<F0>(){<T1#integer#><V1>=<R1#7<=R1<=9;#>;while(<V1> >= <R2#integer;4<=R2<=6;#>){<<<V1>;<V1> = <V1> - 1;}<T1><V2>=<R3#integer;0<=R3<=2;#>;while(<V2> < <V1>){<<<V2>;<V2> = <V2> + 1;}}}
>
Type: output
Hardness: 80

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

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

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

# 688
Pretest.Multiple.Dependent
>
{<F0>(){<T1#integer#><V1>=<R1#3<=R1<=5;#>;while(<V1> > <R2#integer;0<=R2<=2;#>){<<<V1>;<V1> = <V1> - 1;}<T1><V2>=<R3#integer;4<=R3<=6;#>;while(<V2> >= <V1>){<<<V2>;<V2> = <V2> - 1;}}}
>
Type: output
Hardness: 80

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

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


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

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

// ------------------------------------------------------------------------
// Pretest.Multiple.Independent ************************************ 700

// ------------------------------------------------------------------------
// Pretest.Nested.Dependent ************************************ 725

// 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
Pretest.Nested.Dependent
>
{<F0>(){<T1#integer#><V1>=<R1#0<=R1<=2;#>;<T1><V2>;while(<V1> < <R2#integer;3<=R2<=4;#>){<<<V1>;<V2> = <V1>;while(<V2> <= <R2>){<<<V2>;<V2> = <V2> + 1;}<V1> = <V1> + 1;}}}
>
Type: output
Hardness: 80

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

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

# 728
Pretest.Nested.Dependent
>
{<F0>(){<T1#integer#><V1>=<R1#0<=R1<=2;#>;<T1><V2>;while(<V1> < <R2#integer;10<=R2<=12;#>){<<<V1>;<V2> = <R1>;while(<V2> <= <V1>){<<<V2>;<V2> = <V2> + <R3#integer;3<=R3<=4;#>;}<V1> = <V1> + <R3>;}}}
>
Type: output
Hardness: 80

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

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

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

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

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

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

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

# 736
Pretest.Nested.Dependent
>
{<F0>(){<T1#integer#><V1>=<R1#3<=R1<=4;#>;<T1><V2>;while(<V1> > <R2#integer;0<=R2<=2;#>){<<<V1>;<V2> = <R2>;while(<V2> <= <V1>){<<<V2>;<V2> = <V2> + 1;}<V1> = <V1> - 1;}}}
>
Type: output
Hardness: 80

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

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

# 739
Pretest.Nested.Dependent
>
{<F0>(){<T1#integer#><V1>=<R1#10<=R1<=12;#>;<T1><V2>;while(<V1> > <R2#integer;0<=R2<=2;#>){<<<V1>;<V2> = <R2>;while(<V2> <= <R1>){<<<V2>;<V2> = <V2> + <V1>;}<V1> = <V1> - <R3#integer;3<=R3<=4;#>;}}}
>
Type: output
Hardness: 90

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

# 741
Pretest.Nested.Dependent
>
{<F0>(){<T1#integer#><V1>=<R1#3<=R1<=4;#>;<T1><V2>;while(<V1> > <R2#integer;0<=R2<=2;#>){<<<V1>;<V2> = <R1>;while(<V2> >= <V1>){<<<V2>;<V2> = <V2> - 1;}<V1> = <V1> - 1;}}}
>
Type: output
Hardness: 80

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

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

# 744
Pretest.Nested.Dependent
>
{<F0>(){<T1#integer#><V1>=<R1#10<=R1<=12;#>;<T1><V2>;while(<V1> > <R2#integer;0<=R2<=2;#>){<<<V1>;<V2> = <R1>;while(<V2> >= <R2>){<<<V2>;<V2> = <V2> - <V1>;}<V1> = <V1> - <R3#integer;3<=R3<=4;#>;}}}
>
Type: output
Hardness: 90

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

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

// ------------------------------------------------------------------------
// Pretest.Nested.Independent ************************************ 750

// 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
Pretest.Nested.Independent
>
{<F0>(){<T1#integer#><V1>=<R1#0<=R1<=2;#>;<T1><V2>;while(<V1> < <R2#integer;3<=R2<=4;#>){<<<V1>;<V2> = <R3#0<=R3<=2;#>;while(<V2> <= <R4#integer;3<=R4<=5;#>){<<<V2>;<V2> = <V2> + 1;}<V1> = <V1> + 1;}}}
>
Type: output
Hardness: 80

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

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

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

# 754
Pretest.Nested.Independent
>
{<F0>(){<T1#integer#><V1>=<R1#0<=R1<=2;#>;<T1><V2>;while(<V1> < <R2#integer;10<=R2<=12;#>){<<<V1>;<V2> = <R3#0<=R3<=2;#>;while(<V2> <= <R2>){<<<V2>;<V2> = <V2> + <R4#integer;3<=R4<=4;#>;}<V1> = <V1> + <R4>;}}}
>
Type: output
Hardness: 80

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

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

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

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

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

# 760
Pretest.Nested.Independent
>
{<F0>(){<T1#integer#><V1>=<R1#0<=R1<=2;#>;<T1><V2>;while(<V1> < <R2#integer;10<=R2<=12;#>){<<<V1>;<V2> = <R2>;while(<V2> >= <R1>){<<<V2>;<V2> = <V2> - <R3#integer;3<=R3<=4;#>;}<V1> = <V1> + <R3>;}}}
>
Type: output
Hardness: 80

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

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

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

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

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

# 766
Pretest.Nested.Independent
>
{<F0>(){<T1#integer#><V1>=<R1#10<=R1<=12;#>;<T1><V2>;while(<V1> > <R2#integer;0<=R2<=2;#>){<<<V1>;<V2> = <R3#0<=R3<=2;#>;while(<V2> <= <R1>){<<<V2>;<V2> = <V2> + <R4#integer;3<=R4<=4;#>;}<V1> = <V1> - <R4>;}}}
>
Type: output
Hardness: 80

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

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

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

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

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

# 772
Pretest.Nested.Independent
>
{<F0>(){<T1#integer#><V1>=<R1#10<=R1<=12;#>;<T1><V2>;while(<V1> > <R2#integer;0<=R2<=2;#>){<<<V1>;<V2> = <R3#10<=R3<=12;#>;while(<V2> >= <R2>){<<<V2>;<V2> = <V2> - <R4#integer;3<=R4<=4;#>;}<V1> = <V1> - <R4>;}}}
>
Type: output
Hardness: 80

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

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

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



// ------------------------------------------------------------------------
// Pretest.Infinite ************************************ 800





// --------------------------------------------------------------------------
// 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
>
{<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
>
{<F0>(){<T1#integer#><V1>;<V1> = 1;while(<V1> <= 2){<<<V1>;<V1> = <V1> + 1;}}}
>
Type: output
Hardness: 10

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