// Copyright Amruth N. Kumar, amruth@computer.org

// 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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;while(<V1> != <R1>){<<<V1>;<<<R1>;<V1> = <V1> + 1;}}}
>
Type: output
Hardness: 50

# 105
Pretest.Skip
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#3<=R1<=9;#>;<V1> = <V1> - 1;while(<V1> < <R1>){<<<V1>;<V1> = <V1> + 1;}}}
{<T0><F0>(){<T1#integer#><V1>=<R1#2<=R1<=8;#>;while(<V1> < <R2#R2 = R1 + 1;#>){<<<V1>;<V1> = <V1> + 1;}}}
>
Type: output
Hardness: 50

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

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

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

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

# 130
Pretest.PassThrough
>
{<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=9;#>;while(<V1> > 0){<<<V1>;<V1> = <V1> - <R1>;}}}
>
Type: output
Hardness: 60

# 133
Pretest.PassThrough
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=9;#>;<T1><V2>=<R1>;<V2> = <V2> + 1;while(<V1> != <V2>){<<<V1>;<<<V2>;<V1> = <V1> + 1;}}}
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=9;#>;<T1><V2> = <R2#R2 = R1 + 1;#>;while(<V1> != <V2>){<<<V1>;<<<V2>;<V1> = <V1> + 1;}}}
>
Type: output
Hardness: 50

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

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

# 139
Pretest.PassThrough
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
// >
// {<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;<T1><V2>=<R2#integer;1<=R2<=5;#>;while(<V1> > <V2>){<<<V1>;<V1> = <V1> - 1;}}}
// {<T0><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
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> <= <V2>){<<<V1>;<V1> = <V1> + 1;}}}
// {<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> != <V2>){<<<V1>;<V1> = <V1> + 1;}}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> != <V2>){<<<V1>;<V1> = <V1> + 1;<<<V2>;}}} // Simplified for S08
>
Type: output
Hardness: 50

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

// Using a constant to hold boundary value, update by more than one
# 336
Pretest.Condition.Relational
?
Pretest.Update.After
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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;#>;}}}
// {<T0><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
>
{<T0><F0>(){<T1#signedtype#><V1>=<R1#15<=R1<=20;#>;<T1><V2>=<R2#integer;1<=R2<=5;#>;while(<V1> >= <V2>){<<<V1>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>;}}}
// {<T0><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
>
// {<T0><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>;}}}
[<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> = <R4>; while(<V1> != <V2>){<<<V1>;<V1> = <V1> + <R2>;}}}
>
Type: output
Hardness: 70

# 345
Pretest.Condition.Relational
?
Pretest.Update.After
>
// {<T0><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>;}}}
[<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> = <R4>; while(<V2> != <V1>){<<<V2>;<V2> = <V2> - <R2>;}}}
>
Type: output
Hardness: 70

# 346
Pretest.Condition.Relational
?
Pretest.Update.After
>
{<T0><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
>
{<T0><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
// >
// {<T0><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
// >
// {<T0><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
// 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
Pretest.Condition.Changing
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
// {<T0><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>;}}}
[<R1#1<=R1<=5;#>,<R2#integer;1<=R2<=5;#>,<R3#R3 = R1 + 6 * R2;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>=<R3>;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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
// {<T0><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>;}}}
[<R1#1<=R1<=5;#>,<R2#integer;1<=R2<=5;#>,<R3#R3 = R1 + 4 * R2;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>=<R3>;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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> != <V2>)<V1> = <V1> + 1;<<<V1>;}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> != <V2>)<V1> = <V1> + 1;<<<V1>;<<<V2>;}} // Simplified for S08
>
Type: output
Hardness: 60

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

// Using a constant to hold boundary value, update by more than one
# 436
Pretest.Action.Simple
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
// {<T0><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>;}}
[<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> = <R4>;while(<V2> != <V1>)<V2> = <V2> - <R2>;<<<V2>;}}
>
Type: output
Hardness: 80

# 446
Pretest.Action.Simple
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> != <V2>){<V1> = <V1> + 1;<<<V1>;}}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> != <V2>){<V1> = <V1> + 1;<<<V1>;<<<V2>;}}} // Simplified for S08
>
Type: output
Hardness: 30

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

// Using a constant for the boundary value, updating by more than one
# 561
Pretest.Update.Before
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
// {<T0><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>;}}}
[<R1#1<=R1<=5;#>,<R2#integer;2<=R2<=5;#>,<R3#integer;2<=R3<=4;#>,<R4#R4 = R1 + R2 * R3;#>]{<T0><F0>(){<T1#integer#><V1> = <R4>; 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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> <= <V2>){<<<V1>;<V1> = <V1> + 1;}<<<V1>;}}
// {<T0><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
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;<T1><V2>=<R2#integer;1<=R2<=5;#>;while(<V1> > <V2>){<<<V2>;<V2> = <V2> + 1;}<<<V2>;}}
{<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> != <V2>){<<<V1>;<V1> = <V1> + 1;}<<<V1>;}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#integer;6<=R2<=9;#>;while(<V1> != <V2>){<<<V1>;<V1> = <V1> + 1;<<<V2>;}<<<V1>;}} // Simplified for S08
>
Type: output
Hardness: 30

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

