// Assignment.Simple.Correct - 100
//    Assigment to a variable from a constant, variable, constant expression, expression w. variables
// Assignment.Simple.Self Referential - 125
//    x = x arithOp value/var/constant expression
// Assignment.Simple.Precedence - 150
//    Assigment to a variable from an expression: arithmetic, relational, logical, bitwise
// Assignment.Simple.Associativity - 175
//    Chained assignment to 2 and 3 variables, same vs compound operators
// Assignment.Simple.Coercion - 200
//    from real to integer, from integer to real
// 
// Assignment.Compound.Correct.Arithmetic - 250
//    +=, -=, *=, /= %=: const, var, expression involving same operator, 
//                       self-ref last (this is a harder problem, not a new concept 
//                                      since all compound assignment is self-referential
// Assignment.Compound.Correct.Bitwise - 275
//    &=, |=, ^=, <<=, >>=
// Assignment.Compound.Precedence - 300
//    *=, /=, ;/%= w.r.t. +, -,  
//    *=, /=, %=, +=, -= w.r.t. the same operator - if they know compound operators are individual ops
// Assignment.Compound.Associativity - 325
//    Within compound arithmetic operators, compound and simple operators
//    Within compound bitwise operators, compound and simple operators
// Assignment.Compound.Coercion - 375
//    Using arithmetic operators, from real to integer, from integer to real
//    Using bitwise operators??
//
// Assignment.Prefix.Increment.Correct - 400
//    Single, Two in an arithmetic/relational expression (not the same variable twice)
// Assignment.Prefix.Increment.Precedence - 425
//    Single in an arithmetic/relational/other assignment operators
// Assignment.Prefix.Increment.Associativity - 450
//    W.r.t. itself only - chained/multiple
//
// Assignment.Prefix.Decrement.Correct - 500
//    Single, Two in an arithmetic/relational expression (not the same variable twice)
// Assignment.Prefix.Decrement.Precedence - 525
//    Single in an arithmetic/relational/other assignment operators
// Assignment.Prefix.Decrement.Associativity - 550
//    W.r.t. itself only - chained/multiple
//
// Assignment.Postfix.Increment.Correct - 600
//    Single, Two in an arithmetic/relational expression (not the same variable twice)
// Assignment.Postfix.Increment.Precedence - 625
//    Single in an arithmetic/relational/other assignment operators
// Assignment.Postfix.Increment.Associativity - 650
//    W.r.t. itself only - chained/multiple
//
// Assignment.Postfix.Decrement.Correct - 700
//    Single, Two in an arithmetic/relational expression (not the same variable twice)
// Assignment.Postfix.Decrement.Precedence - 725
//    Single in an arithmetic/relational/other assignment operators
// Assignment.Postfix.Decrement.Associativity - 750
//    W.r.t. itself only - chained/multiple
//
// Assignment.Parenthesis.Precedence - 800
//   to prioritize assignment over arithmetic, relational, operators
// Assignment.Parenthesis.Associativity - 850
//   
//
// Move learning objectives as follows:
// Assignment.Simple.Multiple             - Variable.Assignment.Simple
// Assignment.Compound.Multiple           - Variable.Assignment.Compound
// Assignment.Prefix.Increment.Multiple   - Variable.Assignment.Prefix.Increment
// Assignment.Prefix.Decrement.Multiple   - Variable.Assignment.Prefix.Decrement
// Assignment.Postfix.Increment.Multiple  - Variable.Assignment.Postfix.Increment
// Assignment.Postfix.Decrement.Multiple  - Variable.Assignment.Postfix.Decrement
//
//
// ------------------------------------------------------------------------
// DONE
// Assignment.Simple.Correct - 100
//    Assigment to a variable from a constant
//    no constant expression - this is about coercion
//    no variable or variable expression - already assumes understanding of assignment
// Don't use negative real numbers, will run into precision problems

// Assignment of constant
# 100
Assignment.Simple.Correct
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;}
>
Type: expression
Hardness: 10

