// dowhile.txt  Draft templates, with and without input REW 7/27/2010

// This is the master plan for the different loops
// [Single Loop]
//    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
// 
//       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.
// Number of iterations:
//   Zero iterations
//    <  >  
//      far off value
//       boundary value
//    <=  >=
//      far off value
//    ==
//      far off value
//    !=
//      same value
//      Only One iteration
// Multiple iterations
//    <  >
//      far off value
//    <=   >=
//      far off value
//      boundary value
//    ==
//      same value
//    !=
//      n-removed value
//
// --------  do-while Learning Objectives  --------------------
// PostTest.PassThrough -  100 - DONE

// PostTest.Condition.Relational - 200 - DONE

// PostTest.Condition.Arithmetic - 225 - DONE
// PostTest.Condition.Assignment - 250 - DONE

// PostTest.Condition.Logical.Range.Conjunct - 300 - DONE
// PostTest.Condition.Logical.Range.Disjunct - 325 - DONE
// PostTest.Condition.Logical.Discrete.Inclusionary - 350 - DONE
// PostTest.Condition.Logical.Discrete.Exclusionary - 375 - DONE
// PostTest.Condition.Logical.Negation - 400 - DONE

// PostTest.Condition.Changing - 450 - DONE
//     monotonic increasing
//     monotonic decreasing
// PostTest.Condition.No - 475 - DONE

// PostTest.Multiple.Dependent - 500 - DONE
// PostTest.Multiple.Independent - 525 - DONE
// PostTest.Nested.Dependent - 550 - DONE
// PostTest.Nested.Independent - 575 - DONE

//
// ------ Orthogonal Learning Objectives  -----------------------
//
// Condition.Boundary.Legal
// Condition.Boundary.Illegal
//
// ------------------------------------------------------------------
// Templates from other loops not considered here:
//
// PostTest.Initialization.No
// PostTest.Initialization.Yes
//
// PostTest.Condition.Logical
// PostTest.Condition.Relational
//
// PostTest.Action.Empty
// PostTest.Action.Simple
// PostTest.Action.Compound
//
// PostTest.Update.No
// PostTest.Update.Before
// PostTest.Update.After
//
// PostTest.PostLoop
//
// -------Guidelines for creating Templates
// (i) All do-while learning objectives will have problets with and without inputs
// (ii) Problets will be modeled on inputting until a valid value
//
//  A problem like 435 was original sample template for inputs
// See June 19. 2010 email from Amruth for more guidelines

//********************* DO-WHILE LOOPS ************************************

// ------------------------------------------------------------------------
// Iteration.Logic.PostTest.PassThrough - 100
// Intersperse, reversed:
//    Without input:
//       <=, >, ==, !=  (update before vs after printing)
//    With input:
//       <, >=, ==, !=