// Using a constant to hold boundary value, update by more than one
# 661
Pretest.PostLoop
>
{<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><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>;}}
// {<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><V1>=<R1#15<=R1<=20;#>;<T1><V2>=<R2#integer;1<=R2<=5;#>;while(<V1> >= <V2>){<<<V1>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>;}<<<V1>;}}
// {<T0><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
>
// {<T0><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>;}}
[<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> = <R4>; while(<V1> != <V2>){<<<V1>;<V1> = <V1> + <R2>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 670
Pretest.PostLoop
>
// {<T0><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>;}}
[<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> = <R4>; while(<V2> != <V1>){<<<V2>;<V2> = <V2> - <R2>;}<<<V2>;}}
>
Type: output
Hardness: 40

# 671
Pretest.PostLoop
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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


// REVIEW FROM HERE ONWARDS

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

# 746
Pretest.Nested.Dependent
>
{<T0><F0>(){<T1#signedtype#><V1>=<R1#2<=R1<=3;#>;<T1><V2>;<T1><V3>;while(<V1> > <R2#integer;0<=R2<=1;#>){<<<V1>;<V2> = <V1>;while(<V2> > <R2>){<<<V2>;<V3> = <V2>;while(<V3> > <R2>){<<<V3>;<V3> = <V3> - 1;}<V2> = <V2> - 1;}<V1> = <V1> - 1;}}}
// {<T0><F0>(){<T1#signedtype#><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;}}} // Simplified for S08
>
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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><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
>
{<T0><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
>
{<T0><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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
>
{<T0><F0>(){<T1#signedtype#><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

// Generates error 50% of the time with C++
// //3-levels
// # 774
// Pretest.Nested.Independent
// >
// {<T0><F0>(){<T1#integer#><V1>=<R1#0<=R1<=1;#>;<T1><V2>;<T1><V3>;while(<V1> < <R4#integer;2<=R4<=3;#>){<<<V1>;<V2>=<R2#0<=R2<=1;#>;while(<V2> < <R4>){<<<V2>;<V3> = <R3#0<=R3<=1;#>;while(<V3> < <R4>){<<<V3>;<V3> = <V3> + 1;}<V2> = <V2> + 1;}<V1> = <V1> + 1;}}}
// // {<T0><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;}}} // Simplified for S08
// >
// Type: output
// Hardness: 90

//3-levels
# 775
Pretest.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>=<R1#2<=R1<=3;#>;<T1><V2>;<T1><V3>;while(<V1> > <R4#integer;0<=R4<=1;#>){<<<V1>;<V2>=<R2#2<=R2<=3;#>;while(<V2> > <R4>){<<<V2>;<V3> = <R3#2<=R3<=3;#>;while(<V3> > <R4>){<<<V3>;<V3> = <V3> - 1;}<V2> = <V2> - 1;}<V1> = <V1> - 1;}}}
// {<T0><F0>(){<T1#signedtype#><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;}}} // Simplified for S08
>
Type: output
Hardness: 90



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






// ------------------ Parsons Puzzles --------------------------------------------------------
// DESIGN PRINCIPLES:
//   Use accumulator variables

// Learning objectives:
// Pretest.Parsons.Single - 2000                 
// Pretest.Parsons.Multiple.Independent - 2025   
// Pretest.Parsons.Multiple.Dependent - 2050     
// Pretest.Parsons.Nested.Independent - 2075
// Pretest.Parsons.Nested.Dependent - 2100       


// ------------------------------------------------------------------------
// Pretest.Parsons.Single - 2000                 

// DemoParsons
// while sentinel not found (-1), read numbers, calculate their sum
# 2000
Pretest.Parsons.Single
>
"It reads numbers till the sentinel -1 is found. It computes the sum of all the numbers read and prints it (e.g., it prints 10 after reading 1,3,2,4,-1)."
{<T0><F0>(){
/* Declare <V1> */
<T1#signedtype#><V1#number,numInput,inputNum#>;
/* Declare <V2> */
<T1><V2#sum,total,numTotal#> = 0;
/* Read <V1> and add it to <V2> till -1 is found */
<< "Enter the first number (-1 to end)";
>> <V1>;
while( <V1> != -1 )
{
<V2> = <V2> + <V1>;
<< "Enter the next number (-1 to end)";
>> <V1>;
}
/* Print <V2> */
<< <V2>;
}}
>
Type: parsons
Hardness: 20

// Read numbers till odd number, count the number of even numbers
# 2001
Pretest.Parsons.Single
>
"It reads numbers till an odd number is read. It counts the number of even numbers read and prints it (e.g., it prints 4 after reading the numbers 2,6,8,6,5)."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numInput,inputNum#>;
/* Declare <V2> */
<T1><V2#count,evenCount,countEven#> = 0;
/* Read <V1> till odd number found. Count number of even numbers read */
<< "Enter the first number";
>> <V1>;
while( <V1> % 2 == 0 )
{
<V2> = <V2> + 1;
<< "Enter the next number";
>> <V1>;
}
/* Print <V2> */
<< <V2>;
}}
>
Type: parsons
Hardness: 20

// while 0 not entered, read income and expenses, and report the balance thereafter
# 2002
Pretest.Parsons.Single
>
"It reads numbers till the sum of the numbers is zero (e.g., it reads up to -2 in 3,3,-4,-2,-7,4,3)."
{<T0><F0>(){
/* Declare <V1> */
<T1#signedtype#><V1#number,numInput,inputNum#>;
/* Declare <V2> */
<T1><V2#sum,sumNumbers,numSum#>;
/* Read <V1> and add it to <V2> till <V2> is 0 */
<< "Enter the first number";
>> <V1>;
<V2> = <V1>;
while( <V2> != 0 )
{
<< "Enter the next number";
>> <V1>;
<V2> = <V2> + <V1>;
}
}}
>
Type: parsons
Hardness: 20



// pretest
// while current number not same as previous number...
# 2005
Pretest.Parsons.Single
>
"It reads numbers till the same number appears back to back. It prints the first number to appear twice back to back (e.g., 4 appears back to back in 3,7,5,7,4,4,5 and is printed)."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number1,numInput1,inputNum1#>;
/* Declare <V2> */
<T1><V2#number2,numInput2,inputNum2#>;
/* Read numbers till same number appears back to back */
<< "Enter the first number";
>> <V1>;
<< "Enter the next number";
>> <V2>;
while( <V2> != <V1> )
{
<V1> = <V2>;
<< "Enter the next number";
>> <V2>;
}
/* Print <V2> */
<< <V2>;
}}
>
Type: parsons
Hardness: 30

// posttest
// while current number not the negative of previous number...
# 2006
Pretest.Parsons.Single
>
"It reads numbers till a number and its negative appear back to back. It prints the number and its negative (e.g., 6 and -6 are a number and its negative appearing back to back in 4,3,-5,6,-6,9)."
{<T0><F0>(){
/* Declare <V1> */
<T1#signedtype#><V1#number1,numInput1,inputNum1#>;
/* Declare <V2> */
<T1><V2#number2,numInput2,inputNum2#>;
/* Read numbers till a number (in <V1>) and its negative (in <V2>) appear back to back */
<< "Enter the first number";
>> <V1>;
<< "Enter the next number";
>> <V2>;
while( <V2> != -1 * <V1> )
{
<V1> = <V2>;
<< "Enter the next number";
>> <V2>;
}
/* Print <V1> followed by <V2> */
<< <V1>;
<< <V2>;
}}
>
Type: parsons
Hardness: 30

// while current number not a multiple of previous number...
# 2007
Pretest.Parsons.Single
>
"It reads numbers till a number and its multiple appear back to back. It prints the number and its multiple (e.g., 5 and 10 are a number and its multiple appearing back to back in 3,4,6,5,10,12 )."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number1,numInput1,inputNum1#>;
/* Declare <V2> */
<T1><V2#number2,numInput2,inputNum2#>;
/* Read numbers till a number (in <V1>) and its multiple (in <V2>) appear back to back */
<< "Enter the first number";
>> <V1>;
<< "Enter the next number";
>> <V2>;
while( <V2> % <V1> != 0 )
{
<V1> = <V2>;
<< "Enter the next number";
>> <V2>;
}
/* Print <V1> followed by <V2> */
<< <V1>;
<< <V2>;
}}
>
Type: parsons
Hardness: 30

// while numbers monotonically increasing, read numbers, count number of numbers in monotonic range
# 2008
Pretest.Parsons.Single
>
"It reads numbers while they are monotonically increasing. It prints the first number that breaks the monotonic sequence (e.g., 5 breaks the monotonically increasing sequence in 1,3,3,6,5,7)."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number1,numInput1,inputNum1#>;
/* Declare <V2> */
<T1><V2#number2,numInput2,inputNum2#>;
/* Read numbers while they increase monotonically */
<< "Enter the first number";
>> <V1>;
<< "Enter the next number";
>> <V2>;
while( <V2> >= <V1> )
{
<V1> = <V2>;
<< "Enter the next number";
>> <V2>;
}
/* Print <V2> that broke the monotonic sequence */
<< <V2>;
}}
>
Type: parsons
Hardness: 30