# 101
Assignment.Simple.Correct
>
{<T1#integer#><V1>;<V1> = <R1#integer;-9<=R1<=-2;#>;}
>
Type: expression
Hardness: 10

# 102
Assignment.Simple.Correct
>
{<T1#real#><V1>;<V1> = <R1#float;2<=R1<=9;#>;}
>
Type: expression
Hardness: 10

# 103
Assignment.Simple.Correct
>
{<T1#real#><V1>;<V1> = <R1#float;11<=R1<=19;#>;}
>
Type: expression
Hardness: 10


// Repeated Assignments of constants to a variable
# 105
Assignment.Simple.Correct
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;<V1> = <R2#integer;11<=R2<=19;#>;}
>
Type: expression
Hardness: 20

# 106
Assignment.Simple.Correct
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;<V1> = <R2#integer;-9<=R2<=-2;#>;}
>
Type: expression
Hardness: 20

# 107
Assignment.Simple.Correct
>
{<T1#real#><V1>;<V1> = <R1#float;2<=R1<=5;#>;<V1> = <R2#float;6<=R2<=9;#>;}
>
Type: expression
Hardness: 20

# 108
Assignment.Simple.Correct
>
{<T1#real#><V1>;<V1> = <R1#float;2<=R1<=9;#>;<V1> = <R2#float;11<=R2<=19;#>;}
>
Type: expression
Hardness: 20


// Assignment of a variable
# 110
Assignment.Simple.Correct
>
{<T1#integer#><V1>;<T1><V2>;<V1> = <R1#integer;2<=R1<=9;#>;<V2> = <V1>;}
>
Type: expression
Hardness: 30

# 111
Assignment.Simple.Correct
>
{<T1#integer#><V1>;<T1><V2>;<V2> = <R1#integer;-9<=R1<=-2;#>;<V1> = <V2>;}
>
Type: expression
Hardness: 30

# 112
Assignment.Simple.Correct
>
{<T1#real#><V1>;<T1><V2>;<V1> = <R1#float;2<=R1<=9;#>;<V2> = <V1>;}
>
Type: expression
Hardness: 30

# 113
Assignment.Simple.Correct
>
{<T1#real#><V1>;<T1><V2>;<V2> = <R2#float;11<=R2<=19;#>;<V1> = <V2>;}
>
Type: expression
Hardness: 30



// Repeated Assignment, at least one being a variable
# 115
Assignment.Simple.Correct
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;<T1><V2>;<V2> = <R2#integer;11<=R2<=19;#>;<V1> = <V2>;}
>
Type: expression
Hardness: 40

# 116
Assignment.Simple.Correct
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;<T1><V2>;<V2> = <R2#integer;-9<=R2<=-2;#>;<V2> = <V1>;}
>
Type: expression
Hardness: 40

# 117
Assignment.Simple.Correct
>
{<T1#real#><V1>;<V1> = <R1#float;2<=R1<=5;#>;<T1><V2>;<V2> = <R2#float;6<=R2<=9;#>;<V1> = <V2>;}
>
Type: expression
Hardness: 40

# 118
Assignment.Simple.Correct
>
{<T1#real#><V1>;<V1> = <R1#float;2<=R1<=9;#>;<T1><V2>;<V2> = <R2#float;11<=R2<=19;#>;<V2> = <V1>;}
>
Type: expression
Hardness: 40



// Assignment with a semantic error
# 120
Assignment.Simple.Correct
>
{<T1#integer#><V1>;<T1><V2>;<V1> = <R1#integer;2<=R1<=9;#>;<V1> = <V2>;}
>
Type: expression
Hardness: 50

# 121
Assignment.Simple.Correct
>
{<T1#integer#><V1>;<T1><V2>;<V2> = <R1#integer;-9<=R1<=-2;#>;<V2> = <V1>;}
>
Type: expression
Hardness: 50

# 122
Assignment.Simple.Correct
>
{<T1#real#><V1>;<T1><V2>;<V1> = <R1#float;2<=R1<=9;#>;<V1> = <V2>;}
>
Type: expression
Hardness: 50

# 123
Assignment.Simple.Correct
>
{<T1#real#><V1>;<T1><V2>;<V2> = <R2#float;11<=R2<=19;#>;<V2> = <V1>;}
>
Type: expression
Hardness: 50

// ------------------------------------------------------------------------
// DONE
// Assignment.Simple.Self Referential - 125
//    x = x arithOp value/var/constant expression

// x = x arithOp 1
# 125
Assignment.Simple.Self Referential
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> = <V1> + 1;}
>
Type: expression
Hardness: 20

# 126
Assignment.Simple.Self Referential
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> = <V1> - 1;}
>
Type: expression
Hardness: 20

# 127
Assignment.Simple.Self Referential
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> = <V1> * 2;}
>
Type: expression
Hardness: 20



// x = x arithOp Constant
# 130
Assignment.Simple.Self Referential
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> = <V1> + <R2#integer;3<=R2<=9;#>;}
>
Type: expression
Hardness: 25

# 131
Assignment.Simple.Self Referential
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> = <V1> - <R2#integer;3<=R2<=9;#>;}
>
Type: expression
Hardness: 25

# 132
Assignment.Simple.Self Referential
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> = <V1> * <R2#integer;3<=R2<=5;#>;}
>
Type: expression
Hardness: 20



// x = x arithOp Variable
# 135
Assignment.Simple.Self Referential
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> = <V1> + <V2>;}
>
Type: expression
Hardness: 30

# 136
Assignment.Simple.Self Referential
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> = <V1> - <V2>;}
>
Type: expression
Hardness: 30

# 137
Assignment.Simple.Self Referential
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V1> = <V1> * <V2>;}
>
Type: expression
Hardness: 30




// x = x arithOp Constant expression
# 140
Assignment.Simple.Self Referential
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> = <V1> + <R2#integer;2<=R2<=5;#> * 2;}
>
Type: expression
Hardness: 40

# 141
Assignment.Simple.Self Referential
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> = <V1> - <R2#integer;2<=R2<=5;#> * 2;}
>
Type: expression
Hardness: 40



// x = x arithOp Variable expression
# 145
Assignment.Simple.Self Referential
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;1<=R2<=4;#>;<V1> = <V1> + <V2> * <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 45

# 146
Assignment.Simple.Self Referential
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;1<=R2<=4;#>;<V1> = <V1> - <V2> * <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 45

// ------------------------------------------------------------------------
// Assignment.Simple.Precedence - 150
//    Assigment to a variable from an expression: arithmetic, relational, logical, bitwise
//    Constant expressions, expressions with variables
// Always use only one other operator, so that we do not test precedence within the other operators

// Arithmetic expression, constant expression
# 150
Assignment.Simple.Precedence 
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#> + <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 20

# 151
Assignment.Simple.Precedence 
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#> - <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 20

# 152
Assignment.Simple.Precedence 
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=5;#> * <R2#integer;2<=R2<=5;#>;}
>
Type: expression
Hardness: 20

# 153
Assignment.Simple.Precedence 
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#> / <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 20

# 154
Assignment.Simple.Precedence 
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#> % <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 20


// Arithmetic expression, variable expression
# 155
Assignment.Simple.Precedence 
>
{<T1#integer#><V1>;<T1><V2> = <R1#integer;2<=R1<=9;#>;<V1> = <V2> + <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 30

# 156
Assignment.Simple.Precedence 
>
{<T1#integer#><V1>;<T1><V2> = <R1#integer;2<=R1<=9;#>;<V1> = <V2> - <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 30

# 157
Assignment.Simple.Precedence 
>
{<T1#integer#><V1>;<T1><V2> = <R1#integer;2<=R1<=5;#>;<V1> = <R2#integer;2<=R2<=5;#> * <V2>;}
>
Type: expression
Hardness: 30

# 158
Assignment.Simple.Precedence 
>
{<T1#integer#><V1>;<T1><V2> = <R1#integer;2<=R1<=9;#>;<V1> = <R2#integer;2<=R2<=9;#> / <V2>;}
>
Type: expression
Hardness: 30

# 159
Assignment.Simple.Precedence 
>
{<T1#integer#><V1>;<T1><V2> = <R1#integer;2<=R1<=9;#>;<V1> = <V2> % <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 30

// Relational expression, constant expression
// Relational expression, variable expression

// Logical expression, constant expression
// Logical expression, variable expression

// Bitwise expression, constant expression
// Bitwise expression, variable expression

// ------------------------------------------------------------------------
// DONE
// Assignment.Simple.Associativity - 175
//    Chained assignment to 2 and 3 variables, same vs compound operators
// x = y = constant; x = y = z; x = constant followed by x = y = constant;



// Assignment of constant
# 175
Assignment.Simple.Associativity
>
{<T1#integer#><V1>;<T1><V2>;<V1> = <V2> = <R1#integer;2<=R1<=9;#>;}
>
Type: expression
Hardness: 20

# 176
Assignment.Simple.Associativity
>
{<T1#integer#><V1>;<T1><V2>;<V2> = <V1> = <R1#integer;-9<=R1<=-2;#>;}
>
Type: expression
Hardness: 20

# 177
Assignment.Simple.Associativity
>
{<T1#real#><V1>;<T1><V2>;<V1> = <V2> = <R1#float;2<=R1<=9;#>;}
>
Type: expression
Hardness: 20

# 178
Assignment.Simple.Associativity
>
{<T1#real#><V1>;<T1><V2>;<V2> = <V1> = <R1#float;11<=R1<=19;#>;}
>
Type: expression
Hardness: 20



// Pre-existing value for variables, Assignment of a constant
# 180
Assignment.Simple.Associativity
>
{<T1#integer#><V1>;<T1><V2>;<V2> = <R1#integer;11<=R1<=19;#>;<V1> = <V2> = <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 30

# 181
Assignment.Simple.Associativity
>
{<T1#integer#><V1>;<T1><V2>;<V1> = <R1#integer;-9<=R1<=-2;#>;<V2> = <V1> = <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 30

# 182
Assignment.Simple.Associativity
>
{<T1#real#><V1>;<T1><V2>;<V2> = <R1#float;6<=R1<=9;#>;<V1> = <V2> = <R2#float;2<=R2<=5;#>;}
>
Type: expression
Hardness: 30

# 183
Assignment.Simple.Associativity
>
{<T1#real#><V1>;<T1><V2>;<V1> = <R1#float;11<=R1<=19;#>;<V2> = <V1> = <R2#float;2<=R2<=9;#>;}
>
Type: expression
Hardness: 30



// Assignment of variable
# 185
Assignment.Simple.Associativity
>
{<T1#integer#><V1>;<T1><V2>;<T1><V3>;<V3> = <R1#integer;2<=R1<=9;#>;<V1> = <V2> = <V3>;}
>
Type: expression
Hardness: 30

# 186
Assignment.Simple.Associativity
>
{<T1#integer#><V1>;<T1><V2>;<T1><V3>;<V3> = <R1#integer;-9<=R1<=-2;#>;<V2> = <V1> = <V3>;}
>
Type: expression
Hardness: 30

# 187
Assignment.Simple.Associativity
>
{<T1#real#><V1>;<T1><V2>;<T1><V3>;<V3> = <R1#float;2<=R1<=9;#>;<V1> = <V2> = <V3>;}
>
Type: expression
Hardness: 30

# 188
Assignment.Simple.Associativity
>
{<T1#real#><V1>;<T1><V2>;<T1><V3>;<V3> = <R1#float;11<=R1<=19;#>;<V2> = <V1> = <V3>;}
>
Type: expression
Hardness: 30



// Pre-existing value for variables, Assignment of variable
# 190
Assignment.Simple.Associativity
>
{<T1#integer#><V1>;<T1><V2>;<T1><V3>;<V2> = <R1#integer;2<=R1<=9;#>;<V3> = <R2#integer;11<=R2<=19;#>;<V1> = <V2> = <V3>;}
>
Type: expression
Hardness: 40

# 191
Assignment.Simple.Associativity
>
{<T1#integer#><V1>;<T1><V2>;<T1><V3>;<V1> = <R1#integer;2<=R1<=9;#>;<V3> = <R2#integer;-9<=R2<=-2;#>;<V2> = <V1> = <V3>;}
>
Type: expression
Hardness: 40

# 192
Assignment.Simple.Associativity
>
{<T1#real#><V1>;<T1><V2>;<T1><V3>;<V2> = <R1#float;2<=R1<=5;#>;<V3> = <R2#float;6<=R2<=9;#>;<V1> = <V2> = <V3>;}
>
Type: expression
Hardness: 40

# 193
Assignment.Simple.Associativity
>
{<T1#real#><V1>;<T1><V2>;<T1><V3>;<V1> = <R1#float;2<=R1<=9;#>;<V3> = <R2#float;11<=R2<=19;#>;<V2> = <V1> = <V3>;}
>
Type: expression
Hardness: 40


// ------------------------------------------------------------------------
// Copy straight from simple assignment and switch data types!
// Assignment.Simple.Coercion - 200
//    from real to integer, from integer to real

# 200
Assignment.Simple.Coercion
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=5;#>;}
>
Type: expression
Hardness: 20



// Assignment of constant
# 100
Assignment.Simple.Coercion
>
{<T1#real#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;}
>
Type: expression
Hardness: 10

# 101
Assignment.Simple.Coercion
>
{<T1#integer#><V1>;<V1> = <R1#float;2<=R1<=9;#>;}
>
Type: expression
Hardness: 10

# 102
Assignment.Simple.Coercion
>
{<T1#real#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;}
>
Type: expression
Hardness: 10

# 103
Assignment.Simple.Coercion
>
{<T1#integer#><V1>;<V1> = <R1#float;11<=R1<=19;#>;}
>
Type: expression
Hardness: 10


// Repeated Assignments of constants to a variable
# 105
Assignment.Simple.Coercion
>
{<T1#real#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;<V1> = <R2#integer;11<=R2<=19;#>;}
>
Type: expression
Hardness: 20

# 106
Assignment.Simple.Coercion
>
{<T1#integer#><V1>;<V1> = <R1#float;2<=R1<=5;#>;<V1> = <R2#float;6<=R2<=9;#>;}
>
Type: expression
Hardness: 20

# 107
Assignment.Simple.Coercion
>
{<T1#real#><V1>;<V1> = <R1#integer;2<=R1<=5;#>;<V1> = <R2#integer;6<=R2<=9;#>;}
>
Type: expression
Hardness: 20

# 108
Assignment.Simple.Coercion
>
{<T1#integer#><V1>;<V1> = <R1#float;2<=R1<=9;#>;<V1> = <R2#float;11<=R2<=19;#>;}
>
Type: expression
Hardness: 20


// Assignment of a variable
# 110
Assignment.Simple.Coercion
>
{<T1#integer#><V1>;<T2#real#><V2>;<V1> = <R1#integer;2<=R1<=9;#>;<V2> = <V1>;}
>
Type: expression
Hardness: 30

# 111
Assignment.Simple.Coercion
>
{<T1#integer#><V1>;<T2#real#><V2>;<V2> = <R1#float;2<=R1<=9;#>;<V1> = <V2>;}
>
Type: expression
Hardness: 30

// From here onwards
# 112
Assignment.Simple.Coercion
>
{<T1#real#><V1>;<T2#integer#><V2>;<V1> = <R1#float;2<=R1<=9;#>;<V2> = <V1>;}
>
Type: expression
Hardness: 30

# 113
Assignment.Simple.Coercion
>
{<T1#real#><V1>;<T1><V2>;<V2> = <R2#float;11<=R2<=19;#>;<V1> = <V2>;}
>
Type: expression
Hardness: 30



// Repeated Assignment, at least one being a variable
# 115
Assignment.Simple.Coercion
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;<T1><V2>;<V2> = <R2#integer;11<=R2<=19;#>;<V1> = <V2>;}
>
Type: expression
Hardness: 40

# 116
Assignment.Simple.Coercion
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;<T1><V2>;<V2> = <R2#integer;-9<=R2<=-2;#>;<V2> = <V1>;}
>
Type: expression
Hardness: 40

# 117
Assignment.Simple.Coercion
>
{<T1#real#><V1>;<V1> = <R1#float;2<=R1<=5;#>;<T1><V2>;<V2> = <R2#float;6<=R2<=9;#>;<V1> = <V2>;}
>
Type: expression
Hardness: 40

# 118
Assignment.Simple.Coercion
>
{<T1#real#><V1>;<V1> = <R1#float;2<=R1<=9;#>;<T1><V2>;<V2> = <R2#float;11<=R2<=19;#>;<V2> = <V1>;}
>
Type: expression
Hardness: 40



// Assignment with a semantic error
# 120
Assignment.Simple.Coercion
>
{<T1#integer#><V1>;<T1><V2>;<V1> = <R1#integer;2<=R1<=9;#>;<V1> = <V2>;}
>
Type: expression
Hardness: 50

# 121
Assignment.Simple.Coercion
>
{<T1#integer#><V1>;<T1><V2>;<V2> = <R1#integer;-9<=R1<=-2;#>;<V2> = <V1>;}
>
Type: expression
Hardness: 50

# 122
Assignment.Simple.Coercion
>
{<T1#real#><V1>;<T1><V2>;<V1> = <R1#float;2<=R1<=9;#>;<V1> = <V2>;}
>
Type: expression
Hardness: 50

# 123
Assignment.Simple.Coercion
>
{<T1#real#><V1>;<T1><V2>;<V2> = <R2#float;11<=R2<=19;#>;<V2> = <V1>;}
>
Type: expression
Hardness: 50

// ------------------------------------------------------------------------
// DONE
// Assignment.Compound.Correct.Arithmetic - 250
//    +=, -=, *=, /= %=: const, var, 
//    expression involving same operator would still be about precedence
//                       self-ref last (this is a harder problem, not a new concept 
//                                      since all compound assignment is self-referential

// Arithmetic operators, constant
# 250
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> += <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 30

# 251
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> -= <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 30

# 252
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<V1> *= <R2#integer;2<=R2<=5;#>;}
>
Type: expression
Hardness: 30

# 253
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> /= <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 30

# 254
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> %= <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 30



// Arithmetic operators, variable
# 255
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> += <V2>;}
>
Type: expression
Hardness: 35

# 256
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> -= <V2>;}
>
Type: expression
Hardness: 35

# 257
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V1> *= <V2>;}
>
Type: expression
Hardness: 35

# 258
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> /= <V2>;}
>
Type: expression
Hardness: 35

# 259
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> %= <V2>;}
>
Type: expression
Hardness: 35



// Arithmetic operators, self-referential variable
# 260
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<V1> += <V1>;}
>
Type: expression
Hardness: 60

# 261
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<V1> -= <V1>;}
>
Type: expression
Hardness: 60

# 262
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> *= <V1>;}
>
Type: expression
Hardness: 60

# 263
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> /=  <V1>;}
>
Type: expression
Hardness: 60

# 264
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> %= <V1>;}
>
Type: expression
Hardness: 60

// ------------------------------------------------------------------------
// Assignment.Compound.Correct.Bitwise - 275
//    &=, |=, ^=, <<=, >>=

# 275
Assignment.Compound.Correct.Bitwise
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=5;#>;}
>
Type: expression
Hardness: 30

// ------------------------------------------------------------------------
// DONE
// Assignment.Compound.Precedence - 300
//    *=, /=, /%= w.r.t. +, -,  
//    *=, /=, %=, +=, -= w.r.t. the same operator - interesting since it violates associativity rules

// *= w.r.t. +/-
# 300
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<V1> *= <R2#integer;2<=R2<=5;#> + <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 301
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<V1> *= <R2#integer;6<=R2<=9;#> - <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 302
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> *= <V2> - <V2>;}
>
Type: expression
Hardness: 50



// /= w.r.t. +/-
# 303
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> /= <R2#integer;2<=R2<=5;#> + <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 304
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> /= <R2#integer;6<=R2<=9;#> - <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 305
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> /= <V2> + <V2>;}
>
Type: expression
Hardness: 50


// %= w.r.t. +/-
# 306
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> %= <R2#integer;2<=R2<=5;#> + <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 307
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> %= <R2#integer;6<=R2<=9;#> - <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 308
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R1>;<V1> %= <V2> + <V2>;}
>
Type: expression
Hardness: 50




// Arithmetic operators, expression involving same operator
# 310
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> += <R2#integer;2<=R2<=9;#> + <R3#integer;2<=R3<=9;#>;}
>
Type: expression
Hardness: 40

# 311
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;5<=R2<=9;#>;<V1> -= <V2> - <R3#integer;2<=R3<=4;#>;}
>
Type: expression
Hardness: 40

# 312
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> *=  <R3#integer;2<=R3<=9;#> / <V2>;}
>
Type: expression
Hardness: 40

# 313
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V1> /=  <V2> * <V2>;}
>
Type: expression
Hardness: 40

# 314
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> %= <R2#integer;2<=R2<=9;#> * <R3#integer;2<=R3<=9;#>;}
>
Type: expression
Hardness: 40



// Arithmetic operators, self-referential expression involving lower precedence operator
// *= w.r.t. +/-
# 315
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> *= <V1> + 1;}
>
Type: expression
Hardness: 60

# 316
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> *= <V1> - <V1>;}
>
Type: expression
Hardness: 60

// /= w.r.t. +/-
# 317
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> /= <V1> + 1;}
>
Type: expression
Hardness: 60

# 318
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> /= <V1> - 1;}
>
Type: expression
Hardness: 60

// %= w.r.t. +/-
# 319
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> %= <V1> + <V1>;}
>
Type: expression
Hardness: 60

# 320
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> %= <V1> - 1;}
>
Type: expression
Hardness: 60



// Arithmetic operators, self-referential expression involving same operator
# 321
Assignment.Compound.Precedence
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=5;#>;<V1> += <V1> + <R2#integer;2<=R2<=5;#>;}
>
Type: expression
Hardness: 60

# 322
Assignment.Compound.Precedence
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=5;#>;<V1> -= <R2#integer;6<=R2<=9;#> - <V1>;}
>
Type: expression
Hardness: 60

# 323
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> *= <V1> / <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 60

# 324
Assignment.Compound.Precedence
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> /=  <V1> * <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 60

// # 325
// Assignment.Compound.Precedence
// >
// {<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> %= <V1> * <V1>;}
// >
// Type: expression
// Hardness: 60



// ------------------------------------------------------------------------
// DONE - Arithmetic is done, bitwise is not done
// Assignment.Compound.Associativity - 325
//    Within compound arithmetic operators, compound and simple operators
// all operators with themselves, *=, /= and %= with += and -=
//    Within compound bitwise operators, compound and simple operators

// *=, /=, %= w.r.t. += and -=: counter to precedence of arithmetic operators
# 325
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V1> *= <V2> += <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 60

# 326
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> /= <V2> -= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 60

# 327
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V1> %= <V2> += <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 60

# 328
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> *= <V2> -= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 60

# 329
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V1> /= <V2> += <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 60

# 330
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> %= <V2> -= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 60




// Compound arithmetic operator with simple assignment operator and vice versa
# 331
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2>;<V1> += <V2> = <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 40

# 332
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2>;<V1> -= <V2> = <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 40

# 333
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2>;<V1> *= <V2> = <R2#integer;2<=R2<=5;#>;}
>
Type: expression
Hardness: 40

# 334
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2>;<V1> /= <V2> = <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 40

# 335
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2>;<V1> %= <V2> = <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 40


# 336
Assignment.Compound.Associativity
>
{<T1#integer#><V1>;<T1><V2> = <R1#integer;2<=R1<=9;#>;<V1> = <V2> += <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 40

# 337
Assignment.Compound.Associativity
>
{<T1#integer#><V1>;<T1><V2> = <R1#integer;2<=R1<=9;#>;<V1> = <V2> -= <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 40

# 338
Assignment.Compound.Associativity
>
{<T1#integer#><V1>;<T1><V2> = <R1#integer;2<=R1<=9;#>;<V1> = <V2> *= <R2#integer;2<=R2<=5;#>;}
>
Type: expression
Hardness: 40

# 339
Assignment.Compound.Associativity
>
{<T1#integer#><V1>;<T1><V2> = <R1#integer;2<=R1<=9;#>;<V1> = <V2> /= <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 40

# 340
Assignment.Compound.Associativity
>
{<T1#integer#><V1>;<T1><V2> = <R1#integer;2<=R1<=9;#>;<V1> = <V2> %= <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 40




// += and -= w.r.t. each other - counter to associativity of +/-
// *=, /= and %= w.r.t. each other - counter to associativity of arithmetic operators
# 341
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V1> += <V2> += <R3#integer;2<=R3<=9;#>;}
>
Type: expression
Hardness: 50

# 342
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> += <V2> -= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 343
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V1> -= <V2> += <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 344
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> -= <V2> -= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 345
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V1> *= <V2> *= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 346
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> *= <V2> /= <R3#integer;2<=R3<=9;#>;}
>
Type: expression
Hardness: 50

# 347
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=9;#>;<V1> *= <V2> %= <R3#integer;2<=R3<=9;#>;}
>
Type: expression
Hardness: 50

# 348
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;11<=R1<=19;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V1> /= <V2> *= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 349
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;11<=R1<=19;#>;<T1><V2> = <R2#integer;6<=R2<=9;#>;<V1> /= <V2> /= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 350
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;11<=R1<=19;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V1> /= <V2> %= <R3#integer;6<=R3<=9;#>;}
>
Type: expression
Hardness: 50

# 351
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;11<=R1<=19;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V1> %= <V2> *= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 352
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;11<=R1<=19;#>;<T1><V2> = <R2#integer;6<=R2<=9;#>;<V1> %= <V2> /= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 353
Assignment.Compound.Associativity
>
{<T1#integer#><V1> = <R1#integer;11<=R1<=19;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V1> %= <V2> %= <R3#integer;6<=R3<=9;#>;}
>
Type: expression
Hardness: 50

// ------------------------------------------------------------------------
// Assignment.Compound.Coercion - 375
//    Using arithmetic operators, from real to integer, from integer to real
//    Using bitwise operators??
//

// DO
// Arithmetic, int to real
// Arithmetic, float to int

# 375
Assignment.Compound.Coercion
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=5;#>;}
>
Type: expression
Hardness: 50

// ------------------------------------------------------------------------
// Assignment.Prefix.Increment.Correct - 400
//    Single, Two in an arithmetic/relational expression (not the same variable twice)
// DONE

# 400
Assignment.Prefix.Increment.Correct
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;++ <V1>;}
>
Type: expression
Hardness: 20

# 401
Assignment.Prefix.Increment.Correct
>
{<T1#integer#><V1>;<V1> = <R1#integer;11<=R1<=19;#>;++ <V1>;}
>
Type: expression
Hardness: 20

// ------------------------------------------------------------------------
// Assignment.Prefix.Increment.Precedence - 425
//    Single in an arithmetic/relational/other assignment operators
// DONE
// Arithmetic: operand op ++ var for *, /, %, +, -
// Relational: operand op ++ var for <, >, <=. >=
// Assignment: operand op ++ var for =, +=, -=, *=, /=, %=

# 425
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<R1> * ++ <V1>;}
>
Type: expression
Hardness: 30

# 426
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> / ++ <V1>;}
>
Type: expression
Hardness: 30

# 427
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> % ++ <V1>;}
>
Type: expression
Hardness: 30

# 428
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<V1> + ++ <V1>;}
>
Type: expression
Hardness: 30

# 429
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> - ++ <V1>;}
>
Type: expression
Hardness: 30


# 430
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> < ++ <V1>;}
>
Type: expression
Hardness: 20

# 431
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> > ++ <V1>;}
>
Type: expression
Hardness: 20

# 432
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> <= ++ <V1>;}
>
Type: expression
Hardness: 25

# 433
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> >= ++ <V1>;}
>
Type: expression
Hardness: 25



# 435
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2>;<V2> = ++ <V1>;}
>
Type: expression
Hardness: 30

# 436
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> += ++ <V1>;}
>
Type: expression
Hardness: 35

# 437
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> -= ++ <V1>;}
>
Type: expression
Hardness: 35

# 438
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> *= ++ <V1>;}
>
Type: expression
Hardness: 35

# 439
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> /= ++ <V1>;}
>
Type: expression
Hardness: 35

# 440
Assignment.Prefix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> %= ++ <V1>;}
>
Type: expression
Hardness: 35


// ------------------------------------------------------------------------
// Assignment.Prefix.Associativity - 450
//    W.r.t. itself only - chained/multiple
// DONE

# 450
Assignment.Prefix.Associativity
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;++ ++ <V1>;}
>
Type: expression
Hardness: 30

# 451
Assignment.Prefix.Associativity
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;-- ++ <V1>;}
>
Type: expression
Hardness: 30

# 452
Assignment.Prefix.Associativity
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;++ -- <V1>;}
>
Type: expression
Hardness: 30

# 453
Assignment.Prefix.Associativity
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;-- -- <V1>;}
>
Type: expression
Hardness: 30

// ------------------------------------------------------------------------
// Assignment.Prefix.Decrement.Correct - 500
//    Single, Two in an arithmetic/relational expression (not the same variable twice)
// DONE

# 500
Assignment.Prefix.Decrement.Correct
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;-- <V1>;}
>
Type: expression
Hardness: 20

# 501
Assignment.Prefix.Decrement.Correct
>
{<T1#integer#><V1>;<V1> = <R1#integer;11<=R1<=19;#>;-- <V1>;}
>
Type: expression
Hardness: 20

// ------------------------------------------------------------------------
// Assignment.Prefix.Decrement.Precedence - 525
//    Single in an arithmetic/relational/other assignment operators

// DONE
// Arithmetic: operand op ++ var for *, /, %, +, -
// Relational: operand op ++ var for <, >, <=. >=
// Assignment: operand op ++ var for =, +=, -=, *=, /=, %=

# 525
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<R1> * -- <V1>;}
>
Type: expression
Hardness: 30

# 526
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> / -- <V1>;}
>
Type: expression
Hardness: 30

# 527
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> % -- <V1>;}
>
Type: expression
Hardness: 30

# 528
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<V1> + -- <V1>;}
>
Type: expression
Hardness: 30

# 529
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> - -- <V1>;}
>
Type: expression
Hardness: 30


# 530
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> < -- <V1>;}
>
Type: expression
Hardness: 20

# 531
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> > -- <V1>;}
>
Type: expression
Hardness: 20

# 532
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> <= -- <V1>;}
>
Type: expression
Hardness: 25

# 533
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> >= -- <V1>;}
>
Type: expression
Hardness: 25



# 535
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2>;<V2> = -- <V1>;}
>
Type: expression
Hardness: 30

# 536
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> += -- <V1>;}
>
Type: expression
Hardness: 35

# 537
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> -= -- <V1>;}
>
Type: expression
Hardness: 35

# 538
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> *= -- <V1>;}
>
Type: expression
Hardness: 35

# 539
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> /= -- <V1>;}
>
Type: expression
Hardness: 35

# 540
Assignment.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> %= -- <V1>;}
>
Type: expression
Hardness: 35