// Assignment before loop, output and update in loop, condition is greater than.
# 100
PostTest.PassThrough
?
PostTest.Condition.Relational
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;do{<V1> = <V1> - 1;<<<V1>;}while(<V1> > <R2#6<=R2<=9;#>);}}
>
Type: debug_output
Hardness: 30

// Demo problem
// Input and output in loop, condition is greater than, first input clearly passes through
# 101
PostTest.PassThrough
?
PostTest.Condition.Relational
>
[<R1#6<=R1<=9;#>]{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<< <V1>;}while(<V1> >= <R1>);}}
>
Input: "<R2#1<=R2<=5;#>\n<R1>\n<R3#R3 = R2 - 1;#>\n<R4#R4 = R1 + 1;#>\n<R5#1<=R5<=9;#>" 
>
Type: debug_output
Hardness: 30

// Assignment before loop, output and update in loop, condition is less than.
# 102
PostTest.PassThrough
?
PostTest.Condition.Relational
>
{<T0><F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;do{<V1> = <V1> + 1;<<<V1>;}while(<V1> <= <R2#1<=R2<=5;#>);}}
>
Type: debug_output
Hardness: 30

// Assignment before loop, output and update in loop, condition is equal to.
# 103
PostTest.PassThrough
?
PostTest.Condition.Relational
>
{<T0><F0>(){<T1#integer#><V1>=0;do{<<<V1>;>><V1>;}while(<V1> != <R1>);}}
>
Input: "<R1#2<=R1<=9;#>\n<R2#R2 = R1 - 2;#>\n<R3#R3 = R1 + 1;#>\n<R1>\n<R3>\n<R2>"
>
Type: debug_output
Hardness: 30

// Pretest problem
// Assignment before loop, output and update in loop, condition is equal to.
# 104
PostTest.PassThrough
?
PostTest.Condition.Relational
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=9;#>;do{<<<V1>;<V1> = <V1> + 1;}while(<V1> == <R1>);}}
>
Type: debug_output
Hardness: 30

// Output and input in loop, condition is less than, first input is borderline and passes through
# 105
PostTest.PassThrough
?
Condition.Boundary.Illegal,PostTest.Condition.Relational
>
[<R1#5<=R1<=9;#>]{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<< <V1>;}while(<V1> < <R1>);}}
>
Input: "<R1>\n<R2#1<=R2<=4;#>\n<R3#R3 = R1 + 1;#>\n<R5#R5 = R2 - 1;#>\n<R5#1<=R5<=9;#>" 
>
Type: debug_output
Hardness: 35

// Posttest problem
// Assignment before loop, output and update in loop, condition is equal to.
# 106
PostTest.PassThrough
?
PostTest.Condition.Relational
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=9;#>;<T1><V2>=<V1>;do{<<<V1>;<V1> = <V1> / 2;}while(<V1> == <V2>);}}
>
Type: debug_output
Hardness: 30

// Assignment before loop, output and update in loop, condition is equal to.
# 107
PostTest.PassThrough
?
PostTest.Condition.Relational
>
[<R1#1<=R1<=9;#>]{<T0><F0>(){<T1#integer#><V1>;do{>><V1>;<V1> = <V1> + 1;<<<V1>;}while(<V1> == <R1>);}}
>
Input: "<R1>\n<R2#R2 = R1 - 1;#>\n<R3#R3 = R1 * 10;#>\n<R2>\n<R4#R4 = R1 + 5;#>\n<R3>"
>
Type: debug_output
Hardness: 35

// ------------------------------------------------------------------------
// PostTest.Condition.Relational - 200  
// Intersperse, reversed: (at least 3 iterations)
//    Without input:
//       <=, >, ==, !=  (update before vs after printing)
//    With input:
//       <, >=, ==, !=

// Assignment before loop, output and increment in loop, condition is less than.
# 200
PostTest.Condition.Relational
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=6;#>;do{<<<V1>;<V1> = <V1> + 1;}while(<V1> < <R2#R2 = R1 + 3;#>);}}
>
Type: debug_output
Hardness: 30

// Assignment before loop, output and input in loop, condition is less than.
# 201
PostTest.Condition.Relational
?
Condition.Boundary.Illegal
>
[<R1#1<=R1<=3;#>,<R2#7<=R2<=9;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;do{<<<V1>;>><V1>;}while(<V1> < <R2>);}}
>
Input: "<R3#4<=R3<=6;#>\n<R1>\n<R2>\n<R4#R4 = R2 - 1;#>\n<R5#R5 = R2 + 1;#>"
>
Type: debug_output
Hardness: 35

// Assignment before loop, output and decrement in loop, condition is greater than.
# 202
PostTest.Condition.Relational 
>
{<T0><F0>(){<T1#signed#><V1>=<R1#7<=R1<=9;#>;do{<V1> = <V1> - 1;<<<V1>;}while(<V1> >= <R2#R2 = R1 - 3;#>);}}
>
Type: debug_output
Hardness: 30

// Declaration before loop, input in loop, output after loop, condition is less than or equal.
# 203
PostTest.Condition.Relational 
?
Condition.Boundary.Legal
>
[<R1#7<=R1<=9;#>]{<T0><F0>(){<T1#integer#><V1>;do{>><V1>;}while(<V1> <= <R1>);<<<V1>;}}
>
Input:  "<R2#R2 = R1 - 3;#>\n<R1>\n<R3#R3 = R1 + 2;#>\n<R4#1<=R4<=3;#>\n<R5#4<=R5<=6;#>" 
>
Type: debug_output
Hardness: 35

// Pretest problem
// Assignment before loop, increment by many and output in loop, condition is less than.
# 204
PostTest.Condition.Relational 
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;do{<V1> = <V1> + <R2#2<=R2<=5;#>;<<<V1>;}while(<V1> <= <R3#R3 = R1 + R2 * 3;#>);}}
>
Type: debug_output
Hardness: 35

// Declaration before loop, input and output in loop, condition is greater than.
# 205
PostTest.Condition.Relational 
?
Condition.Boundary.Illegal
>
[<R1#1<=R1<=5;#>]{<T0><F0>(){<T1#integer#><V1>;do{>><V1>;<<<V1>;}while(<V1> > <R1>);}}
>
Input: "<R2#6<=R2<=8;#>\n<R3#9<=R3<=12;#>\n<R4#R4 = R1 + 1;#>\n<R1>\n<R5#R5 = R1 - 1;#>\n0" 
>
Type: debug_output
Hardness: 35

// Posttest problem
// Assignment before loop, decrement by many and output in loop, condition is greater than.
# 206
PostTest.Condition.Relational 
?
Condition.Boundary.Illegal
>
[<R1#1<=R1<=5;#>,<R2#2<=R2<=5;#>,<R3#R3 = R1 + R2 * 3;#>]{<T0><F0>(){<T1#signed#><V1>=<R3>;do{<V1> = <V1> - <R2>;<<<V1>;}while(<V1> > <R1>);}}
>
Type: debug_output
Hardness: 35

// Declaration before loop, input in loop, output after loop, condition is greater than or equal.
# 207
PostTest.Condition.Relational 
?
Condition.Boundary.Legal
>
[<R1#1<=R1<=5;#>]{<T0><F0>(){<T1#integer#><V1>;do{>><V1>;}while(<V1> >= <R1>);<<<V1>;}}
>
Input: "<R2#R2 = R1 + 3;#>\n<R1>\n<R3#R3 = R1 * 2;#>\n<R4#R4 = R1 - 1;#>\n<R5#6<=R5<=9;#>\n13" 
>
Type: debug_output
Hardness: 35

// ------------------------------------------------------------------------
// PostTest.Condition.Arithmetic 
// Valid in C++ but syntax error in Java and C#

// Interspersed:
//  Without input vs With input to variable involved in expression:
//      +, -, *, /

// Assignment before loop, output and  decrement in loop, condition variable.
# 225
PostTest.Condition.Arithmetic
>
{<T0><F0>(){<T1#signed#><V1>=<R1#2<=R1<=4;#>;do{<<<V1>;<V1> = <V1> - 1;}while(<V1>);}}
>
Type: debug_output
Hardness: 30

// Input is read and output is done in loop, condition is variable.
# 226
PostTest.Condition.Arithmetic
>
{<T0><F0>(){<T1#integer#><V1>;do{>><V1>;<<<V1>;}while(<V1>);}}
>
Input: "<R1#2<=R1<=4;#>\n<R2#6<=R2<=9;#>\n<R3#R3 = R2 - R1;#>\n0\n<R2>\n<R1>" 
>
Type: debug_output
Hardness: 30

// Pretest problem
// Assignments before loop, output and  increment in loop, condition is constant minus variable.
# 227
PostTest.Condition.Arithmetic
>
{<T0><F0>(){<T1#signed#><V1>=<R1#integer;1<=R1<=6;#>;
do{<<<V1>;<V1> = <V1> + 1;}while(<R2#integer;R2 = R1 + 3;#> - <V1>);}}
>
Type: debug_output
Hardness: 30

// Input is read and output is done in loop, condition is constant minus variable.
# 228
PostTest.Condition.Arithmetic
>
[<R1#integer;6<=R1<=9;#>]{<T0><F0>(){<T1#integer#><V1>;do{>><V1>;<<<V1>;}while(<R1> - <V1>);}}
>
Input: "<R2#2<=R2<=5;#>\n<R3#R3 = R1 - R2;#>\n<R1>\n0\n<R2>\n2" 
>
Type: debug_output
Hardness: 30

// Posttest problem
// Assignments before loop, decrement and output in loop, condition is variable minus constant.
# 229
PostTest.Condition.Arithmetic
>
{<T0><F0>(){<T1#signed#><V1>=<R1#integer;4<=R1<=9;#>;
do{<V1> = <V1> - 1;<<<V1>;}while(<V1> - <R2#integer;R2 = R1 - 3;#>);}}
>
Type: debug_output
Hardness: 30

// Demo problem
// Input is read and output is done in loop, condition is variable minus constant.
# 230
PostTest.Condition.Arithmetic
>
[<R1#integer;1<=R1<=4;#>]{<T0><F0>(){<T1#signed#><V1>;do{>><V1>;}while(<V1> - <R1>);<<<V1>;}}
>
Input: "<R2#5<=R2<=8;#>\n9\n<R3#R3 = R1 + 1;#>\n<R1>\n<R2>\n2"  
>
Type: debug_output
Hardness: 30

# 231
PostTest.Condition.Arithmetic
>
[<R1#2<=R1<=4;#>,<R2#R2 = R1 * 3;#>]{<T0><F0>(){<T1#signed#><V1>=<R2>;do{<<<V1>;<V1> = <V1> - <R1>;}while(<V1> * <R3#-4<=R3<=-1;#>);}}
>
Type: debug_output
Hardness: 35

# 232
PostTest.Condition.Arithmetic
>
{<T0><F0>(){<T1#signed#><V1>;do{>><V1>;<<<V1>;}while(<V1> * <R3#-4<=R3<=-1;#>);}}
>
Input: "<R1#1<=R1<=3;#>\n<R2#4<=R2<=6;#>\n0\n<R3#7<=R3<=9;#>\n<R4#10<=R4<=12;#>\n<R2>"
>
Type: debug_output
Hardness: 35

# 233
PostTest.Condition.Arithmetic
>
[<R1#2<=R1<=4;#>,<R2#R2 = R1 * 3;#>]{<T0><F0>(){<T1#signed#><V1>=<R2>;do{<V1> = <V1> - <R1>;<<<V1>;}while(<V1> * <V1>);}}
>
Type: debug_output
Hardness: 30

# 234
PostTest.Condition.Arithmetic
>
{<T0><F0>(){<T1#signed#><V1>;do{>><V1>;<<<V1>;}while(<V1> * <V1>);}}
>
Input: "<R1#1<=R1<=3;#>\n<R2#10<=R2<=12;#>\n0\n<R3#4<=R3<=6;#>\n<R4#7<=R4<=9;#>\n<R5#13<=R5<=15;#>"
>
Type: debug_output
Hardness: 30

// ------------------------------------------------------------------------
// PostTest.Condition.Assignment 
// Infinite loop in C++, 
// Syntax error in Java, and C#
// Variation in what is assigned to variable:
//    const value, variable to which value was input in loop, 
//    expression involving variable to which value was not/was input in loop

// Assignment before loop, output and increment in loop
# 250
PostTest.Condition.Assignment
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=9;#>;ido{<<<V1>;<V1> = <V1> + 1;}while(<V1> = <R1>);}}
>
Type: debug_output
Hardness: 30

// Input is read and output is done in loop
# 251
PostTest.Condition.Assignment
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>,<R4#10<=R4<=12;#>,<R5#13<=R5<=15;#>]
{<T0><F0>(){<T1#integer#><V1>;ido{>><V1>;<<<V1>;}while(<V1> = <R1>);}}
>
Input:  "<R2>\n<R1>\n<R4>\n<R3>\n<R5>\n<R1>"
>
Type: debug_output
Hardness: 30

// Pretest problem
// Assignment before loop, increment and output in loop
# 252
PostTest.Condition.Assignment 
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=9;#>;ido{<V1> = <V1> + <R2#2<=R2<=4;#>;<<<V1>;}while(<V1> = <R3#12<=R3<=19;#>);}}
>
Type: debug_output
Hardness: 30

// Variable assigned before loop, output is done and input is read in loop
# 253
PostTest.Condition.Assignment
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>,<R4#10<=R4<=12;#>,<R5#13<=R5<=15;#>]
{<T0><F0>(){<T1#signed#><V1> = <R1>;ido{<<<V1>;>><V1>;}while(<V1> = <R3>);}}
>
Input: "<R2>\n<R5>\n<R3>\n<R4>\n<R1>\n<R3>"
>
Type: debug_output
Hardness: 30

// Assignment before loop, decrement and output in loop
# 254
PostTest.Condition.Assignment 
>
{<T0><F0>(){<T1#signed#><V1>=<R1#6<=R1<=9;#>;ido{<<<V1>;<V1> = <V1> - 1;}while(<V1> = <R2#1<=R2<=5;#>);}}
>
Type: debug_output
Hardness: 30

// Demo problem
// Input is read and and incremented and output is done in loop
# 255
PostTest.Condition.Assignment
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>,<R4#10<=R4<=12;#>,<R5#R5 = R2 - R1;#>]
{<T0><F0>(){<T1#signed#><V1>;ido{>><V1>;<V1> = <V1>+<R1>;<<<V1>;}while(<V1> = <R2>);}}
>
Input: "<R2>\n<R4>\n<R5>\n<R3>\n<R1>\n<R2>\n<R5>"
>
Type: debug_output
Hardness: 30

// Posttest problem
// Assignment before loop, output and decrement in loop
# 256
PostTest.Condition.Assignment 
>
{<T0><F0>(){<T1#signed#><V1>=<R1#12<=R1<=19;#>;ido{<V1> = <V1> - <R2#2<=R2<=5;#>;<<<V1>;}while(<V1> = <R3#1<=R3<=5;#>);}}
>
Type: debug_output
Hardness: 30

// Input is read and and incremented and output is done in loop
# 257
PostTest.Condition.Assignment
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>,<R4#10<=R4<=12;#>,<R5#R5 = R2 + R1;#>]
{<T0><F0>(){<T1#signed#><V1>;ido{>><V1>;<V1> = <V1> - <R1>;<<<V1>;}while(<V1> = <R2>);}}
>
Input: "<R5>\n<R3>\n<R1>\n<R4>\n<R5>\n<R2>"
>
Type: debug_output
Hardness: 30

// ------------------------------------------------------------------------
// PostTest.Condition.Logical.Range.Conjunct - 300
// Intersperse:
//   Without input
//      Increment by 1
//      Decrement by 1
//      Increment by many
//      Decrement by many
//   With input
//      Ends with illegal low
//      Ends with illegal high
//      Ends with boundary illegal low
//      Ends with boundary illegal high



// Variable is output and incremented in the loop
# 300
PostTest.Condition.Logical.Range.Conjunct
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=6;#>;
do{<<<V1>;<V1> = <V1> + 1;}while(<V1> >= <R1> && <V1> <= <R2#R2 = R1 + 3;#>);}}
>
Type: debug_output
Hardness: 30

// Demo problem
// Variable is assigned before, output and input in the loop, Ends with illegal high
# 301
PostTest.Condition.Logical.Range.Conjunct
>
[<R1#4<=R1<=7;#>,<R2#R2 = R1 + 2;#>,<R3#R3 = R1 - 2;#>]{<T0><F0>(){<T1#signed#><V1>=<R1>;
do{<< <V1>;>> <V1>;}while(<V1> >= <R3> && <V1> <= <R2>);}}
>
Input: "<R4#R4 = R1 - 1;#>\n<R5#R5 = R1 + 1;#>\n<R6#R6 = R1 + 3;#>\n<R2>\n<R1>\n<R7#R7 = R1 - 3;#>" 
>
Type: debug_output
Hardness: 40

// Variable is decremented and output in the loop
# 302
PostTest.Condition.Logical.Range.Conjunct
>
{<T0><F0>(){<T1#signed#><V1>=<R1#4<=R1<=9;#>;
do{<V1> = <V1> - 1;<<<V1>;}while(<V1> > <R2#R2 = R1 - 4;#> && <V1> <= <R1>);}}
>
Type: debug_output
Hardness: 30

// Variable is assigned before, output and input in the loop, Ends with illegal low
# 303
PostTest.Condition.Logical.Range.Conjunct
>
[<R1#4<=R1<=6;#>,<R2#R2 = R1 + 3;#>,<R3#R3 = R1 - 3;#>]{<T0><F0>(){<T1#signed#><V1>=<R1>;
do{>> <V1>;}while(<V1> > <R3> && <V1> < <R2>);<< <V1>;}}
>
Input: "<R4#R4 = R1 - 2;#>\n<R5#R5 = R1 + 2;#>\n0\n<R2>\n<R1>\n<R1>" 
>
Type: debug_output
Hardness: 40

// Variable is incremented by many and output in the loop
# 304
PostTest.Condition.Logical.Range.Conjunct
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;
do{<V1> = <V1> + <R2#2<=R2<=5;#>;<<<V1>;}while(<V1> >= <R1> && <V1> < <R3#R3 = R1 + 4 * R2;#>);}}
>
Type: debug_output
Hardness: 30

// Pretest problem
// Variable is input in the loop and output after loop, Ends with boundary illegal low
# 305
PostTest.Condition.Logical.Range.Conjunct
?
Condition.Boundary.Illegal
>
[<R1#7<=R1<=9;#>,<R2#1<=R2<=3;#>]{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;}while(<V1> > <R2> && <V1> <= <R1>);<< <V1>;}}
>
Input: "<R3#R3 = R1 - 2;#>\n<R4#R4 = R2 + 2;#>\n<R2>\n<R1>\n<R5#R2 < R5 < R1;#>\n0" 
>
Type: debug_output
Hardness: 45

// Variable is decremented by many and output in the loop
# 306
PostTest.Condition.Logical.Range.Conjunct
>
[<R1#1<=R1<=4;#>,<R2#2<=R2<=5;#>,<R3#R3 = R1 + 4 * R2;#>]{<T0><F0>(){<T1#signed#><V1>=<R3>;
do{<V1> = <V1> - <R2>;<<<V1>;}while(<V1> > <R1> && <V1> <= <R3>);}}
>
Type: debug_output
Hardness: 30

// Posttest problem
// Variable is input and output in the loop, Ends with boundary illegal high
# 307
PostTest.Condition.Logical.Range.Conjunct
?
Condition.Boundary.Illegal
>
[<R1#1<=R1<=3;#>,<R2#7<=R2<=9;#>]{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<< <V1>;}while(<V1> >= <R1> && <V1> < <R2>);}}
>
Input: "<R3#R1 <= R3 < R2;#>\n<R4#R4 = R2 - 1;#>\n<R5#R5 = R1 + 1;#>\n<R2>\n<R1>\n<R3>" 
>
Type: debug_output
Hardness: 45

// ------------------------------------------------------------------------
// PostTest.Condition.Logical.Range.Disjunct - 325  
// Intersperse:
//   Without input
//      Increment by 1 in lower range
//      Decrement by 1 in upper range
//      Increment by many in lower range
//      Decrement by many in upper range
//   With input
//      Ends with illegal 
//      Ends with boundary lower range upper limit
//      Ends with boundary upper range lower limit

// Variable is output and incremented in the loop
# 325
PostTest.Condition.Logical.Range.Disjunct
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=3;#>;
do{<<<V1>;<V1> = <V1> + 1;}while(<V1> < <R2#R2 = R1 + 3;#> || <V1> >= <R3#7<=R3<=9;#>);}}
>
Type: debug_output
Hardness: 30

// Demo problem
// Variable is input in the loop and output after loop, Ends with illegal
# 326
PostTest.Condition.Logical.Range.Disjunct
?
Condition.Boundary.Legal
>
[<R1#7<=R1<=9;#>,<R2#R2 = R1 - 3;#>]{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<< <V1>;}while(<V1> <= <R2> || <V1> > <R1>);}}
>
Input: "<R3#R3 = R2 - 2;#>\n<R4#R4 = R1 + 1;#>\n<R2>\n<R5#R2 < R5 < R1;#>\n0\n<R1>" 
>
Type: debug_output
Hardness: 45

// Variable is decremented and output in the loop
# 327
PostTest.Condition.Logical.Range.Disjunct
>
{<T0><F0>(){<T1#signed#><V1>=<R1#7<=R1<=9;#>;
do{<V1> = <V1> - 1;<<<V1>;}while(<V1> <= <R2#1<=R2<=3;#> || <V1> > <R3#R3 = R1 - 3;#>);}}
>
Type: debug_output
Hardness: 30

// Pretest problem
// Variable is input and output in the loop, Ends with boundary lower range upper limit
# 328
PostTest.Condition.Logical.Range.Disjunct
?
Condition.Boundary.{Illegal,Legal}
>
[<R1#4<=R1<=6;#>,<R2#R2 = R1 + 3;#>]{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<< <V1>;}while(<V1> < <R1> || <V1> >= <R2>);}}
>
Input: "<R3#R3 = R2 + 1;#>\n<R4#R4 = R1 - 2;#>\n<R2>\n<R5#R5 = R1 - 4;#>\n<R1>\n<R6#R1 < R6 < R2;#>\n<R7#R7 = R6 * 2;#>" 
>
Type: debug_output
Hardness: 45

// Variable is incremented by 2-4 and output in the loop
# 329
PostTest.Condition.Logical.Range.Disjunct
>
[<R1#1<=R1<=3;#>,<R2#2<=R2<=4;#>,<R3#R3 = R1 + R2 * 3;#>,<R4#R4 = R1 + R2 * 5;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;
do{<V1> = <V1> + <R2>;<<<V1>;}while(<V1> < <R3> || <V1> >= <R4>);}}
>
Type: debug_output
Hardness: 35

// Posttest problem
// Variable is assigned before, output and input in the loop, Ends with boundary upper range lower limit
# 330
PostTest.Condition.Logical.Range.Disjunct
?
Condition.Boundary.{Illegal,Legal}
>
[<R1#4<=R1<=6;#>,<R2#R2 = R1 - 2;#>,<R3#R3 = R1 + 2;#>]{<T0><F0>(){<T1#signed#><V1>=<R1>;
do{<< <V1>;>> <V1>;}while(<V1> <= <R2> || <V1> > <R3>);}}
>
Input: "<R4#R4 = R2 - 1;#>\n<R5#R5 = R3 + 1;#>\n<R2>\n<R6#R6 = R3 + 3;#>\n<R3>\n<R7#R7 = R2 - 2;#>\n<R8#R2 < R8 < R3;#>" 
>
Type: debug_output
Hardness: 45

// Variable is decremented by 2-4 and output in the loop
# 331
PostTest.Condition.Logical.Range.Disjunct
>
[<R1#R1 = 0;#>,<R2#2<=R2<=4;#>,<R3#R3 = R1 + R2 * 3;#>,<R4#R4 = R1 + R2 * 5;#>,<R5#R5 = R1 + R2 * 8;#>]{<T0><F0>(){<T1#signed#><V1>=<R5>;
do{<<<V1>;<V1> = <V1> - <R2>;}while(<V1> <= <R3> || <V1> > <R4>);}}
>
Type: debug_output
Hardness: 35

// ------------------------------------------------------------------------
// PostTest.Condition.Logical.Discrete.Inclusionary 
// Intersperse:
//   Without input (discrete values are uniformly spaced)
//      Increment by many to visit discrete values 
//      Decrement by many to visit discrete values
//      Multiply to step between various products of a factor (increasing)
//   With input - randomly visits randomly spaced discrete values
//      Ends with illegal over
//      Ends with illegal under
//      Ends with illegal in between

// Variable is incremented by 3-5 and output in the loop
# 350
PostTest.Condition.Logical.Discrete.Inclusionary
>
[<R1#1<=R1<=3;#>,<R2#3<=R2<=5;#>]
{<T0><F0>(){<T1#integer#><V1>=<R1>;do{<V1> = <V1> + <R2>;<<<V1>;}
while( <R3#R3 = R1 + R2;#> == <V1> || <R4#R4 = R1 + 2 * R2;#> == <V1> || <R5#R5 = R1 + 3 * R2;#> == <V1>);}}
>
Type: debug_output
Hardness: 30

// Demo problem
// Variable is input in the loop and output after loop
# 351
PostTest.Condition.Logical.Discrete.Inclusionary
>
[<R1#1<=R1<=3;#>,<R2#3<=R2<=5;#>,<R3#R3 = R1 + R2;#>,<R4#R4 = R1 + R2 * 2;#>,<R5#R5 = R1 + R2 * 3;#>]
{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;}
while(<R3> == <V1> || <R4> == <V1> || <R5> == <V1>);<< <V1>;}}
>
Input: "<R4>\n<R3>\n<R1>\n<R5>\n<R2>\n<R6#R3 < R6 < R4;#>\n<R7#R4 < R7 < R5;#>\n"
>
Type: debug_output
Hardness: 40

// Variable is decremented by 3-5 and output in the loop
# 352
PostTest.Condition.Logical.Discrete.Inclusionary
>
[<R1#1<=R1<=3;#>,<R2#3<=R2<=5;#>,<R6#R6 = R1 + 4 * R2;#>]
{<T0><F0>(){<T1#signed#><V1>=<R6>;do{<<<V1>;<V1> = <V1> - <R2>;}
while(<R3#R3 = R1 + R2;#> == <V1> || <R4#R4 = R1 + 2 * R2;#> == <V1> || <R5#R5 = R1 + 3 * R2;#> == <V1>);}}
>
Type: debug_output
Hardness: 30

// Pretest problem
// Variable is input and output in the loop
# 353
PostTest.Condition.Logical.Discrete.Inclusionary
>
[<R1#1<=R1<=3;#>,<R2#7<=R2<=9;#>,<R3#13<=R3<=15;#>]{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<< <V1>;}
while( <R1> == <V1> || <R2> == <V1> || <R3> == <V1> );}}
>
Input: "<R3>\n<R1>\n<R2>\n<R4#R1 < R4 < R2;#>\n<R1>\n<R5#R2 < R5 < R3;#>\n"
>
Type: debug_output
Hardness: 40

// Variable is printed and changed in the loop
# 354
PostTest.Condition.Logical.Discrete.Inclusionary
>
[<R1#2<=R1<=5;#>,<R2#R2 = R1 * R1;#>,<R3#R3 = R2 * R1;#>,<R4#R4 = R3 * R1;#>]
{<T0><F0>(){<T1#integer#><V1>=<R4>;do{<<<V1>;<V1> = <V1> / <R1>;}
while(<R1> == <V1> || <R2> == <V1> || <R3> == <V1>);}}
>
Type: debug_output
Hardness: 30

// Posttest problem
// Variable is assigned before, input, incremented and output in the loop
# 355
PostTest.Condition.Logical.Discrete.Inclusionary
>
[<R1#6<=R1<=9;#>,<R2#3<=R2<=5;#>,<R3#R3 = R1 - R2;#>,<R4#R4 = R1 + R2;#>]{<T0><F0>(){<T1#signed#><V1>;do{>> <V1>;<V1> = <V1> + <R2>;<< <V1>;}
while( <R3> == <V1> || <R1> == <V1> || <R4> == <V1> );}}
>
Input: "<R1>\n<R3>\n<R5#R5 = R3 - R2;#>\n<R2>\n<R1>\n<R6#R3 < R6 < R1;#>\n<R7#R1 < R7 < R4;#>"
>
Type: debug_output
Hardness: 40

// ------------------------------------------------------------------------
// PostTest.Condition.Logical.Discrete.Exclusionary - 375 
// Intersperse:
//   Without input (discrete values are uniformly spaced)
//      Increment by one to visit discrete values 
//      Decrement by one to visit discrete values
//      Increment by many to visit discrete values 
//      Decrement by many to visit discrete values
//   With input - randomly visits randomly spaced discrete values
//      output after loop
//      input and output in loop
//      output and input in loop

// Variable is output and incremented in the loop, condition is conjunction of three not equals
# 375
PostTest.Condition.Logical.Discrete.Exclusionary
>
[<R1#1<=R1<=3;#>,<R2#3<=R2<=5;#>,<R6#0<=R6<=2;#>,<R7#R7 = R1 + R2 * R6;#>]
{<T0><F0>(){<T1#integer#><V1>=<R7>;do{<<<V1>;<V1> = <V1> + 1;}
while(<V1> != <R3#R3 = R1 + R2;#> && <V1> != <R4#R4 = R1 + R2 * 2;#> && <V1> != <R5#R5 = R1 + R2 * 3;#>);}}
>
Type: debug_output
Hardness: 30

// Demo problem
// Variable is input in the loop and output after loop
# 376
PostTest.Condition.Logical.Discrete.Exclusionary
>
[<R1#1<=R1<=3;#>,<R2#3<=R2<=5;#>,<R3#R3 = R1 + R2;#>,<R4#R4 = R1 + R2 * 2;#>,<R5#R5 = R1 + R2 * 3;#>]
{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;}
while(<V1> != <R3> && <V1> != <R4> && <V1> != <R5>);<< <V1>;}}
>
Input: "<R1>\n<R6#R3 < R6 < R4;#>\n<R2>\n<R7#R4 < R7 < R5;#>\n<R4>\n<R8#R8 = R5 + R2;#>\n<R3>\n<R5>\n" 
>
Type: debug_output
Hardness: 40

// Variable is decremented and output in the loop
# 377
PostTest.Condition.Logical.Discrete.Exclusionary
>
[<R1#1<=R1<=3;#>,<R2#3<=R2<=5;#>,<R6#2<=R6<=4;#>,<R7#R7 = R1 + R2 * R6;#>]
{<T0><F0>(){<T1#signed#><V1>=<R7>;do{<V1> = <V1> - 1;<<<V1>;}
while(<V1> != <R3#R3 = R1 + R2;#> && <V1> != <R4#R4 = R1 + R2 * 2;#> && <V1> != <R5#R5 = R1 + R2 * 3;#>);}}
>
Type: debug_output
Hardness: 30

// Pretest problem
// Variable is input and output in the loop
# 378
PostTest.Condition.Logical.Discrete.Exclusionary
>
[<R1#1<=R1<=3;#>,<R2#7<=R2<=9;#>,<R3#13<=R3<=15;#>]{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<< <V1>;}
while(<V1> != <R1> && <V1> != <R2> && <V1> != <R3>);}}
>
Input: "<R4#R4 = R2 - 1;#>\n<R5#R5 = R1 + 2;#>\n<R6#R6 = R3 - 2;#>\n<R1>\n<R2>\n<R7#R7 = R2 + 1;#>\n"
>
Type: debug_output
Hardness: 40

// Variable is incremented by 3-5 and output in the loop
# 379
PostTest.Condition.Logical.Discrete.Exclusionary
>
[<R1#1<=R1<=3;#>,<R2#3<=R2<=5;#>]
{<T0><F0>(){<T1#integer#><V1>=<R1>;do{<V1> = <V1> + <R2>;<<<V1>;}
while(<V1> != <R3#R3 = R1 + R2 - 2;#> && <V1> != <R4#R4 = R1 + 2 * R2 - 1;#> && <V1> != <R5#R5 = R1 + 3 * R2;#>);}}
>
Type: debug_output
Hardness: 35

// Posttest problem
// Variable is assigned before, output and input in the loop
# 380
PostTest.Condition.Logical.Discrete.Exclusionary
>
[<R1#6<=R1<=9;#>,<R2#3<=R2<=5;#>,<R3#R3 = R1 - R2;#>,<R4#R4 = R1 + R2;#>]{<T0><F0>(){<T1#signed#><V1>=<R1>;do{<< <V1>;>> <V1>;}
while(<V1> != <R3> && <V1> != <R1> && <V1> != <R4>);}}
>
Input: "<R5#R5 = R3 - 1;#>\n<R6#R6 = R4 + 3;#>\n<R7#R7 = R1 + 2;#>\n<R3>\n<R8#R8 = R1 - 1;#>\n<R2>\n<R4>" 
>
Type: debug_output
Hardness: 40

// Variable is decremented by 3-5 and output in the loop
# 381
PostTest.Condition.Logical.Discrete.Exclusionary
>
[<R1#1<=R1<=3;#>,<R2#3<=R2<=5;#>,<R6#R6 = R1 + 3 * R2;#>]
{<T0><F0>(){<T1#signed#><V1>=<R6>;do{<<<V1>;<V1> = <V1> - <R2>;}
while(<V1> != <R3#R3 = R1 + R2;#> && <V1> != <R4#R4 = R1 + 2 * R2 - 2;#> && <V1> != <R5#R5 = R6 - 1;#>);}}
>
Type: debug_output
Hardness: 35

// ------------------------------------------------------------------------
// PostTest.Condition.Logical.Negation - 400  
// EXACT opposite of Condition.Relational
// Intersperse:
//   Without input
//      Increment by 1, ! >
//      Decrement by 1, ! <
//      Increment by many, ! >=
//      Decrement by many, ! <=
//   With input
//      Ends with illegal over, ! >
//      Ends with illegal under, ! <
//      Ends with boundary, ! >=
//      Ends with boundary, ! <=


// Assignment before loop, output and increment in loop, condition is less than.
# 400
PostTest.Condition.Logical.Negation
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=6;#>;do{<<<V1>;<V1> = <V1> + 1;}while(!(<V1> >= <R2#R2 = R1 + 3;#>));}}
>
Type: debug_output
Hardness: 30

// Assignment before loop, output and input in loop, condition is less than.
# 401
PostTest.Condition.Logical.Negation
?
Condition.Boundary.Illegal
>
[<R1#1<=R1<=3;#>,<R2#7<=R2<=9;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;do{<<<V1>;>><V1>;}while(!(<V1> >= <R2>));}}
>
Input: "<R3#4<=R3<=6;#>\n<R1>\n<R2>\n<R4#R4 = R2 - 1;#>\n<R5#R5 = R2 + 1;#>"
>
Type: debug_output
Hardness: 35

// Assignment before loop, output and decrement in loop, condition is greater than.
# 402
PostTest.Condition.Logical.Negation
>
{<T0><F0>(){<T1#signed#><V1>=<R1#7<=R1<=9;#>;do{<V1> = <V1> - 1;<<<V1>;}while(!(<V1> < <R2#R2 = R1 - 3;#>));}}
>
Type: debug_output
Hardness: 30

// Pretest problem
// Declaration before loop, input in loop, output after loop, condition is less than or equal.
# 403
PostTest.Condition.Logical.Negation
?
Condition.Boundary.Legal
>
[<R1#7<=R1<=9;#>]{<T0><F0>(){<T1#integer#><V1>;do{>><V1>;}while(!(<V1> > <R1>));<<<V1>;}}
>
Input:  "<R2#R2 = R1 - 3;#>\n<R1>\n<R3#R3 = R1 + 2;#>\n<R4#1<=R4<=3;#>\n<R5#4<=R5<=6;#>" 
>
Type: debug_output
Hardness: 35

// Assignment before loop, increment by many and output in loop, condition is less than.
# 404
PostTest.Condition.Logical.Negation
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;do{<V1> = <V1> + <R2#2<=R2<=5;#>;<<<V1>;}while(!(<V1> > <R3#R3 = R1 + R2 * 3;#>));}}
>
Type: debug_output
Hardness: 35

// Demo problem
// Declaration before loop, input and output in loop, condition is greater than.
# 405
PostTest.Condition.Logical.Negation
?
Condition.Boundary.Illegal
>
[<R1#1<=R1<=5;#>]{<T0><F0>(){<T1#integer#><V1>;do{>><V1>;<<<V1>;}while(!(<V1> <= <R1>));}}
>
Input: "<R2#6<=R2<=8;#>\n<R3#9<=R3<=12;#>\n<R4#R4 = R1 + 1;#>\n<R1>\n<R5#R5 = R1 - 1;#>\n0" 
>
Type: debug_output
Hardness: 35

// Assignment before loop, decrement by many and output in loop, condition is greater than.
# 406
PostTest.Condition.Logical.Negation
>
[<R1#1<=R1<=5;#>,<R2#2<=R2<=5;#>,<R3#R3 = R1 + R2 * 3;#>]{<T0><F0>(){<T1#signed#><V1>=<R3>;do{<V1> = <V1> - <R2>;<<<V1>;}while(!(<V1> <= <R1>));}}
>
Type: debug_output
Hardness: 35

// Posttest problem
// Declaration before loop, input in loop, output after loop, condition is greater than or equal.
# 407
PostTest.Condition.Logical.Negation
?
Condition.Boundary.Legal
>
[<R1#1<=R1<=5;#>]{<T0><F0>(){<T1#integer#><V1>;do{>><V1>;}while(!(<V1> < <R1>));<<<V1>;}}
>
Input: "<R2#R2 = R1 + 3;#>\n<R1>\n<R3#R3 = R1 * 2;#>\n<R4#R4 = R1 - 1;#>\n<R5#6<=R5<=9;#>\n13" 
>
Type: debug_output
Hardness: 35

// ------------------------------------------------------------------------
// PostTest.Condition.Changing - 450 
// Intersperse
//    Without input: - Commented out
//       var1 < var2: var1++, var2--
//       var1 >= var2: var1--, var2++
//    With input for var1:
//       var1 < var2: var2--
//       var1 >= var2: var2++
//    With input for var2:
//       var1 = var2; >> var2; while( var1 < var2 )
//       var1 = var2; >> var2; while( var1 > var2 )
//    With input for var1 and var2:
//       var1 <= var2 
//       var1 >= var2
//       var1 != var2 
//       var1 == var2

// // COMMENTED OUT BECAUSE THESE COULD AS WELL BE IN FOR LOOP
// // Assignments before loop, output and increment and decrement in loop, condition is less than.
// # 450
// PostTest.Condition.Changing
// >
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;<T1><V2>=<R2#R2=R1 + 6;#>;
// do{<<<V1>;<<<V2>;<V1> = <V1> + 1;<V2> = <V2> - 1;}while(<V1> < <V2>);}}
// >
// Type: debug_output
// Hardness: 40
// 
// // Assignment before loop, output and decrement and increment in loop, condition is greater than.
// # 452
// PostTest.Condition.Changing 
// >
// {<T0><F0>(){<T1#signed#><V1>=<R1#7<=R1<=9;#>;<T1><V2>=<R2#R2=R1 - 6;#>;
// do{<V1> = <V1> - 1;<V2> = <V2> + 1;<<<V1>;<<<V2>;}while(<V1> > <V2>);}}
// >
// Type: debug_output
// Hardness: 40


// Two variables, one assignment before loop, one variable input and other decremented in loop,
// both variables output in loop, condition is less than.
# 450
PostTest.Condition.Changing
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#6<=R1<=9;#>]{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R1>;
do{>><V1>;<<<V1>;<<<V2>;<V2> = <V2> - 1;}while(<V1> <= <V2>);}}
>
Input: "<R2#1<=R2<=3;#>\n<R3#R3 = R1 - 2;#>\n<R4#R4 = R1 + 2;#>\n<R5#R5 = R1 - 4;#>\n<R1>"
>
Type: debug_output
Hardness: 45

// Two variables declared before loop, both variables input in loop,
// both variables output in loop, condition is greater than.
# 451
PostTest.Condition.Changing 
?
PostTest.Condition.Relational
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;
do{>><V1>;>><V2>;<<<V1>;<<<V2>;}while(<V1> > <V2>);}}
>
Input: "<R1#7<=R1<=9;#>\n<R2#4<=R2<=6;#>\n<R2>\n<R3#1<=R3<=3;#>\n<R3>\n<R1>\n<R4#R4 = R2 + 1;#>\n<R5#R5 = R3 + 1;#>"
>
Type: debug_output
Hardness: 50

// Two variables, one assignment before loop, one variable input and other decremented in loop,
// both variables output in loop, condition is less than.
# 452
PostTest.Condition.Changing
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#1<=R1<=5;#>]{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R1>;
do{>><V1>;<V2> = <V2> + 1;<<<V1>;<<<V2>;}while(<V1> >= <V2>);}}
>
Input: "<R2#7<=R2<=9;#>\n<R3#R3 = R1 + 2;#>\n<R1>\n<R4#R4 = R1 + 5;#>\n0"
>
Type: debug_output
Hardness: 45

// Two variables declared before loop, both variables input in loop,
// both variables output in loop, condition is greater than.
# 453
PostTest.Condition.Changing 
?
PostTest.Condition.Relational
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;
do{>><V1>;<<<V1>;>><V2>;<<<V2>;}while(<V1> < <V2>);}}
>
Input: "<R1#1<=R1<=3;#>\n<R2#4<=R2<=6;#>\n<R2>\n<R3#7<=R3<=9;#>\n<R3>\n<R1>\n<R4#R4 = R1 - 1;#>\n<R5#R5 = R3 - 1;#>"
>
Type: debug_output
Hardness: 50

// Two variables, one assignment before loop, one variable input and other decremented in loop,
// both variables output in loop, condition is less than.
# 454
PostTest.Condition.Changing
?
PostTest.Condition.Relational
>
[<R1#6<=R1<=9;#>]{<T0><F0>(){<T1#signed#><V1>=<R1>;<T1><V2>;
do{>><V2>;<<<V2>;<V1> = <V1> - 1;<<<V1>;}while(<V1> > <V2>);}}
>
Input: "<R2#1<=R2<=3;#>\n<R3#R3 = R1 - 3;#>\n<R4#R4 = R1 + 3;#>\n<R5#R5 = R1 - 5;#>\n<R1>"
>
Type: debug_output
Hardness: 40

// Two variables declared before loop, both variables input in loop,
// both variables output in loop, condition is greater than.
# 455
PostTest.Condition.Changing 
?
PostTest.Condition.Relational
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;
do{>><V1>;>><V2>;<<<V1>;<<<V2>;}while(<V1> != <V2>);}}
>
Input: "<R1#1<=R1<=3;#>\n<R2#4<=R2<=6;#>\n<R2>\n<R3#7<=R3<=9;#>\n<R2>\n<R2>\n<R4#R4 = R1 + 1;#>\n<R5#R5 = R3 - 1;#>"
>
Type: debug_output
Hardness: 50

// Two variables, one assignment before loop, one variable input and other decremented in loop,
// both variables output in loop, condition is less than.
# 456
PostTest.Condition.Changing
?
PostTest.Condition.Relational
>
[<R1#1<=R1<=5;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>;
do{>><V2>;<<<V2>;<<<V1>;<V1> = <V1> + 1;}while(<V1> < <V2>);}}
>
Input: "<R2#7<=R2<=9;#>\n<R3#R3 = R1 + 3;#>\n<R1>\n<R4#R4 = R1 + 5;#>\n5"
>
Type: debug_output
Hardness: 40




// Pretest problem
// Two variables declared before loop, one variable input in loop, other updated to first variable's value,
// both variables output in loop, condition is greater than.
// Monotonically increasing
# 460
PostTest.Condition.Changing 
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
{<T0><F0>(){<T1#integer#><V1>=0;<T1><V2>;
do{<V2> = <V1>;>><V1>;<<<V1>;}while(<V1> >= <V2>);}}
>
Input: "<R1#1<=R1<=3;#>\n<R2#4<=R2<=6;#>\n<R2>\n<R3#7<=R3<=9;#>\n<R1>\n<R3>\n<R2>" 
>
Type: debug_output
Hardness: 60

// Posttest problem
// Two variables declared before loop, one variable input in loop, other updated to first variable's value,
// both variables output in loop, condition is greater than.
// Monotonically decreasing
# 461
PostTest.Condition.Changing 
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#7<=R1<=9;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>;
do{<V2> = <V1>;>><V1>;<<<V1>;}while(<V1> <= <V2>);}}
>
Input: "<R1>\n<R2#4<=R2<=6;#>\n<R2>\n<R3#1<=R3<=3;#>\n<R2>\n<R1>" 
>
Type: debug_output
Hardness: 60

// Demo problem
// Two variables declared before loop, one variable input in loop, other updated to first variable's value,
// both variables output in loop, condition is greater than.
// Continually changing
# 462
PostTest.Condition.Changing 
?
PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>;
do{<V2> = <V1>;>><V1>;<<<V1>;}while(<V1> != <V2>);}}
>
Input: "<R2#4<=R2<=6;#>\n<R3#7<=R3<=9;#>\n<R3>\n<R2>\n<R1>\n<R2>" 
>
Type: debug_output
Hardness: 60

// ------------------------------------------------------------------------
// PostTest.Condition.Condition of the loop is empty 
// Syntax error in C++, Java, and C#
// Variation in body (output in all cases):
//   No input, with input, 

// Assignment before loop, output and increment in loop
# 475
PostTest.Condition.Condition of the loop is empty
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=9;#>;do{<<<V1>;<V1> = <V1> + 1;}while();}}
>
Type: debug_output
Hardness: 30

// Input is read and output is done in loop
# 476
PostTest.Condition.Condition of the loop is empty
>
{<T0><F0>(){<T1#integer#><V1>;do{>><V1>;<<<V1>;}while();}}
>
Input: "<R1#1<=R1<=3;#>\n<R2#7<=R2<=9;#>\n<R3#4<=R3<=6;#>\n<R2>\n<R1>"
>
Type: debug_output
Hardness: 30

// Pretest problem
// Assignment before loop, increment and output in loop
# 477
PostTest.Condition.Condition of the loop is empty 
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=9;#>;do{<V1> = <V1> + <R2#2<=R2<=4;#>;<<<V1>;}while();}}
>
Type: debug_output
Hardness: 30

// Demo problem
// Variable assigned before loop, output is done and input is read in loop
# 478
PostTest.Condition.Condition of the loop is empty
>
[<R1#integer;4<=R1<=6;#>]{<T0><F0>(){<T1#integer#><V1> = <R1>;do{<<<V1>;>><V1>;}while();}}
>
Input: "<R2#1<=R2<=3;#>\n<R3#7<=R3<=9;#>\n<R1>\n0\n<R4#R4 = R3 + 1;#>\n<R3>"
>
Type: debug_output
Hardness: 30

// Assignment before loop, output and decrement in loop
# 479
PostTest.Condition.Condition of the loop is empty 
>
{<T0><F0>(){<T1#signed#><V1>=<R1#1<=R1<=9;#>;do{<<<V1>;<V1> = <V1> - 1;}while();}}
>
Type: debug_output
Hardness: 30

// Input is read and and incremented and output is done in loop
# 480
PostTest.Condition.Condition of the loop is empty
>
[<R1#integer;1<=R1<=3;#>]{<T0><F0>(){<T1#integer#><V1>;do{>><V1>;<V1> = <V1>+<R1>;<<<V1>;}while();}}
>
Input: "<R1>\n<R2#4<=R2<=6;#>\n<R3#7<=R3<=9;#>\n<R4#R4 = R1 - 1;#>\n<R5#R5 = R3 + 1;#>\n<R2>"
>
Type: debug_output
Hardness: 30

// Posttest problem
// Assignment before loop, decrement and output in loop
# 481
PostTest.Condition.Condition of the loop is empty 
>
{<T0><F0>(){<T1#signed#><V1>=<R1#1<=R1<=9;#>;do{<V1> = <V1> - <R2#2<=R2<=4;#>;<<<V1>;}while();}}
>
Type: debug_output
Hardness: 30

// Input is read and decremented and output is done in loop
# 482
PostTest.Condition.Condition of the loop is empty
>
[<R1#integer;1<=R1<=3;#>]{<T0><F0>(){<T1#integer#><V1>;do{>><V1>;<V1> = <V1>-<R1>;<<<V1>;}while();}}
>
Input: "<R2#4<=R2<=6;#>\n<R3#7<=R3<=9;#>\n<R4#R4 = R2 - 1;#>\n<R5#R5 = R3 + 1;#>\n<R1>\n<R3>"
>
Type: debug_output
Hardness: 30

// ------------------------------------------------------------------------
// PostTest.Multiple.Dependent - 500  

// First loop reads value into a variable,
//    Second loop prints up to or from it, inc/dec
// First loop reads value into a variable,
//    Second loop continues to read into the same variable after printing the value
// First loop reads value into a variable,
//    Second loop uses it in condition to read value into a second variable


// // COMMENTED OUT SINCE THESE COULD JUST AS WELL BE FOR LOOPS
// //2-loops, two variables output and incremented in first loop, 
// // second variable output and incremented in second loop
// # 500
// PostTest.Multiple.Dependent
// >
// {<T0><F0>(){<T1#integer#><V1>=<R1#0<=R1<=6;#>;<T1><V2>=<R2#0<=R2<=4;#>;
// do{<<<V1>;<<<V2>;<V1> = <V1> + 1;<V2> = <V2> + 1;}while(<V1> < <R3#R3 = R1 + 3;#>);
// do{<<<V2>;<V2> = <V2> + 1;}while(<V2> < <R4#R4 = R2 + 5;#>);}}
// >
// Type: debug_output
// Hardness: 70
// 
// //2-loops, two variables decremented and output in first loop, 
// // second variable incremented and output in second loop
// # 501
// PostTest.Multiple.Dependent
// >
// {<T0><F0>(){<T1#signed#><V1>=<R1#4<=R1<=9;#>;<T1><V2>=<R2#3<=R2<=7;#>;
// do{<V1> = <V1> - 1;<V2> = <V2> - 1;<<<V1>;<<<V2>;}while(<V1> > <R3#R3 = R1 - 3;#>);
// do{<V2> = <V2> + 1;<<<V2>;}while(<V2> < <R4#R4 = R2 + 1;#>);}}
// >
// Type: debug_output
// Hardness: 70
// 
// //3-loops, single variable output and incremented in first loop, 
// //  output and decremented in second loop, output and incremented in third loop
// # 502
// PostTest.Multiple.Dependent
// >
// {<T0><F0>(){<T1#signed#><V1>=<R1#3<=R1<=6;#>;
// do{<<<V1>;<V1> = <V1> + 1;}while(<V1> < <R2#R2 = R1 + 3;#>);
// do{<<<V1>;<V1> = <V1> - 1;}while(<V1> > <R3#R3 = R1 -1;#>);
// do{<<<V1>;<V1> = <V1> + 1;}while(<V1> < <R4#R4 = R1 + 2;#>);}}
// >
// Type: debug_output
// Hardness: 80

// 2 loops, single variable input in first loop
// and second variable incremented up to first variable in second loop
# 500
PostTest.Multiple.Dependent
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#4<=R1<=6;#>,<R2#7<=R2<=9;#>,<R3#1<=R3<=3;#>,<R4#R4 = R3 + 3;#>,<R5#R5 = R3 - 1;#>]
{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<<<V1>;}while(<V1> >= <R1>);
<T1><V2> = <V1>;do{<< <V2>;<V2> = <V2> + 1;}while(<V2> < <R4>);}}
>
Input: "<R2>\n<R1>\n<R3>\n<R5>\n<R2>\n<R4>"
>
Type: debug_output
Hardness: 45

// Pretest problem
// 2 loops, single variable input and output in first loop
// and used in condition of second loop to read into a second variable
# 501
PostTest.Multiple.Dependent
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>,<R4#10<=R4<=12;#>]
{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<<<V1>;}while(<V1> <= <R1>);
<T1><V2>;do{>> <V2>;}while(<V2> > <V1>);<<<V2>;}}
>
Input: "<R1>\n<R2>\n<R3>\n<R4>\n<R1>\n<R2>"
>
Type: debug_output
Hardness: 65

// 2 loops, single variable input in first loop
// and second variable decremented down to first variable in second loop
# 502
PostTest.Multiple.Dependent
?
PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>,<R4#R4 = R3 - 2;#>,<R5#R5 = R2 + 1;#>]
{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<<<V1>;}while(<V1> < <R2>);
do{<< <V1>;<V1> = <V1> - 1;}while(<V1> >= <R4>);}}
>
Input: "<R1>\n<R3>\n<R2>\n<R5>\n<R4>"
>
Type: debug_output
Hardness: 40

// Posttest problem
// 2 loops, single variable input and output in first loop
// and used in condition of second loop to read into a second variable
# 503
PostTest.Multiple.Dependent
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>,<R4#R4 = R3 + 1;#>]
{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;}while(<V1> > <R2>);<<<V1>;
<T1><V2>;do{>> <V2>;}while(<V2> <= <V1>);<<<V2>;}}
>
Input: "<R3>\n<R2>\n<R1>\n<R2>\n<R3>\n<R4>"
>
Type: debug_output
Hardness: 65

// 2 loops, single variable input and output in first loop
// and same variable decremented in second loop
# 504
PostTest.Multiple.Dependent
?
PostTest.Condition.Relational
>
[<R1#4<=R1<=6;#>,<R2#1<=R2<=3;#>,<R3#2<=R3<=4;#>,<R4#R4 = R2 + 3 * R3;#>,<R5#R5 = R2 + R3;#>]
{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<<<V1>;}while(<V1> == <R1>);
do{<V1> = <V1> - <R3>;<<<V1>;}while(<V1> != <R2>);}}
>
Input: "<R1>\n<R4>\n<R5>\n<R3>\n<R2>"
>
Type: debug_output
Hardness: 40

// 2 loops, single variable input and output in first loop
// and used in condition of second loop to read into a second variable
# 505
PostTest.Multiple.Dependent
?
PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>]
{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<<<V1>;}while(<V1> == <R2>);
do{<<<V1>;>> <V1>;}while(<V1> != <R3>);}}
>
Input: "<R2>\n<R1>\n<R4#R4 = R3 - 1;#>\n<R3>\n<R5#R5 = R3 + 1;#>\n<R3>"
>
Type: debug_output
Hardness: 60

//2 loops, single variable input and output in first loop
// and same variable output and input in second loop, output after loops
# 506
PostTest.Multiple.Dependent
?
PostTest.Condition.Relational
>
[<R1#3<=R1<=6;#>,<R2#5<=R2<=7;#>]
{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<<<V1>;}while(<V1> > <R1>);
do{>> <V1>;<<<V1>;}while(<V1> < <R2>);}}
>
Input: "<R3#R3 = R1 + 3;#>\n<R4#R4 = R1 - 2;#>\n<R5#R5 = R2 - 2;#>\n<R6#R6 = R2 + 2;#>\n<R2>\n<R3>" 
>
Type: debug_output
Hardness: 70

// Demo problem
# 507
PostTest.Multiple.Dependent
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>]
{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R2>;do{>> <V1>;<<<V1>;}while(<V1> <= <V2>);
do{>> <V2>;<< <V2>;}while(<V2> <= <V1>);}}
>
Input: "<R2>\n<R3>\n<R1>\n<R3>\n<R4#R4 = R3 + 1;#>\n<R5#R5 = R3 - 1;#>"
>
Type: debug_output
Hardness: 45

// ------------------------------------------------------------------------
// PostTest.Multiple.Independent - 525 

// // COMMENTED OUT SINCE THIS IS SIMILAR TO FOR LOOPS
// // 2-loops, a variable output and incremented in first loop, 
// // second variable output and incremented in second loop
// # 525
// PostTest.Multiple.Independent
// >
// {<T0><F0>(){<T1#integer#><V1>=<R1#0<=R1<=5;#>;
// do{<<<V1>;<V1> = <V1> + 1;}while(<V1> < <R2#R2 = R1 + 3;#>);
// <T1><V2>=<R3#1<=R3<=6;#>;do{<<<V2>;<V2> = <V2> + 1;}while(<V2> <= <R4#R4 = R3 + 3;#>);}}
// >
// Type: debug_output
// Hardness: 70
// 
// //2-loops, a variables decremented and output in first loop, 
// // second variable incremented and output in second loop
// # 526
// PostTest.Multiple.Independent
// >
// {<T0><F0>(){<T1#integer#><V1>=<R1#4<=R1<=9;#>;
// do{<V1> = <V1> - 1;<<<V1>;}while(<V1> >= <R2#R2 = R1 - 4;#>);
// <T1><V2>=<R3#1<=R3<=6;#>;do{<V2> = <V2> + 1;<<<V2>;}while(<V2> < <R4#R4 = R3 + 2;#>);}}
// >
// Type: debug_output
// Hardness: 70
// 
// //3-loops, a variable output and incremented in first loop, 
// //  second variable output and decremented in second loop, 
// // third variable output and incremented in third loop
// # 527
// PostTest.Multiple.Independent
// >
// {<T0><F0>(){<T1#integer#><V1>=<R1#0<=R1<=5;#>;
// do{<<<V1>;<V1> = <V1> + 1;}while(<V1> < <R2#R2 = R1 + 2;#>);
// <T1><V2>=<R3#5<=R3<=9;#>;do{<<<V2>;<V2> = <V2> - 1;}while(<V2> > <R4#R4 = R3 - 4;#>);}}
// <T1><V3>=<R5#1<=R5<=6;#>;do{<<<V3>;<V3> = <V3> + 1;}while(<V3> <= <R6#R6 = R5 + 3;#>);}}
// >
// Type: debug_output
// Hardness: 80

// 2 loops, single variable input and output in first loop
// and same variable output and input in second loop
# 525
PostTest.Multiple.Independent
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#4<=R1<=6;#>]{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<<<V1>;}while(<V1> >= <R1>);
do{>> <V1>;}while(<V1> < <R1>);<<<V1>;}}
>
Input: "<R2#7<=R2<=9;#>\n<R1>\n<R3#1<=R3<=3;#>\n<R4#R4 = R3 - 1;#>\n<R1>\n<R2>\n<R5#R5 = R1 + 1;#>"
>
Type: debug_output
Hardness: 55

// 2 loops, single variable input and output in first loop
// and second variable output and input in second loop
# 526
PostTest.Multiple.Independent
?
Condition.Boundary.{Illegal,Legal},PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>,<R4#R4 = R1 - 1;#>]
{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<<<V1>;}while(<V1> <= <R2>);
<T1><V2>;do{>> <V2>;}while(<V2> > <R1>);<<<V2>;}}
>
Input: "<R2>\n<R3>\n<R2>\n<R1>\n<R3>\n<R4>"
>
Type: debug_output
Hardness: 55

// Pretest problem
// 2 loops, single variable input and output in first loop
// and same variable output and input in second loop
# 527
PostTest.Multiple.Independent
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#4<=R1<=6;#>]{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;}while(<V1> < <R1>);<<<V1>;
do{<<<V1>;>> <V1>;}while(<V1> >= <R1>);}}
>
Input: "<R3#1<=R3<=3;#>\n<R1>\n<R2#7<=R2<=9;#>\n<R1>\n<R4#R4 = R3 - 1;#>\n<R2>\n<R5#R5 = R1 - 1;#>"
>
Type: debug_output
Hardness: 55

// Demo problem
// 2 loops, single variable input and output in first loop
// and second variable output and input in second loop
# 528
PostTest.Multiple.Independent
?
Condition.Boundary.{Illegal,Legal},PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>,<R4#R4 = R1 - 1;#>]
{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;}while(<V1> > <R1>);<<<V1>;
<T1><V2>;do{>> <V2>;<<<V2>;}while(<V2> <= <R1>);}}
>
Input: "<R3>\n<R1>\n<R4>\n<R1>\n<R2>\n<R3>"
>
Type: debug_output
Hardness: 55

// 2 loops, single variable input and output in first loop
// and same variable output and input in second loop
# 529
PostTest.Multiple.Independent
?
PostTest.Condition.Relational
>
[<R1#4<=R1<=6;#>]{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<<<V1>;}while(<V1> == <R1>);
do{<<<V1>;>> <V1>;}while(<V1> != <R1>);}}
>
Input: "<R1>\n<R3#1<=R3<=3;#>\n<R2#7<=R2<=9;#>\n<R1>\n<R4#R4 = R3 - 1;#>\n<R5#R5 = R2 + 1;#> <R1>"
>
Type: debug_output
Hardness: 50

// 2 loops, single variable input and output in first loop
// and second variable output and input in second loop
# 530
PostTest.Multiple.Independent
?
PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>]
{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<<<V1>;}while(<V1> != <R3>);
<T1><V2>;do{>> <V2>;<<<V2>;}while(<V2> == <R2>);}}
>
Input: "<R1>\n<R3>\n<R2>\n<R1>\n<R2>\n<R3>"
>
Type: debug_output
Hardness: 50

// Posttest problem
//2 loops, 1 variable, input and output in both loop
// first condition  <, second condition >
# 531
PostTest.Multiple.Independent
?
Condition.Boundary.Illegal,PostTest.Condition.Relational
>
[<R1#5<=R1<=7;#>,<R2#3<=R2<=5;#>]{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<<<V1>;}while(<V1> < <R1>);
do{>> <V1>;<<<V1>;}while(<V1> > <R2>);}}
>
Input: "<R3#1<=R3<=3;#>\n<R4#R4 = R1 - 2;#>\n<R1>\n<R5#7<R5<9;#>\n<R2>\n<R6#R6 = R1 + 2;#>\n<R7#R7 = R2 - 2;#>" 
>
Type: debug_output
Hardness: 50

// 2 loops, 2 variables, input and output in both loops, 
// first condition  >=, second condition <=
# 532
PostTest.Multiple.Independent
?
Condition.Boundary.{Illegal,Legal},PostTest.Condition.Relational
>
[<R1#3<=R1<=5;#>,<R2#5<=R2<=7;#>]{<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<<<V1>;}while(<V1> >= <R1>);
<T1><V2>;do{>> <V2>;<<<V2>;}while(<V2> <= <R2>);}}
>
Input: "<R1>\n<R3#R3 = R1 - 2;#>\n<R2>\n<R4#R4 = R2 + 2;#>\n<R5#2<R5<9;#>\n<R6#R6 = R1 + 2;#>" 
>
Type: debug_output
Hardness: 55

// TOO COMPLICATED?
// //3-loops, a variable input and output in first loop, 
// // 2nd variable assigned before 2nd loop, output and input in 2nd loop, 
// // 3rd variable assigned before 3rd loop, output and input in 3rd loop,
// // 1st condition <, 2nd condition >, 3rd condition <=
// # 537
// PostTest.Multiple.Independent
// >
// [<R1#4<=R1<=6;#>,<R2#5<=R2<=9;#>,<R3#4<=R3<=6;#>,<R4#1<=R4<=6;#>,<R5#4<=R5<=6;#>]
// {<T0><F0>(){<T1#integer#><V1>;do{>> <V1>;<<<V1>;}while(<V1> < <R1>);
// <T1><V2>=<R2>;do{<<<V2>;>> <V2>;}while(<V2> > <R3>);}}
// <T1><V3>=<R4>;do{<<<V3>;>> <V3>;}while(<V3> <= <R5>);}}
// >
// Input: "<R6#R6 = R1 + 2;#> <R7#R7 = R3 + 2;#> <R8#R8 = R3 - 3;#> <R9#R9 = R5 + 3;#> <R2> <R1>" 
// >
// Type: debug_output
// Hardness: 80

// ------------------------------------------------------------------------
// PostTest.Nested.Dependent - 550 

// // COMMENTED OUT - SIMILAR TO FOR LOOP TEMPLATES
// // Pair of nested loops, two variables output and one incremented in inside  loop with condition <, 
// // other variable incremented by 2 after first loop in second loop with condition <
// # 550
// PostTest.Nested.Dependent
// >
// {<T0><F0>(){<T1#integer#><V1>=<R1#3<=R1<=5;#>;<T1><V2>=<R2#R2 = R1 - 2;#>;
// do{do{<<<V1>;<<<V2>;<V2> = <V2> + 1;}while(<V2> < <V1>);<V1> = <V1> + 2;}while(<V1> < 5);}}
// >
// Type: debug_output
// Hardness: 70
// 
// // Pair of nested loops, 2 variable, one variable incremented and the other assigned before inside loop
// // both variables output and the second variable decremented in inside loop with condition >=, 
// //  outside loop has condition <
// # 551
// PostTest.Nested.Dependent
// >
// {<T0><F0>(){<T1#signed#><V1>=<R1#1<=R1<=3;#>;<T1><V2>;
// do{<V1>=<V1>+1;<V2>=<R2#R2=R1+4;#>;do{<V2> = <V2> - 1;<<<V1>;<<<V2>;}while(<V2> >= <V1>);
// }while(<V1> < <R3#R3=R1+3;#>);}}
// >
// Type: debug_output
// Hardness: 70
// 
// // Pair of nested loops, 2 variable, second variable assigned the first variable,
// // then the first variable incremented before inside loop
// // both variables output and the second variable incremented in inside loop with condition >, 
// //  outside loop has condition <
// # 552
// PostTest.Nested.Dependent
// >
// {<T0><F0>(){<T1#signed#><V1>=<R1#3<=R1<=5;#>;<T1><V2>;
// do{<V2>=<R2#R2=R1+4;#>;<V1> = <V1> + 1;do{<<<V1>;<V2> = <V2> - 1;<<<V2>;}while(<V2> > <V1>);
// }while(<V1> < <R3#R3=R1+3;#>);}}
// >
// Type: debug_output
// Hardness: 70

// Increment a variable in outside loop, read into second variable 
//    while greater than it in inside loop
# 550
PostTest.Nested.Dependent
?
PostTest.Condition.Relational
>
[<R1#1<=R1<=5;#>,<R2#R2 = R1 + 2;#>]
{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>;
do{<V1> = <V1> + 1;<<<V1>;
do{>><V2>;<< <V2>;}while(<V2> > <V1>);
}while(<V1> < <R2>);}}
>
Input: "<R2>\n<R1>\n<R3#R3 = R1 + 3;#>\n<R4#R4 = R1 - 1;#>\n<R5#R5 = R1 + 1;#>\n<R2>"
>
Type: debug_output
Hardness: 50

// Pretest problem
// Read in outside loop, print up to it in inside loop
# 551
PostTest.Nested.Dependent
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>]
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;
do{>><V1>;<<<V1>;<V2>=<R1>;
do{<< <V2>;<V2> = <V2> + 1;}while(<V2> < <V1>);
}while(<V1> <= <R2>);}}
>
Input: "<R2#R2 = R1 + 2;#>\n<R3#R3 = R1 + 3;#>\n<R4#R4 = R1 + 5;#>\n<R1>\n<R5#R5 = R1 + 1;#>"
>
Type: debug_output
Hardness: 55

// Decrement a variable in outside loop, read into second variable while less than it in inside loop
# 552
PostTest.Nested.Dependent
?
PostTest.Condition.Relational
>
[<R1#6<=R1<=9;#>,<R2#R2 = R1 - 2;#>]
{<T0><F0>(){<T1#signed#><V1>=<R1>;<T1><V2>;
do{<V1> = <V1> - 1;<<<V1>;
do{>><V2>;<< <V2>;}while(<V2> < <V1>);
}while(<V1> > <R2>);}}
>
Input: "<R2>\n<R1>\n<R3#R3 = R1 - 3;#>\n<R4#R4 = R1 + 1;#>\n<R5#R5 = R1 - 1;#>\n<R2>"
>
Type: debug_output
Hardness: 50

// Posttest problem
// Read in outside loop, print down from it in inside loop
# 553
PostTest.Nested.Dependent
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>]
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;
do{>><V1>;<<<V1>;<V2>=<V1>;
do{<< <V2>;<V2> = <V2> - 1;}while(<V2> > <R1>);
}while(<V1> >= <R2>);}}
>
Input: "<R2#R2 = R1 + 3;#>\n<R3#R3 = R1 + 2;#>\n<R1>\n<R4#R4 = R1 + 1;#>\n<R5#R5 = R1 + 5;#>"
>
Type: debug_output
Hardness: 55

// Increment a variable by many in outside loop, read into second variable while >= than it in inside loop
# 554
PostTest.Nested.Dependent
?
PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#2<=R2<=4;#>,<R3#R3 = R1 + 2 * R2;#>]
{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>;
do{<V1> = <V1> + <R2>;<<<V1>;
do{>><V2>;<< <V2>;}while(<V2> >= <V1>);
}while(<V1> < <R3>);}}
>
Input: "<R3>\n<R1>\n<R4#R4 = R1 + 3 * R2;#>\n<R6#R6 = R1 + R2;#>\n<R1>\n<R3>"
>
Type: debug_output
Hardness: 50

# 555
PostTest.Nested.Dependent
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#2<=R2<=4;#>,<R3#R3 = R1 + 2 * R2;#>]
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;
do{>><V1>;<<<V1>;<V2>=<V1>;
do{<< <V2>;<V2> = <V2> + <R2>;}while(<V2> <= <R3>);
}while(<V1> >= <R1>);}}
>
Input: "<R1>\n<R4#R4 = R1 - 1;#>\n<R5#R5 = R1 + 3 * R2;#>\n<R6#R6 = R1 + 5 * R2;#>\n<R3>"
>
Type: debug_output
Hardness: 55

// Decrement a variable by many in outside loop, read into second variable while <= than it in inside loop
# 556
PostTest.Nested.Dependent
?
PostTest.Condition.Relational
>
[<R1#14<=R1<=19;#>,<R2#2<=R2<=4;#>,<R3#R3 = R1 - 2 * R2;#>]
{<T0><F0>(){<T1#signed#><V1>=<R1>;<T1><V2>;
do{<V1> = <V1> - <R2>;<<<V1>;
do{>><V2>;<< <V2>;}while(<V2> <= <V1>);
}while(<V1> > <R3>);}}
>
Input: "<R3>\n<R1>\n<R4#R4 = R1 - 3 * R2;#>\n<R6#R6 = R1 - R2;#>\n<R1>\n<R3>"
>
Type: debug_output
Hardness: 50

# 557
PostTest.Nested.Dependent
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#2<=R2<=4;#>]
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;
do{>><V1>;<<<V1>;<V2>=<V1>;
do{<< <V2>;<V2> = <V2> - <R2>;}while(<V2> >= <R1>);
}while(<V1> <= <R3>);}}
>
Input: "<R3#R3 = R1 + 2 * R2;#>\n<R4#R4 = R1 + 3 * R2 - 1;#>\n<R5#R5 = R1 - 1;#>\n<R1>\n<R2>"
>
Type: debug_output
Hardness: 55





// Pair of nested loops, 2 variables, 1 variable input before inner loop,
// other variable input in inner loop and both variables output in inner loop
// both conditions use <
# 560
PostTest.Nested.Dependent
?
Condition.Boundary.{Illegal,Legal},PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>]{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;
do{>><V1>;<<<V1>;do{>><V2>;}while(<V2> < <V1>);<<<V2>;}while(<V1> < <R3>);}}
>
Input: "<R2>\n<R1>\n<R3>\n<R3>\n<R2>\n<R4#10<=R4<=12;#>\n<R4>\n<R3>"
>
Type: debug_output
Hardness: 60

// Demo problem
// Pair of nested loops, 2 variables, 1 variable input and output before inner loop,
// other variable input and output in inner loop, conditions are >= and <
# 561
PostTest.Nested.Dependent
?
Condition.Boundary.{Illegal,Legal},PostTest.Condition.Relational
>
[<R1#3<=R1<=8;#>]{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;
do{>><V1>;do{>><V2>;<<<V2>;}while(<V2> >= <V1>);<<<V1>;}while(<V1> < <R1>);}}
>
Input: "<R2#R2 = R1 - 1;#>\n<R2>\n<R3#R3 = R2 - 1;#>\n<R1>\n<R1>\n<R2>\n<R4#R4 = R1 + 1;#>\n<R1>"
>
Type: debug_output
Hardness: 70

// Pair of nested loops, 2 variables, 1 variable input before inner loop and output after,
// other variable input and output in inner loop, conditions are > and >=
# 562
PostTest.Nested.Dependent
? 
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#7<=R1<=9;#>,<R2#1<=R2<=3;#>]{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;
do{>><V1>;do{>><V2>;<<<V2>;}while(<V2> > <V1>);<<<V1>;}while(<V1> >= <R1>);}}
>
Input: "<R1>\n<R3#R3 = R1 + R2;#>\n<R4#R4 = R1 - R2;#>\n<R5#4<=R5<=6;#>\n<R6#R6 = R5 + R2;#>\n<R7#R7 = R5 - R2;#>\n<R5>\n<R2>"
>
Type: debug_output
Hardness: 65

// Pair of nested loops, 2 variables, 1 variable input before inner loop and output after,
// other variable input and output in inner loop, conditions are > and >=
# 563
PostTest.Nested.Dependent
? 
Condition.Boundary.Illegal,PostTest.Condition.Relational
>
[<R1#7<=R1<=9;#>,<R2#2<=R2<=3;#>,<R5#4<=R5<=6;#>]{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;
do{>><V1>;<<<V1>;do{>><V2>;}while(<V2> <= <V1>);<<<V2>;}while(<V1> > <R5>);}}
>
Input: "<R1>\n<R3#R3 = R1 - R2;#>\n<R4#R4 = R1 + R2;#>\n<R5>\n<R6#R6 = R5 - R2;#>\n<R7#R7 = R5 + R2;#>\n<R2>\n<R5>"
>
Type: debug_output
Hardness: 65

// ------------------------------------------------------------------------
// PostTest.Nested.Independent - 575 

// COMMENTED OUT - VERY SIMILAR TO COUNTER LOOPS
// //  575-578 Problets from original do-while file 
// //Nested Up-Counting  - 2-levels
// # 575
// PostTest.Nested.Independent
// >
// {<T0><F0>(){<T1#integer#><V1>=<R1#0<=R1<=2;#>;do{<T1><V2>=<R2#0<=R2<=2;#>;
// do{<<<V1>;<<<V2>;<V2> = <V2> + 1;}while(<V2> < 3);<V1> = <V1> + 1;}while(<V1> < 3);}}
// >
// Type: debug_output
// Hardness: 70
// 
// //3-levels
// # 576
// PostTest.Nested.Independent
// >
// {<T0><F0>(){<T1#integer#><V1>=<R1#0<R1<=1;#>;do{<T1><V2>=<R2#0<=R2<=1;#>;
// do{<T1><V3>=<R3#0<=R3<=1;#>;do{<<<V1>;<<<V2>;<<<V3>;<V3> = <V3> + 1;}while(<V3> < 2);
// <V2> = <V2> + 1;}while(<V2> < 2);<V1> = <V1> + 1;}while(<V1> < 2);}}
// >
// Type: debug_output
// Hardness: 80
// 
// //Nested Down-Counting 
// //2-levels
// # 577
// PostTest.Nested.Independent
// >
// {<T0><F0>(){<T1#signed#><V1>=<R1#2<=R1<=4;#>;do{<T1><V2>=<R2#2<=R2<=4;#>;
// do{<<<V1>;<<<V2>;<V2> = <V2> - 1;}while(<V2> > 0);<V1> = <V1> - 1;}while(<V1> > 0);}}
// >
// Type: debug_output
// Hardness: 70
// 
// //3-levels
// # 578
// PostTest.Nested.Independent
// >
// {<T0><F0>(){<T1#signed#><V1>=<R1#1<R1<=2;#>;do{<T1><V2>=<R2#1<=R2<=2;#>;
// do{<T1><V3>=<R3#1<=R3<=2;#>;do{<<<V1>;<<<V2>;<<<V3>;<V3> = <V3> - 1;}while(<V3> >= 0);
// <V2> = <V2> - 1;}while(<V2> >= 0);<V1> = <V1> - 1;}while(<V1> >= 0);}}
// >
// Type: debug_output
// Hardness: 80

// COPIED DEPENDENT TEMPLATES AND MODIFIED THEM

// Increment a variable in outside loop, read into second variable while greater than it in inside loop
# 575
PostTest.Nested.Independent
?
Condition.Boundary.Illegal,PostTest.Condition.Relational
>
[<R1#1<=R1<=5;#>,<R2#R2 = R1 + 2;#>]
{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>;
do{<V1> = <V1> + 1;<<<V1>;
do{>><V2>;<< <V2>;}while(<V2> > <R1>);
}while(<V1> < <R2>);}}
>
Input: "<R2>\n<R1>\n<R3#R3 = R1 + 3;#>\n<R4#R4 = R1 - 1;#>\n<R5#R5 = R1 + 1;#>\n<R1>"
>
Type: debug_output
Hardness: 50

// Pair of nested loops, 2 variables, 1 variable input before inner loop,
// other variable input in inner loop and both variables output in inner loop
// both conditions use <
# 576
PostTest.Nested.Independent
?
Condition.Boundary.Illegal,PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>]{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;
do{>><V1>;<<<V1>;do{>><V2>;}while(<V2> < <R2>);<<<V2>;}while(<V1> < <R3>);}}
>
Input: "<R1>\n<R1>\n<R3>\n<R3>\n<R1>\n<R2>\n<R4#10<=R4<=12;#>\n<R2>\n<R4>"
>
Type: debug_output
Hardness: 65

// Decrement a variable in outside loop, read into second variable while less than it in inside loop
# 577
PostTest.Nested.Independent
?
Condition.Boundary.Illegal,PostTest.Condition.Relational
>
[<R1#6<=R1<=9;#>,<R2#R2 = R1 - 2;#>]
{<T0><F0>(){<T1#signed#><V1>=<R1>;<T1><V2>;
do{<<<V1>;
do{>><V2>;<< <V2>;}while(<V2> < <R1>);
<V1> = <V1> - 1;}while(<V1> > <R2>);}}
>
Input: "<R2>\n<R1>\n<R3#R3 = R1 - 3;#>\n<R4#R4 = R1 + 1;#>\n<R5#R5 = R1 - 1;#>\n<R1>"
>
Type: debug_output
Hardness: 50

// Pretest problem
// Pair of nested loops, 2 variables, 1 variable input and output before inner loop,
// other variable input and output in inner loop, conditions are >= and <
# 578
PostTest.Nested.Independent
?
Condition.Boundary.{Illegal,Legal},PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>]{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;
do{>><V1>;do{>><V2>;<<<V2>;}while(<V2> >= <R2>);<<<V1>;}while(<V1> < <R2>);}}
>
Input: "<R1>\n<R2>\n<R1>\n<R2>\n<R3>\n<R1>\n<R3>\n<R1>\n<R3>"
>
Type: debug_output
Hardness: 70

// Increment a variable by many in outside loop, read into second variable while >= than it in inside loop
# 579
PostTest.Nested.Independent
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#10<=R1<=12;#>,<R2#2<=R2<=4;#>,<R3#R3 = R1 + 2 * R2;#>]
{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>;
do{<<<V1>;
do{>><V2>;<< <V2>;}while(<V2> >= <R1>);
<V1> = <V1> + <R2>;}while(<V1> < <R3>);}}
>
Input: "<R3>\n<R4#R4 = R1 - R2;#>\n<R1>\n<R5#R5 = R1 - 2 * R2;#>\n<R3>\n<R5>"
>
Type: debug_output
Hardness: 55

// Posttest problem
// Pair of nested loops, 2 variables, 1 variable input before inner loop and output after,
// other variable input and output in inner loop, conditions are > and >=
# 580
PostTest.Nested.Independent
? 
Condition.Boundary.{Illegal,Legal},PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>]
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;
do{>><V1>;do{>><V2>;}while(<V2> > <R1>);<<<V1>;<<<V2>;}while(<V1> >= <R2>);}}
>
Input: "<R2>\n<R3>\n<R1>\n<R1>\n<R2>\n<R4#R4 = R1 - 1;#>\n<R4>\n<R2>\n<R1>"
>
Type: debug_output
Hardness: 70

// Decrement a variable by many in outside loop, read into second variable while >= than it in inside loop
# 581
PostTest.Nested.Independent
?
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#14<=R1<=19;#>,<R2#2<=R2<=4;#>,<R3#R3 = R1 - 2 * R2;#>]
{<T0><F0>(){<T1#signed#><V1>=<R1>;<T1><V2>;
do{<V1> = <V1> - <R2>;<<<V1>;
do{>><V2>;<< <V2>;}while(<V2> <= <R1>);
}while(<V1> > <R3>);}}
>
Input: "<R3>\n<R4#R4 = R1 + 3 * R2;#>\n<R1>\n<R5#R5 = R1 + R2;#>\n<R6#R6 = R1 - R2;#>\n<R4>"
>
Type: debug_output
Hardness: 55

// Pair of nested loops, 2 variables, 1 variable input before inner loop and output after,
// other variable input and output in inner loop, conditions are > and >=
# 582
PostTest.Nested.Independent
? 
Condition.Boundary.Legal,PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>]
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;
do{>><V1>;<<<V1>;do{>><V2>;<<<V2>;}while(<V2> <= <R2>);}while(<V1> > <R2>);}}
>
Input: "<R3>\n<R2>\n<R3>\n<R1>\n<R1>\n<R3>\n<R2>\n<R3>\n<R1>"
>
Type: debug_output
Hardness: 65

// Demo problem
// Pair of nested loops, 2 variables, 1 variable input before inner loop and output after,
// other variable input and output in inner loop, conditions are > and >=
# 583
PostTest.Nested.Independent
? 
PostTest.Condition.Relational
>
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>]
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;
do{>><V1>;do{>><V2>;}while(<V2> != <R2>);<<<V1>;}while(<V1> == <R2>);}}
>
Input: "<R2>\n<R1>\n<R2>\n<R3>\n<R1>\n<R2>\n<R3>\n<R1>\n<R2>"
>
Type: debug_output
Hardness: 65


// // Demo problem
// // Pair of nested loops, 2 variables, 1 variable input before inner loop and output after,
// // other variable input and output in inner loop, conditions are > and >=
// # 589
// PostTest.Nested.Independent
// ? 
// PostTest.Condition.Relational
// >
// [<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>,<R3#7<=R3<=9;#>]
// {<T0><F0>(){<T1#signed#><V1>;<T1><V2>;
// >> <V2>;
// do{>><V1>;do{>><V2>;}while(<V2> != <R2>);<<<V1>;}while(<V1> == <R2>);}}
// >
// Input: "<R2>\n<R1>\n<R2>\n<R3>\n<R1>\n<R2>\n<R3>\n<R1>\n<R2>"
// >
// Type: debug_output
// Hardness: 65



// THESE TEMPLATES CANNOT BE CONVERTED FROM DEPENDENT TO INDEPENDENT
// - INSIDE LOOP ALWAYS ITERATES THE SAME, MAKING IT MEANINGLESS.
// // Read in outside loop, print up to it in inside loop
// # 580
// PostTest.Nested.Independent
// ?
// Condition.Boundary.Legal
// >
// [<R1#1<=R1<=3;#>]
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;
// do{>><V1>;<<<V1>;<V2>=<R1>;
// do{<< <V2>;<V2> = <V2> + 1;}while(<V2> < <V1>);
// }while(<V1> <= <R2);}}
// >
// Input: "<R2#R2 = R1 + 2;#>\n<R3#R3 = R1 + 3;#>\n<R4#R4 = R1 + 5;#>\n<R1>\n<R5#R5 = R1 + 1;#>"
// >
// Type: debug_output
// Hardness: 55
// 
// // Read in outside loop, print down from it in inside loop
// # 581
// PostTest.Nested.Independent
// ?
// Condition.Boundary.Legal
// >
// [<R1#1<=R1<=3;#>]
// {<T0><F0>(){<T1#signed#><V1>;<T1><V2>;
// do{>><V1>;<<<V1>;<V2>=<V1>;
// do{<< <V2>;<V2> = <V2> - 1;}while(<V2> > <R1>);
// }while(<V1> >= <R2);}}
// >
// Input: "<R2#R2 = R1 + 3;#>\n<R3#R3 = R1 + 2;#>\n<R1>\n<R4#R4 = R1 + 1;#>\n<R5#R5 = R1 + 5;#>"
// >
// Type: debug_output
// Hardness: 55
// 
// # 582
// PostTest.Nested.Independent
// ?
// Condition.Boundary.Legal
// >
// [<R1#1<=R1<=3;#>,<R2#2<=R2<=4;#>,<R3#R3 = R1 + 2 * R2;#>]
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;
// do{>><V1>;<<<V1>;<V2>=<V1>;
// do{<< <V2>;<V2> = <V2> + <R2>;}while(<V2> <= <R3>);
// }while(<V1> < <R3);}}
// >
// Input: "<R1>\n<R4#R4 = R1 - 1;#>\n<R5#R5 = R1 + 3 * R2;#>\n<R6#R6 = R1 + 5 * R2;#>\n<R3>"
// >
// Type: debug_output
// Hardness: 55
// 
// # 583
// PostTest.Nested.Independent
// ?
// Condition.Boundary.Legal
// >
// [<R1#1<=R1<=3;#>,<R2#2<=R2<=4;#>]
// {<T0><F0>(){<T1#signed#><V1>;<T1><V2>;
// do{>><V1>;<<<V1>;<V2>=<V1>;
// do{<< <V2>;<V2> = <V2> - <R2>;}while(<V2> >= <R1>);
// }while(<V1> > <R1);}}
// >
// Input: "<R3#R3 = R1 + 2 * R2;#>\n<R4#R4 = R1 + 3 * R2 - 1;#>\n<R5#R5 = R1 - 1;#>\n<R1>\n<R2>"
// >
// Type: debug_output
// Hardness: 55

//---------------------------------------------------------------------------
// 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>;}}
>
Type: debug_output
Hardness: 10

// How to enter an error
# 91
Demonstration
>
{<T0><F0>(){<T1#integer#><V1>;<<<V1>;}}
>
Type: debug_output
Hardness: 10

// How to enter outputs when input is provided
# 92
Demonstration
>
{<T0><F0>(){<T1#integer#><V1>;>><V1>;<< <V1>; >><V1>; << <V1>;}}
>
Input: "<R1#1<=R1<=8;#>\n<R2#10<=R2<=19;#>\n<R3#R3 = R2 - R1;#>\n<R1>\n"
>
Type: debug_output
Hardness: 10