// Read two numbers - min and max, read all the numbers while they are within the range of min-max
// 3, 7 - 4,6,5,9 - read up to and including 5

// Read a number, add all subsequent numbers till that number is encountered again
// 5 1 2 3 4 5 : print 10


// ------------------------------------------------------------------------
// Pretest.Parsons.Multiple.Independent - 2025

// read two factors of a number in increasing order

// compute largest and smallest factor of a number

// Read numbers till -1 and sum them; read additional numbers till the sum is over the first sum

// ------------------------------------------------------------------------
// Pretest.Parsons.Multiple.Dependent - 2050     
// Design: Validate an input using a while loop, use it in condition of second while loop

DemoParsons
// number of contiguous 1s followed by number of contiguous 0s
# 2050
Pretest.Parsons.Multiple.Dependent
>
"It reads a series of 1s and 0s. It counts the number of contiguous 1s followed by the number of contiguous 0s, and prints the counts. For example, for the sequence 1,1,1,0,0,0,0,1,1,0, it prints 3 1s and 4 0s."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numRead,readNum#>;
/* Declare <V2> */
<T1><V2#onesCount,numOnes,totalOnes#> = 0;
/* Declare <V3> */
<T1><V3#zeroCount,numZeroes,totalZeroes#> = 0;
/* Count the number of contiguous 1s followed by contiguous 0s */
>> <V1>;
while( <V1> == 1 )
{
<V2> = <V2> + 1;
>> <V1>;
}
while( <V1> == 0 )
{
<V3> = <V3> + 1;
>> <V1>;
}
/* Print the number of contiguous 1s and 0s */
<< "Number of 1s: " << <V2> << " Number of 0s: " << <V3>;
}}
>
Type: parsons
Hardness: 20