// ------------------------------------------------------------------------
// Assignment.Prefix.Decrement.Associativity - No longer a learning objective

// ------------------------------------------------------------------------
// Assignment.Postfix.Increment.Correct - 600
//    Single, Two in an arithmetic/relational expression (not the same variable twice)
// DONE
# 600
Assignment.Postfix.Increment.Correct
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> >+;}
>
Type: expression
Hardness: 20

# 601
Assignment.Postfix.Increment.Correct
>
{<T1#integer#><V1>;<V1> = <R1#integer;11<=R1<=19;#>;<V1> ++;}
>
Type: expression
Hardness: 20

// ------------------------------------------------------------------------
// Assignment.Postfix.Increment.Precedence - 625
//    Single in an arithmetic/relational/other assignment operators
// DONE
// Arithmetic: operand op ++ var for *, /, %, +, -
// Relational: operand op ++ var for <, >, <=. >=
// Assignment: operand op ++ var for =, +=, -=, *=, /=, %=

# 625
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<R1> * <V1> ++;}
>
Type: expression
Hardness: 30

# 626
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> / <V1> ++;}
>
Type: expression
Hardness: 30

# 627
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> % <V1> ++;}
>
Type: expression
Hardness: 30

# 628
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<V1> + <V1> ++;}
>
Type: expression
Hardness: 30

