// 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.Widening - 200
//    from integer to real
// Assignment.Simple.Coercion.Narrowing - 225
//    from real to integer
// 
// 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 - 350
//    Within compound arithmetic operators, compound and simple operators
//    Within compound bitwise operators, compound and simple operators
// Assignment.Compound.Coercion.Widening - 400
//    Using arithmetic operators, from real to integer, from integer to real
//    Using bitwise operators??
// Assignment.Compound.Coercion.Narrowing - 450
//


// Assignment.Prefix.Increment.Correct - 500
//    Single, Two in an arithmetic/relational expression (not the same variable twice)
// Assignment.Prefix.Increment.Precedence - 525
//    Single in an arithmetic/relational/other assignment operators
// Assignment.Prefix.Associativity - 550
//    W.r.t. itself only - chained/multiple
//
// Assignment.Prefix.Decrement.Correct - 600
//    Single, Two in an arithmetic/relational expression (not the same variable twice)
// Assignment.Prefix.Decrement.Precedence - 625
//    Single in an arithmetic/relational/other assignment operators
//
// Assignment.Postfix.Increment.Correct - 700
//    Single, Two in an arithmetic/relational expression (not the same variable twice)
// Assignment.Postfix.Increment.Precedence - 725
//    Single in an arithmetic/relational/other assignment operators
//
// Assignment.Postfix.Decrement.Correct - 800
//    Single, Two in an arithmetic/relational expression (not the same variable twice)
// Assignment.Postfix.Decrement.Precedence - 825
//    Single in an arithmetic/relational/other assignment operators
//
// Assignment.Parenthesis.Precedence - 900
//   to prioritize assignment over arithmetic, relational, operators
// Assignment.Parenthesis.Associativity - 950
//   
//
// 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;#>;}
{<T1#signed#><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;#>;}
{<T1#signed#><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>;}
{<T1#signed#><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>;}
{<T1#signed#><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> = <V2>;}
>
Type: expression
Hardness: 50

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

# 122
Assignment.Simple.Correct
>
{<T1#integer#><V1>;<V1> = <V1>;}
>
Type: expression
Hardness: 50

# 123
Assignment.Simple.Correct
>
{<T1#integer#><V1>;<V1> = <R2#float;2<=R2<=9;#> / 0;}
>
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;#>;}
{<T1#integer#><V1> = <R1#integer;6<=R1<=9;#>;<V1> = <V1> - <R2#integer;2<=R2<=5;#>;}
>
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>;}
{<T1#integer#><V1> = <R1#integer;6<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<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;}
{<T1#integer#><V1> = <R1#integer;11<=R1<=19;#>;<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;#>;}
{<T1#signed#><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


// Buggy - semantic error 
# 148
Assignment.Simple.Self Referential
>
{<T1#integer#><V1>;<V1> = <V1> + 1;}
>
Type: expression
Hardness: 20

// ------------------------------------------------------------------------
// 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;#>;}
{<T1#signed#><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;#>;}
{<T1#signed#><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;#>;}
{<T1#signed#><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;#>;}
{<T1#signed#><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>;}
{<T1#signed#><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>;}
{<T1#signed#><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


// ------------------------------------------------------------------------
// Assignment.Simple.Coercion.Widening - 200
//    from integer to real
//    Always use float for real constants to get single precision real constants

// Assignment of constant
# 200
Assignment.Simple.Coercion.Widening
>
{<T1#real#><V1>;<V1> = <R1#int;2<=R1<=9;#>;}
>
Type: expression
Hardness: 20

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

// Assignment of an expression
// HINT: When extracting a real random number based on an integer random number
//   use + or - : they are reliable unlike multiplication and division. Use spaces
# 210
Assignment.Simple.Coercion.Widening
>
{<T1#real#><V1>;<V1> = <R1#int;2<=R1<=9;#> + <R2#int;2<=R2<=9;#>;}
>
Type: expression
Hardness: 50

# 211
Assignment.Simple.Coercion.Widening
>
{<T1#real#><V1>;<V1> = <R1#int;6<=R1<=9;#> - <R2#int;2<=R2<=5;#>;}
>
Type: expression
Hardness: 50

# 212
Assignment.Simple.Coercion.Widening
>
{<T1#real#><V1>;<V1> = <R1#int;2<=R1<=5;#> * <R2#int;2<=R2<=5;#>;}
>
Type: expression
Hardness: 50

# 213
Assignment.Simple.Coercion.Widening
>
{<T1#real#><V1>;<V1> = <R1#int;6<=R1<=9;#> % <R2#int;2<=R2<=5;#>;}
>
Type: expression
Hardness: 50

# 214
Assignment.Simple.Coercion.Widening
>
{<T1#real#><V1>;<V1> = <R1#int;6<=R1<=9;#> / <R2#int;2<=R2<=5;#>;}
>
Type: expression
Hardness: 50


// ------------------------------------------------------------------------
// Assignment.Simple.Coercion.Narrowing - 225
//    from real to integer
//    Always use float for real constants to get single precision real constants

// Assignment of constant
# 225
Assignment.Simple.Coercion.Narrowing 
>
{<T1#integer#><V1>;<V1> = <R1#float;2.0<=R1<=9.0;#>;}
>
Type: expression
Hardness: 20

// Assignment of a variable
# 230
Assignment.Simple.Coercion.Narrowing 
>
{<T1#real#><V1> = <R1#float;2.0<=R1<=9.0;#>;<T2#integer#><V2>;<V2> = <V1>;}
>
Type: expression
Hardness: 30

// Assignment of an expression
// HINT: When extracting a real random number based on an integer random number
//   use + or - : they are reliable unlike multiplication and division. Use spaces
# 235
Assignment.Simple.Coercion.Narrowing 
>
{<T1#integer#><V1>;<V1> = <R1#int;2<=R1<=6;#> + <R2#float;2.0<=R2<=6;#>;}
>
Type: expression
Hardness: 50

# 236
Assignment.Simple.Coercion.Narrowing 
>
{<T1#integer#><V1>;<V1> = <R1#int;6<=R1<=9;#> - <R2#float;2<=R2<=5;#>;}
>
Type: expression
Hardness: 50

# 237
Assignment.Simple.Coercion.Narrowing 
>
{<T1#integer#><V1>;<V1> = <R1#int;2<=R1<=5;#> * <R2#float;2<=R2<=5;#>;}
>
Type: expression
Hardness: 50

# 238
Assignment.Simple.Coercion.Narrowing 
>
{<T1#integer#><V1>;<V1> = <R1#int;2<=R1<=9;#> / <R2#float;R2 = R1;#>;}
>
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;#>;}
{<T1#integer#><V1> = <R1#integer;6<=R1<=9;#>;<V1> -= <R2#integer;2<=R2<=5;#>;}
>
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>;}
{<T1#integer#><V1> = <R1#integer;6<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<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>;}
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<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



// The following generate errors of various kinds
# 265
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1>;<V1> += <R1#integer;2<=R1<=9;#>;}
>
Type: expression
Hardness: 50

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

# 267
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1>;<T1><V2> = <R1#integer;2<=R1<=9;#>;<V1> +=  <V2>;}
>
Type: expression
Hardness: 50

# 268
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2>;<V1> +=  <V2>;}
>
Type: expression
Hardness: 50

# 269
Assignment.Compound.Correct.Arithmetic
>
{<T1#integer#><V1>;<T1><V2>;<V1> +=  <V2>;}
>
Type: expression
Hardness: 55

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

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


// // Testing compound assignment to an uninitialized variable
// # 274
// Assignment.Compound.Correct.Arithmetic
// >
// {<T1#integer#><V1>;<V1> += <R1#integer;2<=R1<=9;#>;}
// >
// Type: expression
// Hardness: 55

// ------------------------------------------------------------------------
// 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;#>;}
{<T1#signed#><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>;}
{<T1#signed#><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 - 350
//    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
# 350
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

# 351
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;#>;}
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;6<=R2<=9;#>;<V1> /= <V2> -= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 60

# 352
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

# 353
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;#>;}
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;6<=R2<=9;#>;<V1> *= <V2> -= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 60

# 354
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

# 355
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;#>;}
{<T1#integer#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;6<=R2<=9;#>;<V1> %= <V2> -= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 60




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

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

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

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

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


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

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

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

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

# 365
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
# 366
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

# 367
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;#>;}
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#integer;6<=R2<=9;#>;<V1> += <V2> -= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 368
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;#>;}
{<T1#signed#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V1> -= <V2> += <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 369
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;#>;}
{<T1#signed#><V1> = <R1#integer;2<=R1<=9;#>;<T1><V2> = <R2#integer;6<=R2<=9;#>;<V1> -= <V2> -= <R3#integer;2<=R3<=5;#>;}
>
Type: expression
Hardness: 50

# 370
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

# 371
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

# 372
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

# 373
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

# 374
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

# 375
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

# 376
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

# 377
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

# 378
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.Widening - 400
//    from integer to real
//    Always use float for real constants to get single precision real constants
//    Using compound arithmetic operators. Also using compound bitwise operators??

// Assignment of constant
# 400
Assignment.Compound.Coercion.Widening
>
{<T1#real#><V1> = <R1#float;2.0<=R1<=9.0;#>;<V1> += <R2#int;2<=R2<=9;#>;}
>
Type: expression
Hardness: 30

# 401
Assignment.Compound.Coercion.Widening
>
{<T1#real#><V1> = <R1#float;6.0<=R1<=9.0;#>;<V1> -= <R2#int;2<=R2<=5;#>;}
>
Type: expression
Hardness: 30

# 402
Assignment.Compound.Coercion.Widening
>
{<T1#real#><V1> = <R1#float;2<=R1<=5;#>;<V1> *= <R2#int;2<=R2<=5;#>;}
>
Type: expression
Hardness: 30

# 403
Assignment.Compound.Coercion.Widening
>
{<T1#real#><V1> = <R1#float;2<=R1<=9;#>;<V1> /= <R2#int;R2 = R1;#>;}
>
Type: expression
Hardness: 30

// Assignment of a variable
# 405
Assignment.Compound.Coercion.Widening
>
{<T1#real#><V1> = <R1#float;2.0<=R1<=9.0;#>;<T2#integer#><V2> = <R2#int;2<=R2<=9;#>;<V1> += <V2>;}
>
Type: expression
Hardness: 30

# 406
Assignment.Compound.Coercion.Widening
>
{<T1#real#><V1> = <R1#float;6.0<=R1<=9.0;#>;<T2#integer#><V2> = <R2#int;2<=R2<=5;#>;<V1> -= <V2>;}
>
Type: expression
Hardness: 30

# 407
Assignment.Compound.Coercion.Widening
>
{<T1#real#><V1> = <R1#float;2<=R1<=5;#>;<T2#integer#><V2> = <R2#int;2<=R2<=5;#>;<V1> *= <V2>;}
>
Type: expression
Hardness: 30

# 408
Assignment.Compound.Coercion.Widening
>
{<T1#real#><V1> = <R1#float;2<=R1<=9;#>;<T2#integer#><V2> = <R2#int;R2 = R1;#>;<V1> /= <V2>;}
>
Type: expression
Hardness: 30

// ------------------------------------------------------------------------
// Assignment.Compound.Coercion.Narrowing - 450
//    from real to integer
//    Always use float for real constants to get single precision real constants
//    Using compound arithmetic operators. Also using compound bitwise operators??

// Assignment of constant
# 450
Assignment.Compound.Coercion.Narrowing
>
{<T1#integer#><V1> = <R1#int;2<=R1<=9;#>;<V1> += <R2#float;2.0<=R2<=9.0;#>;}
>
Type: expression
Hardness: 30

# 451
Assignment.Compound.Coercion.Narrowing
>
{<T1#integer#><V1> = <R1#int;6<=R1<=9;#>;<V1> -= <R2#float;2<=R2<=5;#>;}
>
Type: expression
Hardness: 30

# 452
Assignment.Compound.Coercion.Narrowing
>
{<T1#integer#><V1> = <R1#int;2<=R1<=5;#>;<V1> *= <R2#float;2<=R2<=5;#>;}
>
Type: expression
Hardness: 30

# 453
Assignment.Compound.Coercion.Narrowing
>
{<T1#integer#><V1> = <R1#int;2<=R1<=9;#>;<V1> /= <R2#float;R2 = R1;#>;}
>
Type: expression
Hardness: 30


// Assignment of a variable
# 455
Assignment.Compound.Coercion.Narrowing
>
{<T1#integer#><V1> = <R1#int;2<=R1<=9;#>;<T2#real#><V2> = <R2#float;2.0<=R2<=9.0;#>;<V1> += <V2>;}
>
Type: expression
Hardness: 30

# 456
Assignment.Compound.Coercion.Narrowing
>
{<T1#integer#><V1> = <R1#int;6<=R1<=9;#>;<T2#real#><V2> = <R2#float;2<=R2<=5;#>;<V1> -= <V2>;}
>
Type: expression
Hardness: 30

# 457
Assignment.Compound.Coercion.Narrowing
>
{<T1#integer#><V1> = <R1#int;2<=R1<=5;#>;<T2#real#><V2> = <R2#float;2<=R2<=5;#>;<V1> *= <V2>;}
>
Type: expression
Hardness: 30

# 458
Assignment.Compound.Coercion.Narrowing
>
{<T1#integer#><V1> = <R1#int;2<=R1<=9;#>;<T2#real#><V2> = <R2#float;R2 = R1;#>;<V1> /= <V2>;}
>
Type: expression
Hardness: 30

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

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

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

# 502
Assignment.Prefix.Increment.Correct
>
{<T1#integer#><V1> = <R1#integer;1<=R1<=9;#>;<T1><V2>;<V2> = ++ <V1>;}
>
Type: expression
Hardness: 30

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



// Boolean operands are special cases - error in Java/C#, always return 1 in C++
# 505
Assignment.Prefix.Increment.Correct
>
{<T1#bool#><V1> = false; ++ <V1>;}
>
Type: expression
Hardness: 30

# 506
Assignment.Prefix.Increment.Correct
>
{<T1#bool#><V1> = true; ++ <V1>;}
>
Type: expression
Hardness: 30

// ------------------------------------------------------------------------
// Assignment.Prefix.Increment.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.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<R1> * ++ <V1>;}
>
Type: expression
Hardness: 30

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

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

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

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


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

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

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

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



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

# 536
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

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

# 538
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

# 539
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

# 540
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 - 550
//    W.r.t. itself only - chained/multiple
// DONE

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

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

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

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

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

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

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

# 602
Assignment.Prefix.Decrement.Correct
>
{<T1#integer#><V1> = <R1#integer;1<=R1<=9;#>;<T1><V2>;<V2> = -- <V1>;}
>
Type: expression
Hardness: 30

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


// Boolean operands are special cases - error in Java/C#/C++
# 605
Assignment.Prefix.Decrement.Correct
>
{<T1#bool#><V1> = true; -- <V1>;}
>
Type: expression
Hardness: 30

// ------------------------------------------------------------------------
// Assignment.Prefix.Decrement.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.Prefix.Decrement.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<R1> * -- <V1>;}
>
Type: expression
Hardness: 30

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

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

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

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


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

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

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

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



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

# 636
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

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

# 638
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

# 639
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

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

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

# 702
Assignment.Postfix.Increment.Correct
>
{<T1#integer#><V1> = <R1#integer;1<=R1<=9;#>;<T1><V2>;<V2> = <V1> ++;}
>
Type: expression
Hardness: 30

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



// Boolean operands are special cases - error in Java/C#, always return 1 in C++
# 705
Assignment.Postfix.Increment.Correct
>
{<T1#bool#><V1> = false; <V1> ++;}
>
Type: expression
Hardness: 30

# 706
Assignment.Postfix.Increment.Correct
>
{<T1#bool#><V1> = true; <V1> ++;}
>
Type: expression
Hardness: 30

// ------------------------------------------------------------------------
// Assignment.Postfix.Increment.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.Increment.Precedence 
>
{<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<R1> * <V1> ++;}
>
Type: expression
Hardness: 30

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

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

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

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


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

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

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

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



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

# 736
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

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

# 738
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

# 739
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

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

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

# 802
Assignment.Postfix.Decrement.Correct
>
{<T1#integer#><V1> = <R1#integer;1<=R1<=9;#>;<T1><V2>;<V2> = <V1> --;}
>
Type: expression
Hardness: 30

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


// Boolean operands are special cases - error in Java/C#/C++
# 805
Assignment.Postfix.Decrement.Correct
>
{<T1#bool#><V1> = true; <V1> --;}
>
Type: expression
Hardness: 30

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

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

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

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

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

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


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

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

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

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



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

# 836
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

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

# 838
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

# 839
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

# 840
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 - 900
//   to prioritize assignment over arithmetic, relational, operators

// # 900
// Assignment.Parenthesis.Precedence
// >
// {<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=5;#>;}
// >
// Type: expression
// Hardness: 30
// 
// // Testing pre and postfix together
// # 901
// Assignment.Parenthesis.Precedence
// >
// {<T1#integer#><V1> = <R1#integer;2<=R1<=5;#>;<T1><V2> = <R2#6<=R2<=9;#>; <V1> ++ + ++ <V2>;}
// >
// Type: expression
// Hardness: 30
// 
// # 902
// Assignment.Parenthesis.Precedence
// >
// {<T1#integer#><V1> = <R1#integer;6<=R1<=9;#>;<T1><V2> = <R2#2<=R2<=5;#>; -- <V1> - <V2> -- ;}
// >
// Type: expression
// Hardness: 30

// // Testing JURightShiftAssign in Java
// # 903
// Assignment.Parenthesis.Precedence
// >
// {<T1#integer#><V1> = <R1#integer;16<=R1<=99;#>;<V1> >>>= <R2#integer;1<=R2<=4;#>;}
// >
// Type: expression
// Hardness: 30

// ------------------------------------------------------------------------
// Assignment.Parenthesis.Associativity - 950

# 950
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 assignment values
# 90
Demonstration
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#>;}
>
Type: expression
Hardness: 10

// How to enter multiple underbraces
# 91
Demonstration
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#> + <R2#integer;2<=R2<=9;#>;}
>
Type: expression
Hardness: 20

// How to enter error values
# 92
Demonstration
>
{<T1#integer#><V1>;<V1> = <R1#integer;2<=R1<=9;#> / 0;}
>
Type: expression
Hardness: 20

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