// number not in sequence, followed by ...
# 2051
Pretest.Parsons.Multiple.Dependent
>
"It reads a series of sequential numbers. It detects and prints the first number that is out of sequence, followed by the first number that gets back into sequence. For example, in the sequence 2,3,4,6,3,7,8, 6 is the first number out of sequence (should have been 5) and 7 is the first number back in sequence."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numRead,readNum#>;
/* Declare <V2> */
<T1><V2#counter,numCount,countNum#>;
/* Find and print the first number out of sequence followed by the first number back in sequence */
>> <V1>;
<V2> = <V1>;
while( <V1> == <V2> )
{
>> <V1>;
<V2> = <V2> + 1;
}
<< <V1>;
while( <V1> != <V2> )
{
>> <V1>;
<V2> = <V2> + 1;
}
<< <V1>;
}}
>
Type: parsons
Hardness: 20

// read reservations and cancellations separated by sentinel value
# 2052
Pretest.Parsons.Multiple.Dependent
>
"It reads a series of numbers, each representing the number of people per reservation at a restaurant, followed by a series of numbers representing the number of people per cancellation. Both the series end with -1. After reading both the series, it prints the number of people who still have reservations after subtracting cancellations. For example, in the sequence of numbers 2,4,1,6,-1,1,2,-1, 13 people reserve, and 3 cancel, leaving the restaurant with 10 people."
{<T0><F0>(){
/* Declare <V1> */
<T1#signedtype#><V1#reserve,numReserve,reserveNum#>;
/* Declare <V2> */
<T1><V2#cancel,numCancel,fcancelNum#>;
/* Declare <V3> */
<T1><V3#sum,total,tally#> = 0;
/* Read and sum all the reservations, read and subtract all the cancellations */
<< "Enter the number of people in the next reservation";
>> <V1>;
while( <V1> != -1 )
{
<V3> = <V3> + <V1>;
<< "Enter the number of people in the next reservation";
>> <V1>;
}
<< "Enter the number of people in the next cancellation";
>> <V2>;
while( <V2> != -1 )
{
<V3> = <V3> - <V2>;
<< "Enter the number of people in the next cancellation";
>> <V2>;
}
/* Print the number of people who still have reservation */
<< "Number of people who still have reservation is " << <V3>;
}}
>
Type: parsons
Hardness: 30