# 629
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> - <V1> ++;}
>
Type: expression
Hardness: 30


# 630
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> < <V1> ++;}
>
Type: expression
Hardness: 20

# 631
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> > <V1> ++;}
>
Type: expression
Hardness: 20

# 632
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> <= <V1> ++;}
>
Type: expression
Hardness: 25

# 633
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> >= <V1> ++;}
>
Type: expression
Hardness: 25



# 635
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2>;<V2> = <V1> ++;}
>
Type: expression
Hardness: 30

# 636
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> += <V1> ++;}
>
Type: expression
Hardness: 35

# 637
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> -= <V1> ++;}
>
Type: expression
Hardness: 35

# 638
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> *= <V1> ++;}
>
Type: expression
Hardness: 35

# 639
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> /= <V1> ++;}
>
Type: expression
Hardness: 35

# 640
Assignment.Postfix.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> %= <V1> ++;}
>
Type: expression
Hardness: 35


// ------------------------------------------------------------------------
// Assignment.Postfix.Increment.Associativity - No longer a learning objective

// ------------------------------------------------------------------------
// Assignment.Postfix.Decrement.Correct - 700
//    Single, Two in an arithmetic/relational expression (not the same variable twice)
// DONE
# 700
Assignment.Postfix.Decrement.Correct
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> --;}
>
Type: expression
Hardness: 20