// pretest
// Reads two numbers, counts the number of numbers before they appear in a series of numbers
# 2053
Pretest.Parsons.Multiple.Dependent
>
"It inputs the face of a card. It then reads a deck of cards and prints how many cards into the deck it finds the input card, followed by its successor. For example, if the input card is 6, in a deck that starts with the cards 1,8,6,10,7,9,13, it finds the 6 card in 3rd place and 7 card in 5th place."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#selectCard,cardPicked,pickedCard#>;
/* Declare <V2> */
<T1><V2#card,deckCard,cardDeck#>;
/* Declare <V3> */
<T1><V3#count,cardCount,counter#> = 1;
/* Read into <V1> the face of the card to look for in the deck */
<< "Enter the face of the card to look for in the deck (1-13)";
>> <V1>;
/* Find the card and its successor in a deck of cards */
<< "Enter the cards in the deck one at a time";
>> <V2>;
while( <V2> != <V1> )
{
>> <V2>;
<V3> = <V3> + 1;
}
<< "Card " << <V1> << " found in deck at position " << <V3>;
<V1> = <V1> + 1;
>> <V2>;
<V3> = <V3> + 1;
while( <V2> != <V1> )
{
>> <V2>;
<V3> = <V3> + 1;
}
<< "Card " << <V1> << " found in deck at position " << <V3>;
}}
>
Type: parsons
Hardness: 40

// posttest
// Reads min and max temperatures. Counts number of days before max temp is observed,
// followed by number of days maximum temperature is observed.
# 2054
Pretest.Parsons.Multiple.Dependent
>
"It inputs maximum temperature of a season. It then reads a series of daily temperatures and prints the day on which maximum temperature is first observed. Thereafter, it counts and prints the number of contiguous days when maximum temperature is observed. For example, given maximum temperature is 72, in the sequence of daily temperatures 32,40,36,72,72,62,72,-1, maximum temperature is observed on day 4, and is observed for two contiguous days."
{<T0><F0>(){
/* Declare <V1> */
<T1#signedtype#><V1#maxTemp,tempMax,highTemp#>;
/* Declare <V2> */
<T1><V2#dayTemp,tempDay,dailyTemp#>;
/* Declare <V3> */
<T1><V3#day,numDay,dayNum#> = 1;
/* Declare <V4> */
<T1><V4#count,maxCount,countMax#> = 1;
/* Read into <V1> the maximum temperature of the season */
<< "Enter the maximum temperature observed";
>> <V1>;
/* Find the first day with <V1> followed by number of days with <V1> */
<< "Enter the daily temperatures one at a time";
>> <V2>;
while( <V2> != <V1> )
{
>> <V2>;
<V3> = <V3> + 1;
}
>> <V2>;
while( <V2> == <V1> )
{
<V4> = <V4> + 1;
>> <V2>;
}
<< <V1> << " first observed on day " << <V3> << " and for " << <V4> << " days";
}}
>
Type: parsons
Hardness: 40

// monotonically increasing followed by monotonically decreasing
# 2055
Pretest.Parsons.Multiple.Dependent
>
"It reads a sequence of numbers and prints the length of monotonically increasing sequence (each number >= previous number) followed by the length of monotonically decreasing sequence (each number <= previous number). For example, in the sequence 1,3,5,5,4,4,2,3,5, the first monotonically increasing sequence is 4 numbers long (1,3,5,5) and the next monotonically decreasing sequence is 3 numbers long (4,4,2)."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#firstNum,numFirst,first#>;
/* Declare <V2> */
<T1><V2#secondNum,numSecond,second#>;
/* Declare <V3> */
<T1><V3#count,numCount,countNum#> = 1;
/* Read and count monotonically increasing numbers followed by monotpnically decreasing numbers */
<< "Enter the numbers one at a time";
>> <V1>;
>> <V2>;
while( <V2> >= <V1> )
{
<V3> = <V3> + 1;
<V1> = <V2>;
>> <V2>;
}
<< "Length of monotonically increasing numbers is " << <V3>;
<V3> = 0;
while( <V2> <= <V1> )
{
<V3> = <V3> + 1;
<V1> = <V2>;
>> <V2>;
}
<< "Length of monotonically decreasing numbers is " << <V3>;
}}
>
Type: parsons
Hardness: 40


// read a number, compute its largest two factors,
// assuming the number has 2 factors, though.
// Even prime has one factor when you start from num / 2.
// But, not all numbers have 2 factors.
// SO, this may not be a good problem.



// Input an n and a limit and validate them; then compute all powers of n less than m and print them


// read all numbers till a sentinel and add them; now, find smallest square larger than the sum...

// number of numbers read till they added up to 100, followed by number of numbers read till sum reduced to 0?

// read a number that is x, read a number smaller/larger than the first that is y