# 701
Assignment.Postfix.Decrement.Correct
>
{<T1#integer#><V1>;<V1> = <R1#integer;11<=R1<=19;#>;<V1> --;}
>
Type: expression
Hardness: 20

// ------------------------------------------------------------------------
// Assignment.Postfix.Decrement.Precedence - 725
//    Single in an arithmetic/relational/other assignment operators
// DONE
// Arithmetic: operand op ++ var for *, /, %, +, -
// Relational: operand op ++ var for <, >, <=. >=
// Assignment: operand op ++ var for =, +=, -=, *=, /=, %=

# 725
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<R1> * <V1> --;}
>
Type: expression
Hardness: 30

# 726
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> / <V1> --;}
>
Type: expression
Hardness: 30

# 727
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> % <V1> --;}
>
Type: expression
Hardness: 30

# 728
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<V1> + <V1> --;}
>
Type: expression
Hardness: 30

# 729
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> - <V1> --;}
>
Type: expression
Hardness: 30


# 730
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> < <V1> --;}
>
Type: expression
Hardness: 20

# 731
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<R1> > <V1> --;}
>
Type: expression
Hardness: 20

# 732
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> <= <V1> --;}
>
Type: expression
Hardness: 25

# 733
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<V1> >= <V1> --;}
>
Type: expression
Hardness: 25