// Duplicate of 2053, used to test single character variable names
// Reads two numbers, counts the number of numbers before they appear in a series of numbers
# 2074
Pretest.Parsons.Multiple.Dependent
>
"It inputs the face of a card. It then reads a deck of cards and prints how many cards into the deck it finds the input card, followed by its successor. For example, if the input card is 6, in a deck that starts with the cards 1,8,6,10,7,9,13, it finds the 6 card in 3rd place and 7 card in 5th place."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#x,y,z#>;
/* Declare <V2> */
<T1><V2#p,q,r#>;
/* Declare <V3> */
<T1><V3#a,b,c#> = 1;
/* Read into <V1> the face of the card to look for in the deck */
<< "Enter the face of the card to look for in the deck (1-13)";
>> <V1>;
/* Find the card and its successor in a deck of cards */
<< "Enter the cards in the deck one at a time";
>> <V2>;
while( <V2> != <V1> )
{
>> <V2>;
<V3> = <V3> + 1;
}
<< "Card " << <V1> << " found in deck at position " << <V3>;
<V1> = <V1> + 1;
>> <V2>;
<V3> = <V3> + 1;
while( <V2> != <V1> )
{
>> <V2>;
<V3> = <V3> + 1;
}
<< "Card " << <V1> << " found in deck at position " << <V3>;
}}
>
Type: parsons
Hardness: 40

// ------------------------------------------------------------------------
// Pretest.Parsons.Nested.Independent - 2075


// ------------------------------------------------------------------------
// Pretest.Parsons.Nested.Dependent - 2100       
// Design: While a sentinel not met, read a number and validate it using while loop, use accumulator var..
// Read and compute up to first number
// Read and read based on first number


# 2100
Pretest.Parsons.Nested.Dependent
>
"It repeatedly reads a positive number, computes the smallest square greater than that number and prints it (.e., smallest square greater than 5 is 9). It stops when the user enters 0 or a negative number."
{<T0><F0>(){
/* Declare <V1> */
<T1#signedtype#><V1#number,numInput,inputNum#>;
/* Declare <V2> */
<T1><V2#factor,numFactor,factorNum#>;
/* Repeatedly read into <V1>, compute the square larger than it using <V2> and print it */
<< "Enter the number whose nearest larger square is desired";
>> <V1>;
while( <V1> > 0 )
{
<V2> = 1;
while( <V2> * <V2> <= <V1> )
{
<V2> = <V2> + 1;
}
<< "Smallest square larger than " << <V1> << " is " << <V2> * <V2>;
<< "Enter the number whose nearest larger square is desired";
>> <V1>;
}
}}
>
Type: parsons
Hardness: 30

# 2101
Pretest.Parsons.Nested.Dependent
>
"It repeatedly reads a positive number, computes its largest factor and prints it (e.g., largest factor of 21 is 7). It stops when the user enters a number less than 2."
{<T0><F0>(){
/* Declare <V1> */
<T1#signedtype#><V1#number,numInput,inputNum#>;
/* Declare <V2> */
<T2#integer#><V2#factor,numFactor,factorNum#>;
/* Repeatedly read into <V1>, compute its largest factor in <V2> and print it */
<< "Enter the number whose largest factor is desired";
>> <V1>;
while( <V1> > 1 )
{
<V2> = <V1> / 2;
while( <V1> % <V2> != 0 )
{
<V2> = <V2> - 1;
}
<< "Largest factor of " << <V1> << " is " << <V2>;
<< "Enter the number whose largest factor is desired";
>> <V1>;
}
}}
>
Type: parsons
Hardness: 30

# 2102
Pretest.Parsons.Nested.Dependent
>
"It repeatedly reads a positive number, and computes and prints all the powers of 2 less than the number (e.g., all the powers of 2 less than 15 are 1,2,4,8). It stops when the user enters 0 or a negative number."
{<T0><F0>(){
/* Declare <V1> */
<T1#signedtype#><V1#number,numInput,inputNum#>;
/* Declare <V2> */
<T2#integer#><V2#power,numPower,powerNum#>;
/* Repeatedly read into <V1>, compute and print all powers of 2 less than <V1> using <V2> */
<< "Enter a positive number as the upper bound for powers of 2";
>> <V1>;
while( <V1> > 0 )
{
<V2> = 1;
while( <V2> <= <V1> )
{
<< <V2>;
<V2> = <V2> * 2;
}
<< "Enter a positive number as the upper bound for powers of 2";
>> <V1>;
}
}}
>
Type: parsons
Hardness: 30

// pretest
# 2105
Pretest.Parsons.Nested.Dependent
>
"It repeatedly reads a positive number, reads additional numbers till its multiple is found, and prints the number and its multiple. It repeats this until 0 or negative value is entered for the number. For example, while reading the sequence 3,2,4,6,2,5,4,0 it prints 3,6 and 2,4."
{<T0><F0>(){
/* Declare <V1> */
<T1#signedtype#><V1#number,numRead,readNum#>;
/* Declare <V2> */
<T2#integer#><V2#multiple,multipleNum,numMultiple#>;
/* Read into <V1>, then read into <V2> until <V2> is a multiple of <V1>, print both and repeat */
<< "Enter the number whose multiple is desired";
>> <V1>;
while( <V1> > 0 )
{
<< "Enter the number to test for multiple";
>> <V2>;
while( <V2> % <V1> != 0 )
{
<< "Enter the number to test for multiple";
>> <V2>;
}
<< <V2> << " is a multiple of " << <V1>;
<< "Enter the number whose multiple is desired";
>> <V1>;
}
}}
>
Type: parsons
Hardness: 30


// posttest
# 2106
Pretest.Parsons.Nested.Dependent
>
"It reads an initial number, reads and adds together subsequent numbers till it reads the initial number again, and prints the sum. It repeats this until 0 or negative value is entered for the initial number. For example, in the sequence 3,4,6,2,3,5,7,5,0, it sums the numbers 4,6 and 2 between the two 3s and prints their sum, i.e., 12. Similarly, it prints 7 as the sum of numbers between the two 5s."
{<T0><F0>(){
/* Declare <V1> */
<T1#signedtype#><V1#initial,numInitial,initialNum#>;
/* Declare <V2> */
<T2#integer#><V2#number,numAdded,addedNum#>;
/* Declare <V3> */
<T2><V3#sum,total,numTotal#>;
/* Read into <V1>, read and add numbers till <V1> is found again, print sum */
<< "Enter the initial number";
>> <V1>;
while( <V1> > 0 )
{
<V3> = 0;
<< "Enter the number to be added";
>> <V2>;
while( <V2> != <V1> )
{
<V3> = <V3> + <V2>;
<< "Enter the number to be added";
>> <V2>;
}
<< "Sum of numbers between " << <V1> << " is " << <V3>;
<< "Enter the initial number";
>> <V1>;
}
}}
>
Type: parsons
Hardness: 40

# 2107
Pretest.Parsons.Nested.Dependent
>
"It reads a positive number, reads that many more numbers, computes their sum and prints it. It repeats this until 0 or negative number is read. For example, in the sequence 3,2,4,2,2,5,1,0, it first reads 3, then reads 3 more numbers: 2,4,2 and prints their sum 8."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#count,numCount,countNum#>;
/* Declare <V2> */
<T1><V2#sum,total,sumTotal#>;
/* Declare <V3> */
<T1><V3#nextNum,nextInput,nextInt#>;
/* Read into <V1>, read <V1> more numbers, compute their sum and print it */
<< "Enter the number of numbers you want to sum";
>> <V1>;
while( <V1> > 0 )
{
<V2> = 0;
while( <V1> > 0 )
{
<< "Enter the next number you want to sum";
>> <V3>;
<V2> = <V2> + <V3>;
<V1> = <V1> - 1;
}
<< <V2>;
<< "Enter the number of numbers you want to sum";
>> <V1>;
}
}}
>
Type: parsons
Hardness: 40

// DemoParsons
// run-length encoding: print each number and its back to back occurrences till -1
# 2108
Pretest.Parsons.Nested.Dependent
>
"It reads a sequence of numbers, and prints each number and how many times it appears back to back. It repeats this until 0 or negative number is read. For example, for the sequence 3,4,4,1,1,1,5,-1 it prints 3 - 1, 4 - 2, 1 - 3 and 5 - 1."
{<T0><F0>(){
/* Declare <V1> */
<T1#signedtype#><V1#start,numStart,startNum#>;
/* Declare <V2> */
<T1><V2#next,numNext,nextNum#>;
/* Declare <V3> */
<T2#integer#><V3#count,numCount,countNum#>;
/* Read a sequence of numbers, print each number and how many times it appears back to back */
<< "Enter the sequence of numbers";
>> <V1>;
while( <V1> > 0 )
{
<V3> = 1;
>> <V2>;
while( <V2> == <V1> )
{
<V3> = <V3> + 1;
>> <V2>;
}
<< <V1> << " - " << <V3>;
<V1> = <V2>;
}
}}
>
Type: parsons
Hardness: 50

// Read a number, read until sum is 0?



// --------------------------------------------------------------------------

// May be for INTEGRATED_LOOP problems?
// Read two non-negative numbers, the second greater than the first,
// Print all the powers of 2 in between them.
// Uses 2 do-while loops for validation
// Uses a while loop to come up to the first power of 2
// power = 1; while( power < firstNumber ) power *= 2;
// Uses do-while to print the powers that follow
// do{ << power; power *= 2; } while( power < secondNumber );


// ---------------------------Solvelet problems-----------------------------
// WARNING: LAST LINE AND ONLY LAST LINE OF INSTRUCTIONS MUST END WITH DOUBLE-QUOTES


// From parser/template/code/ProblemSpec:
// order*="2":
//   order - temporal order in which this should be attempted
//   * means this attribute is given, do not ask the user for it
// after*="*"*
//   Spatial order for this variable in the actual code, e.g., after="minimum"
//   "*" means any spatial order is fine