# 735
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2>;<V2> = <V1> --;}
>
Type: expression
Hardness: 30

# 736
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> += <V1> --;}
>
Type: expression
Hardness: 35

# 737
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> -= <V1> --;}
>
Type: expression
Hardness: 35

# 738
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> *= <V1> --;}
>
Type: expression
Hardness: 35

# 739
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> /= <V1> --;}
>
Type: expression
Hardness: 35

# 740
Assignment.Postfix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> %= <V1> --;}
>
Type: expression
Hardness: 35





// ------------------------------------------------------------------------
// Assignment.Postfix.Decrement.Associativity -  No longer a learning objective

// ------------------------------------------------------------------------
// Assignment.Parenthesis.Precedence - 800
//   to prioritize assignment over arithmetic, relational, operators

# 800
Assignment.Parenthesis.Precedence
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=5;#>;}
>
Type: expression
Hardness: 30

// ------------------------------------------------------------------------
// Assignment.Parenthesis.Associativity - 850

# 850
Assignment.Parenthesis.Associativity
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=5;#>;}
>
Type: expression
Hardness: 50

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

// <R1#integer;2<=R1<=5;#> < <R2#integer;6<=R2<=9;#> && <R2> < <R3#integer;11<=R3<=14;#>

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

// How to enter multiple underbraces
# 90
Demonstration
>
2 < 4 == true
>
Type: expression
Hardness: 10

// How to enter short circuit values
# 91
Demonstration
>
false && 4 < 9
>
Type: expression
Hardness: 15

// How to enter error values
# 92
Demonstration
>
2 / 0 && 3 < 5
>
Type: expression
Hardness: 15

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