// From parser/template/code/problemspec/ProblemSpec:
//   Could have <data>, <control> and <statement> tags, although, it appears, I am only using <data> tag so far..
// From parser/template/code/ProblemSpec:
//   Attributes for data specification include "form", "type", "direction", "control"
// From tutor.wizard.ControlConstants:
//   Value of "control" attribute can be if, ifelse, switch, elsif, multiway, while, for, dowhile - all lowercase, no hyphens
//   These are post-processed by ControlWizard to be Selection or Loop





// PROBLEM TO TEST DEVELOPMENT OF WHILE LOOP TUTOR
// Read a number, print its square until the user says n
# 4100
Pretest.Solve.Condition.Independent
>
"Write a program to read a
<data direction="Input" type="Integer" form="Variable" order*="1" after*="*">number</data>
and compute and print its 
<data direction="Output" type="Integer" form="Variable" control="expression" equation="square = number * number" order*="2"  after*="*">square</data> 
while the user's
<data direction="Anticipated" type="Character" form="Variable" order*="3" after*="*">reply</data>
is yes (y) to whether the user wants to calculate 
<control type="while" order*="4">another</control> square."
{<T0><F0>(){
/** Variable Declaration Section */
/* Statement: Declare Purpose: number Name: <V1> Type: <T1#integer#> */^^<T1#integer#><V1#number#>;^
/* Statement: Declare Purpose: square Name: <V2> Type: <T1#integer#> */^^<T1><V2#square#>;^
/* Statement: Declare Purpose: reply Name: <V3> Type: <T2#char#> */^^<T2><V3#reply#>;^


/* Block: Section Purpose: another Function: Initialization */
/* Statement: Section Purpose: reply Format: Read the response */
/* Statement: Prompt Purpose: reply Format: Do you want to calculate a square (y/n) */^^<< "Do you want to calculate a square (y/n)?";^
/* Statement: Input Purpose: reply */^^>> <V3>;^


/* Block: Section Purpose: another Function: Loop Control: while */
while( <V3> == 'y' )
{
/** Input Section */
/* Statement: Section Purpose: number Format: Read the number */
/* Statement: Prompt Purpose: number Format: Enter number */^^<< "Enter number";^
/* Statement: Input Purpose: number */^^>> <V1>;^

/** Compute Section */
/* Statement: Compute Purpose: square BasedOn: product of <V1> and <V1> */^^<V2> = <V1> * <V1>;^

/** Output Section */
/* Statement: Output Purpose: square Format: Square is 16 */^^<< "Square is " << <V2>;^


/* Block: Section Purpose: another Function: Update */
/* Statement: Section Purpose: reply Format: Read the response */
/* Statement: Prompt Purpose: reply Format: Do you want to calculate a square (y/n) */^^<< "Do you want to calculate a square (y/n)?";^
/* Statement: Input Purpose: reply */^^>> <V3>;^


}



}}
>
Type: code
Hardness: 15
// Number of input variables * 5 + number of output variables * 5 + number of expression operators * 5 + number of intermediate variables * 10




// Read a number> 1, print all the powers of 2 less than that number
# 4200
Pretest.Solve.Condition.Dependent
>
"Write a program to read the 
<data direction="Input" type="Integer" form="Variable" min="2" validate="true" control="dowhile" order*="1" after*="*">limit</data>
(at least 2) and compute and print the smallest
<data direction="Output" type="Integer" form="Variable" control="while" equation="power = power * 2" order*="2"  after*="*">power</data> 
of 2 greater than limit."
{<T0><F0>(){
/** Variable Declaration Section */
/* Statement: Declare Purpose: limit Name: <V1> Type: <T1#integer#> */^^<T1#integer#><V1#limit#>;^
/* Statement: Declare Purpose: power Name: <V2> Type: <T1#integer#> */^^<T1><V2#power#>;^

/** Input Section */

/* Block: Section Purpose: limit Function: validate Control: dowhile */
do{
/* Statement: Section Purpose: limit Format: Read the limit */
/* Statement: Prompt Purpose: limit Format: Enter the limit */^^<< "Enter the limit";^
/* Statement: Input Purpose: limit */^^>> <V1>;^
} while( !(<V1> > 1) );

/** Compute Section */
/* Block: Section Purpose: power Function: compute Control: while */
<V2> = 1;
while( <V2> <= <V1> )
{
   <V2> = <V2> * 2;
}
// /* Statement: Compute Purpose: power BasedOn: product of power and 2 */^^<V3> = <V1> * <V2>;^

/** Output Section */
/* Statement: Output Purpose: power Format: The smallest power of 2 greater than 10 is 16 */^^<< "The smallest power of 2 greater than " << <V1> << " is " << <V2>;^

}}
>
Type: code
Hardness: 15
// Number of input variables * 5 + number of output variables * 5 + number of expression operators * 5 + number of intermediate variables * 10


// Also try printing ALL the powers of 2 up to limit



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

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