// Syntax:
// Comment for reader's benefit, not parsed
// # Template Number - +100 for each new type of problem, +10 for each new subtype
// Learning Objective(s) for this template - when this template should be used
// ?
// If student gets the answer right, what OTHER objectives should get credit
// Usually, counterpoint to the point of the error, say allocation for missing 
// deallocation, Declaration for out of scope error, assignment for incorrect 
// referencing, etc.
// Make sure there is no overlap between this and antecedents!
// :
// If student gets the answer wrong, what OTHER objectives should get discredit
// Make sure there is no overlap between this and antecedents!
// >
// The template itself, no double quotes, preceded and succeeded by a single >
// >
// Type: debug / output / code
// Hardness: The student's correct percentage up to which this template will be used
// Note: Syntax for learning objectives (in antecedent, ifCorrect, ifWrong) 
// is dot.separated, with {,} to represent alternates.
// e.g., a.{b,c} is a.b and a.c
// This is NOT graph structured, i.e., a,{b,c}.d is not accounted for to mean
// a.b.d or a.c.d

// FUTURE IMPROVEMENTS
// -------------------------------------------------------------------------------
// The actual learning objectives:
// 
// 100 - output, changed to debug_output for consistency
// Switch.Condition.Matches case
// 125 - output, changed to debug_output for consistency
// Switch.Condition.Matches default
// 150 - output, changed to debug_output for consistency
// Switch.Condition.Matches none
// 175 - output, changed to debug_output for consistency
// Switch.Condition.Expression
//
// 200 - Done by RWalde - debug_output
// Switch.Condition.Switch condition is not an integer expression
// 225 - Done by RWalde - debug_output
// Switch.Case.Case value is not an integer expression
// 250 - Done by RWalde - debug_output
// Switch.Case.Case value is not a constant expression
// 
// 300 - output, changed to debug_output for consistency
// Switch.Body.No statement
//
// 325 - debug_output
// Switch.Body.No break.Has statements
// 350 - debug_output
// Switch.Body.No break.No statement
// 
// 400 - output
// Switch.Nested
// 500 - output
// Switch.Multiple
// 

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


// ---------------------------------------------------------------------------
// 100
// Switch.Condition.Matches case

// Always has default, never used; all cases have break and at least one statement
// Case value options:
//    1-5
//    5 random values
//    50-10
// Body of switch options:
//    Print random constants
//    Print an expression involving case value, e.g., monotonic up or exchange
//    Print an expression involving a variable other than the one in the condition
//    Assign to a variable, which is printed after the switch
//      Random value
//      Value of an expression involving case value

// 1-5 cases
# 100
Switch.Condition.Matches case
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;switch(<V1>){ case 1: << <R2#10<=R2<20;#>; break; case 2: << <R3#20<=R3<30;#>; break; case 3: << <R4#30<=R4<40;#>; break; case 4: << <R5#40<=R5<50;#>; break; case 5: << <R6#50<=R6<60;#>; break; default: << <R7#60<=R7<100;#>; break; }}}
>
Type: debug_output
Hardness: 20

# 101
Switch.Condition.Matches case
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;switch(<V1>){ case 1: << <V1> + 4; break; case 2: << <V1> + 2; break; case 3: << <V1>; break; case 4: << <V1> - 2; break; case 5: << <V1> - 4; break; default: << <V1> * <V1>; break; }}}
>
Type: debug_output
Hardness: 20

# 102
Switch.Condition.Matches case
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#6<=R2<=10;#>;switch(<V1>){ case 1: << <V1> * <V2>; break; case 2: << <V2> - <V1>; break; case 3: << <V1> + <V2>; break; case 4: << <V1> - <V2>; break; case 5: << <V2> + <R1>; break; default: << <V2> * <V2>; break; }}}
>
Type: debug_output
Hardness: 20

# 103
Switch.Condition.Matches case
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;switch(<V1>){ case 1: <V2> = <V1> * 10; break; case 2: <V2> = <V1> + 10; break; case 3: <V2> = 0; break; case 4: <V2> = <V1> + 2; break; case 5: <V2> = <V1> * 2; break; default: <V2> = <V1> % 10; break; } << <V2>;}}
>
Type: debug_output
Hardness: 20


// 5 random values for cases
# 105
Switch.Condition.Matches case
>
{<T0><F0>(){<T1#integer#><V1>=<R1#30<=R1<40;#>;switch(<V1>){ case <R2#40<=R2<50;#>: << <R1>; break; case <R3#20<=R3<30;#>: << <R2>; break; case <R4#50<=R4<60;#>: << <R3>; break; case <R1>: << <R4>; break; case <R5#10<=R5<20;#>: << <R6#60<=R6<70;#>; break; default: << <R7#70<=R7<100;#>; break; }}}
>
Type: debug_output
Hardness: 20

# 106
Switch.Condition.Matches case
>
{<T0><F0>(){<T1#integer#><V1>=<R1#40<=R1<50;#>;switch(<V1>){ case <R2#20<=R2<30;#>: << <V1> - 20; break; case <R1>: << <V1> + 20; break; case <R3#10<=R3<20;#>: << <V1> - 10; break; case <R4#50<=R4<60;#>: << 50 - <V1>; break; case <R5#30<=R5<40;#>: << <V1> + 10; break; default: << <V1> + <V1>; break; }}}
>
Type: debug_output
Hardness: 20

# 107
Switch.Condition.Matches case
>
{<T0><F0>(){<T1#integer#><V1>=<R1#10<=R1<20;#>;<T1><V2>=<R2#20<=R2<30;#>;switch(<V1>){ case <R3#30<=R3<40;#>: << <V2> * <V1>; break; case <R4#50<=R4<60;#>: << <V2> / <V1>; break; case <R2>: << <V2> + <V1>; break; case <R5#40<=R5<50;#>: << <V2> % <V1>; break; case <R1>: << <V2> - <V1>; break; default: << <V2> * <V2>; break; }}}
>
Type: debug_output
Hardness: 20

# 108
Switch.Condition.Matches case
>
{<T0><F0>(){<T1#integer#><V1>=<R1#60<=R1<70;#>;<T1><V2>=<R2#1<=R2<10;#>;switch(<V1>){ case <R3#20<=R3<30;#>: <V2> = <V2> * 10; break; case <R4#50<=R4<60;#>: <V2> = <V1> % <V2>; break; case <R1>: <V2> = <V2> + 10; break; case <R5#40<=R5<50;#>: <V2> = <V1> / <V2>; break; case <R6#30<=R6<40;#>: <V2> = <V1> - <V2>; break; default: <V2> = <V2> * <V2>; break; } << <V2>;}}
>
Type: debug_output
Hardness: 20


// cases 50-10
# 110
Switch.Condition.Matches case
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=5;#> * 10;switch(<V1>){ case 50: << <R2#10<=R2<20;#>; break; case 40: << <R3#20<=R3<30;#>; break; case 30: << <R4#30<=R4<40;#>; break; case 20: << <R5#40<=R5<50;#>; break; case 10: << <R6#50<=R6<60;#>; break; default: << <R7#60<=R7<100;#>; break; }}}
[<R1#1<=R1<=5;#>]{<T0><F0>(){<T1#integer#><V1> = <R2#R2=R1*10;#>;switch(<V1>){ case 50: << <R3#10<=R3<20;#>; break; case 40: << <R4#20<=R4<30;#>; break; case 30: << <R5#30<=R5<40;#>; break; case 20: << <R6#40<=R6<50;#>; break; case 10: << <R7#50<=R7<60;#>; break; default: << <R8#60<=R8<100;#>; break; }}}
>
Type: debug_output
Hardness: 20

# 111
Switch.Condition.Matches case
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=5;#> * 2;switch(<V1>){ case 10: << <V1> / 10; break; case 8: << <V1> + <V1>; break; case 6: << <V1>; break; case 4: << <V1> - <V1>; break; case 2: << <V1> * <V1>; break; default: << <V1> % 10; break; }}}
[<R1#1<=R1<=5;#>]{<T0><F0>(){<T1#integer#><V1> = <R2#R2=R1*2;#>;switch(<V1>){ case 10: << <V1> / 10; break; case 8: << <V1> + <V1>; break; case 6: << <V1>; break; case 4: << <V1> - <V1>; break; case 2: << <V1> * <V1>; break; default: << <V1> % 10; break; }}}
>
Type: debug_output
Hardness: 20

# 112
Switch.Condition.Matches case
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=5;#> * 5;<T1><V2> = <R2#6<=R2<=10;#> * 10;switch(<V1>){ case 25: << <V1> - <V2>; break; case 20: << <V2> / 10; break; case 15: << <V1> / 10; break; case 10: << <V1> + <V2>; break; case 5: << <V2> - <V1>; break; default: << <V2> * <V1>; break; }}}
[<R1#1<=R1<=5;#>,<R2#6<=R2<=10;#>]{<T0><F0>(){<T1#integer#><V1> = <R3#R3=R1*5;#>;<T1><V2> = <R4#R4=R2*10;#>;switch(<V1>){ case 25: << <V1> - <V2>; break; case 20: << <V2> / 10; break; case 15: << <V1> / 10; break; case 10: << <V1> + <V2>; break; case 5: << <V2> - <V1>; break; default: << <V2> * <V1>; break; }}}
>
Type: debug_output
Hardness: 20

# 113
Switch.Condition.Matches case
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#5<=R1<=9;#> * 10;<T1><V2>;switch(<V1>){ case 90: <V2> = <V1> / 10; break; case 80: <V2> = <V1> - 30; break; case 70: <V2> = <V1>; break; case 60: <V2> = <V1> + 20; break; case 50: <V2> = <V1> * 2; break; default: <V2> = <V1> % 10; break; } << <V2>;}}
[<R1#5<=R1<=9;#>]{<T0><F0>(){<T1#integer#><V1> = <R2#R2=R1*10;#>;<T1><V2>;switch(<V1>){ case 90: <V2> = <V1> / 10; break; case 80: <V2> = <V1> - 30; break; case 70: <V2> = <V1>; break; case 60: <V2> = <V1> + 20; break; case 50: <V2> = <V1> * 2; break; default: <V2> = <V1> % 10; break; } << <V2>;}}
>
Type: debug_output
Hardness: 20


// ---------------------------------------------------------------------------
// 125
// Switch.Condition.Matches default


// 1-5 cases
# 125
Switch.Condition.Matches default
>
{<T0><F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;switch(<V1>){ case 1: << <R2#10<=R2<20;#>; break; case 2: << <R3#20<=R3<30;#>; break; case 3: << <R4#30<=R4<40;#>; break; case 4: << <R5#40<=R5<50;#>; break; case 5: << <R6#50<=R6<60;#>; break; default: << <R7#60<=R7<100;#>; break; }}}
>
Type: debug_output
Hardness: 20

# 126
Switch.Condition.Matches default
>
{<T0><F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;switch(<V1>){ case 1: << <V1> + <V1>; break; case 2: << <V1> % 2; break; case 3: << <V1> * 2; break; case 4: << <V1> * <V1>; break; case 5: << <V1> - <V1>; break; default: << <V1>; break; }}}
>
Type: debug_output
Hardness: 20

# 127
Switch.Condition.Matches default
>
{<T0><F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;<T1><V2>=<R2#1<=R2<=5;#>;switch(<V1>){ case 1: << <V1> % <V2>; break; case 2: << <V2> - <V1>; break; case 3: << <V1> * <V2>; break; case 4: << <V1> - <V2>; break; case 5: << <V2> % <V1>; break; default: << <V2>; break; }}}
>
Type: debug_output
Hardness: 20

# 128
Switch.Condition.Matches default
>
{<T0><F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;<T1><V2>;switch(<V1>){ case 1: <V2> = <V1> + <V1>; break; case 2: <V2> = <V1> * <V1>; break; case 3: <V2> = <V1> % 10; break; case 4: <V2> = <V1> / 3; break; case 5: <V2> = <V1>; break; default: <V2> = <V1> + 1; break; } << <V2>;}}
>
Type: debug_output
Hardness: 20


// 5 random values for cases
# 130
Switch.Condition.Matches default
>
{<T0><F0>(){<T1#integer#><V1>=<R1#30<=R1<40;#>;switch(<V1>){ case <R2#40<=R2<50;#>: << <R1>; break; case <R3#20<=R3<30;#>: << <R2>; break; case <R4#50<=R4<60;#>: << <R3>; break; case <R5#10<=R5<20;#>: << <R4>; break; case <R6#60<=R6<70;#>: << <R5>; break; default: << <R7#70<=R7<100;#>; break; }}}
>
Type: debug_output
Hardness: 20

# 131
Switch.Condition.Matches default
>
{<T0><F0>(){<T1#integer#><V1>=<R1#40<=R1<50;#>;switch(<V1>){ case <R2#20<=R2<30;#>: << <V1> - <R2>; break; case <R3#10<=R3<20;#>: << <V1> * <R3>; break; case <R4#50<=R4<60;#>: << <R4> - <V1>; break; case <R5#30<=R5<40;#>: << <R5> + <V1>; break; case <R6#60<=R6<70;#>: << <R6> - <V1>; break; default: << <V1> - 40; break; }}}
>
Type: debug_output
Hardness: 20

# 132
Switch.Condition.Matches default
>
{<T0><F0>(){<T1#integer#><V1>=<R1#10<=R1<20;#>;<T1><V2>=<R2#20<=R2<30;#>;switch(<V1>){ case <R3#30<=R3<40;#>: << <V1> % <V2>; break; case <R4#50<=R4<60;#>: << <V2> / <V1>; break; case <R5#60<=R5<70;#>: << <V2> + <V1>; break; case <R6#40<=R6<50;#>: << <V2> % <V1>; break; case <R2>: << <V1> / <V2>; break; default: << <V2>; break; }}}
>
Type: debug_output
Hardness: 20

# 133
Switch.Condition.Matches default
>
{<T0><F0>(){<T1#integer#><V1>=<R1#40<=R1<50;#>;<T1><V2>=<R2#1<=R2<10;#>;switch(<V1>){ case <R3#50<=R3<60;#>: <V2> = <V1> / 10; break; case <R4#20<=R4<30;#>: <V2> = <V1> % <V2>; break; case <R5#60<=R5<70;#>: <V2> = <V1> / <V2>; break; case <R2>: <V2> = <V2> % <V1>; break; case <R6#30<=R6<40;#>: <V2> = <V1> * 10; break; default: <V2> = <V1>; break; } << <V2>;}}
>
Type: debug_output
Hardness: 20


// cases 50-10
# 135
Switch.Condition.Matches default
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=4;#> * 10;switch(<V1>){ case 90: << <R2#40<=R2<50;#>; break; case 80: << <R3#20<=R3<30;#>; break; case 70: << <R4#30<=R4<40;#>; break; case 60: << <R5#50<=R5<60;#>; break; case 50: << <R6#10<=R6<20;#>; break; default: << <R7#10<=R7<100;#>; break; }}}
[<R1#1<=R1<=4;#>]{<T0><F0>(){<T1#integer#><V1> = <R2#R2=R1*10;#>;switch(<V1>){ case 90: << <R3#40<=R3<50;#>; break; case 80: << <R4#20<=R4<30;#>; break; case 70: << <R5#30<=R5<40;#>; break; case 60: << <R6#50<=R6<60;#>; break; case 50: << <R7#10<=R7<20;#>; break; default: << <R8#10<=R8<100;#>; break; }}}
>
Type: debug_output
Hardness: 20

# 136
Switch.Condition.Matches default
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=5;#> * 2;switch(<V1>){ case 9: << <V1> % 10; break; case 7: << <V1> % 2; break; case 5: << <V1> * <V1>; break; case 3: << <V1> / 10; break; case 1: << <V1> * 5; break; default: << <V1> / 2; break; }}}
[<R1#1<=R1<=5;#>]{<T0><F0>(){<T1#integer#><V1> = <R2#R2=R1*2;#>;switch(<V1>){ case 9: << <V1> % 10; break; case 7: << <V1> % 2; break; case 5: << <V1> * <V1>; break; case 3: << <V1> / 10; break; case 1: << <V1> * 5; break; default: << <V1> / 2; break; }}}
>
Type: debug_output
Hardness: 20

# 137
Switch.Condition.Matches default
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#6<=R1<=9;#> * 10;<T1><V2> = <R2#1<=R2<=5;#> * 10;switch(<V1>){ case 50: << <V2> * 10; break; case 40: << <V2> * <V2>; break; case 30: << <V2> * 5; break; case 20: << <V2> * 2; break; case 10: << <V2> * <V1>; break; default: << <V2>; break; }}}
[<R1#6<=R1<=9;#>,<R2#1<=R2<=5;#>]{<T0><F0>(){<T1#integer#><V1> =<R3#R3=R1*10;#>;<T1><V2> = <R4#R4=R2*10;#>;switch(<V1>){ case 50: << <V2> * 10; break; case 40: << <V2> * <V2>; break; case 30: << <V2> * 5; break; case 20: << <V2> * 2; break; case 10: << <V2> * <V1>; break; default: << <V2>; break; }}}
>
Type: debug_output
Hardness: 20

# 138
Switch.Condition.Matches default
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=5;#> * 5;<T1><V2>;switch(<V1>){ case 50: <V2> = <V1> % 5; break; case 45: <V2> = <V1> / 10; break; case 40: <V2> = <V1> % 10; break; case 35: <V2> = <V1> / 5; break; case 30: <V2> = <V1> % 2; break; default: <V2> = <V1> * 2; break; } << <V2>;}}
[<R1#1<=R1<=5;#>]{<T0><F0>(){<T1#integer#><V1> = <R2#R2=R1*5;#>;<T1><V2>;switch(<V1>){ case 50: <V2> = <V1> % 5; break; case 45: <V2> = <V1> / 10; break; case 40: <V2> = <V1> % 10; break; case 35: <V2> = <V1> / 5; break; case 30: <V2> = <V1> % 2; break; default: <V2> = <V1> * 2; break; } << <V2>;}}
>
Type: debug_output
Hardness: 20


// ---------------------------------------------------------------------------
// 150
// Switch.Condition.Matches none


// 1-5 cases
# 150
Switch.Condition.Matches none
>
{<T0><F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;switch(<V1>){ case 1: << <R2#50<=R2<60;#>; break; case 2: << <R3#40<=R3<50;#>; break; case 3: << <R4#30<=R4<40;#>; break; case 4: << <R5#20<=R5<30;#>; break; case 5: << <R6#10<=R6<20;#>; break; }}}
>
Type: debug_output
Hardness: 20

# 151
Switch.Condition.Matches none
>
{<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<5;#>;switch(<V1>){ case 5: << <V1> + <V1>; break; case 6: << <V1> - <V1>; break; case 7: << <V1> * 2; break; case 8: << <V1> % 2; break; case 9: << <V1> * <V1>; break; }}}
>
Type: debug_output
Hardness: 20

# 152
Switch.Condition.Matches none
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=5;#> * 10;<T1><V2>=<R2#1<=R2<=5;#>;switch(<V1>){ case 3: << <V1> % <R1>; break; case 4: << <V1> % 10; break; case 5: << <V1> + <V2>; break; case 6: << <V1> - <V2>; break; case 7: << <V1> % <V2>; break; } << <V2>;}}
[<R1#1<=R1<=5;#>]{<T0><F0>(){<T1#integer#><V1> = <R2#R2=R1*10;#>;<T1><V2>=<R3#1<=R3<=5;#>;switch(<V1>){ case 3: << <V1> % <R1>; break; case 4: << <V1> % 10; break; case 5: << <V1> + <V2>; break; case 6: << <V1> - <V2>; break; case 7: << <V1> % <V2>; break; } << <V2>;}}
>
Type: debug_output
Hardness: 20

# 153
Switch.Condition.Matches none
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#3<=R1<=9;#> * 2;<T1><V2>=<R2#1<=R2<=5;#>;switch(<V1>){ case 1: <V2> = <V1> * <V1>; break; case 2: <V2> = <V1> / 2; break; case 3: <V2> = <V1> * 10; break; case 4: <V2> = <V1> % 2; break; case 5: <V2> = <V1> / <R1>; break; } << <V2>;}}
[<R1#3<=R1<=9;#>]{<T0><F0>(){<T1#integer#><V1> =<R2#R2=R1*2;#>;<T1><V2>=<R3#1<=R3<=5;#>;switch(<V1>){ case 1: <V2> = <V1> * <V1>; break; case 2: <V2> = <V1> / 2; break; case 3: <V2> = <V1> * 10; break; case 4: <V2> = <V1> % 2; break; case 5: <V2> = <V1> / <R1>; break; } << <V2>;}}
>
Type: debug_output
Hardness: 20


// 5 random values for cases
# 155
Switch.Condition.Matches none
>
{<T0><F0>(){<T1#integer#><V1>=<R1#40<=R1<50;#>;switch(<V1>){ case <R2#50<=R2<60;#>: << <R1>; break; case <R3#20<=R3<30;#>: << <R2>; break; case <R4#30<=R4<40;#>: << <R3>; break; case <R5#60<=R5<70;#>: << <R4>; break; case <R6#10<=R6<20;#>: << <R5>; break; }}}
>
Type: debug_output
Hardness: 20

# 156
Switch.Condition.Matches none
>
{<T0><F0>(){<T1#integer#><V1>=<R1#30<=R1<40;#>;switch(<V1>){ case <R2#50<=R2<60;#>: << <R2> - <V1>; break; case <R3#40<=R3<50;#>: << <V1> + <R3>; break; case <R4#20<=R4<30;#>: << <V1> - <R4>; break; case <R5#60<=R5<70;#>: << <R5> - <V1>; break; case <R6#10<=R6<20;#>: << <V1> - <R6>; break; }}}
>
Type: debug_output
Hardness: 20

# 157
Switch.Condition.Matches none
>
{<T0><F0>(){<T1#integer#><V1>=<R1#20<=R1<30;#>;<T1><V2>=<R2#70<=R2<80;#>;switch(<V1>){ case <R3#40<=R3<50;#>: <V2> = <V2> - <R3>; break; case <R4#10<=R4<20;#>: <V2> = <V2> / <R4>; break; case <R5#60<=R5<70;#>: <V2> = <R5> / <V1>; break; case <R6#30<=R6<40;#>: <V2> = <R6> - <V1>; break; case <R7#50<=R7<60;#>: <V2> = <V2> - <V1>; break; } << <V2>; }}
>
Type: debug_output
Hardness: 20

# 158
Switch.Condition.Matches none
>
{<T0><F0>(){<T1#integer#><V1>=<R1#70<=R1<80;#>;<T1><V2>=<R2#10<=R2<20;#>;switch(<V1>){ case <R3#30<=R3<40;#>: <V1> = <V1> + <V2>; break; case <R4#50<=R4<60;#>: <V1> = <V1> / <V2>; break; case <R5#80<=R5<90;#>: <V1> = <V1> % <V2>; break; case <R6#60<=R6<70;#>: <V1> = <V1> - <V2>; break; case <R7#40<=R7<50;#>: <V1> = <V2> - <V1>; break; } << <V1>;}}
>
Type: debug_output
Hardness: 20


// cases 50-10
# 160
Switch.Condition.Matches none
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=5;#> * 20;switch(<V1>){ case 90: << <R2#0<=R2<20;#>; break; case 70: << <R3#20<=R3<40;#>; break; case 50: << <R4#40<=R4<60;#>; break; case 30: << <R5#60<=R5<80;#>; break; case 10: << <R6#80<=R6<100;#>; break; }}}
[<R1#1<=R1<=5;#>]{<T0><F0>(){<T1#integer#><V1> = <R2#R2=R1*20;#>;switch(<V1>){ case 90: << <R3#0<=R3<20;#>; break; case 70: << <R4#20<=R4<40;#>; break; case 50: << <R5#40<=R5<60;#>; break; case 30: << <R6#60<=R6<80;#>; break; case 10: << <R7#80<=R7<100;#>; break; }}}
>
Type: debug_output
Hardness: 20

# 161
Switch.Condition.Matches none
>
{<T0><F0>(){<T1#integer#><V1> = <R1#5<=R1<=9;#>;switch(<V1>){ case 4: << <V1> / 2; break; case 3: << <V1> % 2; break; case 2: << <V1> * 2; break; case 1: << <V1> * 3; break; case 0: << <V1> + 5; break; }}}
>
Type: debug_output
Hardness: 20

# 162
Switch.Condition.Matches none
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=5;#> * 10;<T1><V2> = <R1>;switch(<V1>){ case 55: <V2> = <V2> * 2; break; case 45: <V2> = <V2> * 10; break; case 35: <V2> = <V1> / <V2>; break; case 25: <V2> = <V1> / 2; break; case 15: <V2> = <V2> + <V1>; break; } << <V2>; }}
[<R1#1<=R1<=5;#>]{<T0><F0>(){<T1#integer#><V1> = <R2#R2=R1*10;#>;<T1><V2> = <R1>;switch(<V1>){ case 55: <V2> = <V2> * 2; break; case 45: <V2> = <V2> * 10; break; case 35: <V2> = <V1> / <V2>; break; case 25: <V2> = <V1> / 2; break; case 15: <V2> = <V2> + <V1>; break; } << <V2>; }}
>
Type: debug_output
Hardness: 20

# 163
Switch.Condition.Matches none
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#6<=R1<=10;#> * 5;switch(<V1>){ case 20: <V1> = <V1> - 5; break; case 15: <V1> = <V1> / 5; break; case 10: <V1> = <V1> % 5; break; case 5: <V1> = <V1> * 5; break; case 0: <V1> = <V1> + 5; break; } << <V1>;}}
[<R1#6<=R1<=10;#>]{<T0><F0>(){<T1#integer#><V1> = <R2#R2=R1*5;#>;switch(<V1>){ case 20: <V1> = <V1> - 5; break; case 15: <V1> = <V1> / 5; break; case 10: <V1> = <V1> % 5; break; case 5: <V1> = <V1> * 5; break; case 0: <V1> = <V1> + 5; break; } << <V1>;}}
>
Type: debug_output
Hardness: 20

// ---------------------------------------------------------------------------
// 175
// Switch.Condition.Expression
// Incrementing
# 175
Switch.Condition.Expression
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=5;#>;<T1><V2> = 10;switch(<V1> + <V2>){ case 11: << <V1>; break; case 12: << <V2>; break; case 13: << <V2> - <V1>; break; case 14: << <V2> * <V1>; break; case 15: << <V2> * <V2>; break; default: << <V2> + <V1>; break; }}}
[<R1#1<=R1<=5;#>,<R2#1<=R2<=9;#>]{<T0><F0>(){<T1#integer#><V1> = <R1>;<T1><V2> = <R3#R3=R2*10;#>;switch(<V1> + <V2>){ case <R4#R4=R3+1;#>: << <V1>; break; case <R5#R5=R3+2;#>: << <V2>; break; case <R6#R6=R3+3;#>: << <V2> - <V1>; break; case <R7#R7=R3+4;#>: << <V2> * <V1>; break; case <R8#R8=R3+5;#>: << <V2> * <V2>; break; default: << <V2> + <V1>; break; }}}
>
Type: debug_output
Hardness: 40

# 176
Switch.Condition.Expression
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=5;#>;<T1><V2> = 10;switch(<V2> - <V1>){ case 5: << <V1> * 2; break; case 6: << <V1> + <V2>; break; case 7: << <V2> * 2; break; case 8: << <V2> * <V1>; break; case 9: << <V1> - <V2>; break; default: << <V2> - <V1>; break; }}}
[<R1#1<=R1<=5;#>,<R2#1<=R2<=9;#>]{<T0><F0>(){<T1#integer#><V1> = <R1>;<T1><V2> = <R3#R3=R2*10;#>;switch(<V2> - <V1>){ case <R4#R4=R3 - 5;#>: << <V1> * 2; break; case <R5#R5=R3 - 4;#>: << <V1> + <V2>; break; case <R6#R6=R3 - 3;#>: << <V2> * 2; break; case <R7#R7=R3 - 2;#>: << <V2> * <V1>; break; case <R8#R8=R3 - 1;#>: << <V1> - <V2>; break; default: << <V2> - <V1>; break; }}}
>
Type: debug_output
Hardness: 40

# 177
Switch.Condition.Expression
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=5;#>;<T1><V2> = 10;switch(<V1> * <V2>){ case 10: << <V2> + <V1>; break; case 20: << <V2> / <V1>; break; case 30: << <V2> - <V1>; break; case 40: << <V2>; break; case 50: << <V1>; break; default: << <V2> * <V1>; break; }}}
[<R1#1<=R1<=5;#>,<R2#1<=R2<=3;#>]{<T0><F0>(){<T1#integer#><V1> = <R1>;<T1><V2> = <R3#R3=R2*10;#>;switch(<V1> * <V2>){ case <R3>: << <V2> + <V1>; break; case <R4#R4 = R3 * 2;#>: << <V2> / <V1>; break; case <R4#R4 = R3 * 3;#>: << <V2> - <V1>; break; case <R4#R4 = R3 * 4;#>: << <V2>; break; case <R4#R4 = R3 * 5;#>: << <V1>; break; default: << <V2> * <V1>; break; }}}
>
Type: debug_output
Hardness: 40

# 178
Switch.Condition.Expression
>
{<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=5;#>;<T1><V2> = 12;switch(<V2> / <V1>){ case 2: <V2> = <V2> + 3; break; case 3: <V2> = <V2> - 2; break; case 4: <V2> = <V2> - <V1>; break; case 6: <V2> = <V1> * 2; break; case 12: <V2> = <V2> + <V1>; break; default: <V2> = <V2> / <V1>; break; } << <V2>; }}
>
Type: debug_output
Hardness: 45

# 179
Switch.Condition.Expression
>
{<T0><F0>(){<T1#integer#><V1> = <R1#3<=R1<=7;#>;<T1><V2> = 10;switch(<V2> % <V1>){ case 0: <V2> = <V2> / <V1>; break; case 1: <V2> = <V2> * <V1>; break; case 2: <V2> = <V2> + <V1>; break; case 3: <V2> = <V2> - <V1>; break; case 4: <V2> = <V2> * <V1>; break; default: <V2> = <V2> % <V1>; break; } << <V2>; }}
// {<T0><F0>(){<T1#integer#><V1> = <R1#3<=R1<=7;#>;<T1><V2> = 10;switch(<V2> % <V1>){ case 0: <V2> = <V2> / <V1>; break; case 1: <V2> = <V2> * <V1>; break; case 2: <V2> = <V2> + <V1>; break; case 3: <V2> = <V2> - <V1>; break; case 4: <V2> = <V2> * <V1>; break; case 5: break; case 6: break; default: <V2> = <V2> % <V1>; break; } << <V2>; }}
>
Type: debug_output
Hardness: 45


// Decrementing
# 185
Switch.Condition.Expression
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=3;#>;<T1><V2> = <R2#1<=R2<=3;#>;switch(<V1> + <V2>){ case 6: << <V1> / <V2>; break; case 5: << <V1> - <V2>; break; case 4: << <V1> * <V2>; break; case 3: << <V2> - <V1>; break; case 2: << <V1> * <V2>; break; default: << <V1> + <V2>; break; }}}
[<R1#1<=R1<=5;#>,<R2#1<=R2<=5;#>,<R3#R3=R2+5;#>,<R4#R4=R2+4;#>,<R5#R5=R2+3;#>,<R6#R6=R2+2;#>,<R7#R7=R2+1;#>]{<T0><F0>(){<T1#integer#><V1> = <R1>;<T1><V2> = <R2>;switch(<V1> + <V2>){ case <R3>: << <V1>; break; case <R4>: << 10 - <V2>; break; case <R5>: << <V1> * <V2>; break; case <R6>: << 10 - <V1>; break; case <R7>: << <V2>; break; default: << <V1> + <V2>; break; }}}
>
Type: debug_output
Hardness: 40

# 186
Switch.Condition.Expression
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=3;#>;<T1><V2> = <R2#1<=R2<=3;#>;switch(<V2> - <V1>){ case 2: << <V2> + <V1>; break; case 1: << <V2>; break; case 0: << <V2> * 2; break; case -1: << <V1>; break; case -2: << <V1> - <V2>; break; default: << <V2> - <V1>; break; }}}
[<R1#1<=R1<=5;#>,<R2#6<=R2<=9;#>,<R3#R3 = R2 - 5;#>,<R4#R4 = R2 - 4;#>,<R5#R5 = R2 - 3;#>,<R6#R6 = R2 - 2;#>,<R7#R7 = R2 - 1;#>]{<T0><F0>(){<T1#integer#><V1> = <R1>;<T1><V2> = <R2>;switch(<V2> - <V1>){ case <R3>: << <V2> + <V1>; break; case <R4>: << <V1>; break; case <R5>: << <V2> * 2; break; case <R6>: << <V2> + 10; break; case <R7>: << <V1> - <V2>; break; default: << <V2> - <V1>; break; }}}
>
Type: debug_output
Hardness: 40

# 187
Switch.Condition.Expression
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=3;#>;<T1><V2> = <R2#1<=R2<=3;#>;<T1><V3>;switch(<V1> * <V2>){ case 9: <V3> = <V2> / <V1>; break; case 6: <V3> = <V2> * 2; break; case 4: <V3> = <V2> % <V1>; break; case 3: <V3> = <V1> * 10; break; case 2: <V3> = <V1> * 5; break; case 1: <V3> = <V2> + <V1>; break; default: <V3> = <V2> * <V1>; break; } << <V3>;}}
[<R1#1<=R1<=5;#>,<R2#1<=R2<=7;#>,<R3#R3=R2*5;#>,<R4#R4=R2*4;#>,<R5#R5=R2*3;#>,<R6#R6=R2*2;#>]{<T0><F0>(){<T1#integer#><V1> = <R1>;<T1><V2> = <R2>;<T1><V3>;switch(<V1> * <V2>){ case <R3>: <V3> = <V2> + 10; break; case <R4>: <V3> = <V2> + 20; break; case <R5>: <V3> = <V2> + 30; break; case <R6>: <V3> = <V2> + 40; break; case <R7>: <V3> = <V2> + 50; break; case <R2>: <V3> = <V2> + 60; break; default: <V3> = <V2> + 100; break; } << <V3>;}}
>
Type: debug_output
Hardness: 40

# 188
Switch.Condition.Expression
>
{<T0><F0>(){<T1#integer#><V1> = <R1#2<=R1<=6;#>;<T1><V2> = 60;<T1><V3>;switch(<V2> / <V1>){ case 30: <V3> = <V2> / 10; break; case 20: <V3> = <V1> * <V1>; break; case 15: <V3> = <V1> / 2; break; case 12: <V3> = <V1> * 2; break; case 10: <V3> = <V1> + <V1>; break; default: <V3> = <V2> / <V1>; break; } << <V3>; }}
>
Type: debug_output
Hardness: 45

# 189
Switch.Condition.Expression
>
// {<T0><F0>(){<T1#integer#><V1> = <R1#5<=R1<=9;#>;<T1><V2> = 10;<T1><V3>;switch(<V2> % <V1>){ case 0: <V3> = <V2>; break; case 1: <V3> = <V1> * 2; break; case 2: <V3> = <V1> / 2; break; case 3: <V3> = <V1> + 2; break; case 4: <V3> = <V1> / 3; break; default: <V3> = <V2> % <V1>; break; } << <V3>; }}
[<R1#2<=R1<=5;#>,<R2#7<=R2<=15;#>]{<T0><F0>(){<T1#integer#><V1> = <R1>;<T1><V2> = <R2>;<T1><V3>;switch(<V2> % <V1>){ case 4: <V3> = <V2>; break; case 3: <V3> = <V2> * 10; break; case 2: <V3> = <V1>; break; case 1: <V3> = <V1> + 20; break; case 0: <V3> = <V1> * 10; break; default: <V3> = <V2> % <V1>; break; } << <V3>; }}
>
Type: debug_output
Hardness: 45

// ---------------------------------------------------------------------------
// 200 
// Switch.Condition.Real
// Added by Ralph Walde  1/22/2010

// Condition is variable 200-
//   Cases are increasing and consecutive or multiples of 5/10/100
//      Action prints random constant
//      Action prints expression involving condition variable
//      Action assings random value to a secondary variable that is printed after the switch
// Condition is expression 205-
//   Cases are increasing and consecutive or multiples of 5/10/100
//      Action prints random constant
//      Action prints expression involving condition variable
//      Action assings random value to a secondary variable that is printed after the switch

// 2 X 2 X 3 combinations of condition (variable vs expression) X cases (increasing versus decreasing) X action (3 types as listed above)

// --------------------------------------------------------------------------- 
// Added by Ralph Walde  1/22/2010 thru 2/7/2010 
// 200 - 224 Switch.Condition.Switch condition is not an integer expression
// 225 - 249 Switch.Case.Real 
// 250 - 274 Switch.Case.Case value is not a constant expression

// 200 - 224 Switch.Condition.Switch condition is not an integer expression

// 200-202 Condition is real variable 
//   Cases are increasing and consecutive or multiples of 5/10/100 
//      Action prints random constant 
//      Action prints expression involving condition variable 
//      Action assigns random value to a secondary variable that is printed after the switch 
// 205-207 Condition is expression involving real variable 
//   Cases are increasing and consecutive or multiples of 5/10/100 
//      Action prints random constant 
//      Action prints expression involving condition variable 
//      Action assigns random value to a secondary variable that is printed after the switch 
// 210-212 Condition is real variable,  Cases are decreasing, three kinds of action 
// 215-217 Condition is real variable expression, Cases are decreasing,  three kinds of action 

// 200  switch(<V1>)   Cases increase <R1> + 10 to <R1> + 50,    Random case matches,      Action - Cases output random constants 
# 200 
Switch.Condition.Switch condition is not an integer expression
> 
[<R1#1<=R1<=9;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + 10 * R2;#>,<R4#float;R4=R3 * 1.0;#>]{<T0><F0>(){<T1#float#><V1>=<R4>;switch(<V1>){ case <R5#R5=R1 + 10;#>: << <R6#20<=R6<30;#>; break; case <R7#R7=R1 + 20;#>: << <R8#30<=R8<40;#>; break; case <R9#R9=R1 + 30;#>: << <R10#40<=R10<50;#>; break; case <R11#R11=R1 + 40;#>: << <R12#50<=R12<60;#>; break; case <R13#R13=R1 + 50;#>: << <R14#60<=R14<70;#>; break; default: << <R15#70<=R15<80;#>; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 201 switch(<V1>),  Cases increase <R1> + 1 to <R1> + 5,  Random case matches,   Cases output expressions of <V1> 
# 201 
Switch.Condition.Switch condition is not an integer expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + R2;#>,<R4#float;R4=R3 * 1.0;#>]{<T0><F0>(){<T1#float#><V1>=<R4>;switch(<V1>){ case <R5#R5=R1 + 1;#>: << <V1> + 1; break; case <R6#R6=R1 + 2;#>: <<  <V1> * 2; break; case <R7#R7=R1 + 3;#>: << <V1> - 3; break; case <R8#R8=R1 + 4;#>: << <V1> - 2; break; case <R9#R9=R1 + 5;#>: << <V1> * <V1>; break; default: << <V1> * 2 + 5; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 202 switch(<V1>),   Cases increase  5 * <R1> + 5 to 5 * <R1> + 25,   A case matches,   Cases assign int <V2>,  output after switch 
# 202 
Switch.Condition.Switch condition is not an integer expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=5 * R1 + 5 * R2;#>,<R4#float;R4=R3 * 1.0;#>]{<T0><F0>(){<T1#float#><V1>=<R4>;<T2#integer#><V2>=<R5#20<=R5<30;#>;switch(<V1>){ case <R6#R6= 5 * R1 + 5;#>: <V2> = <R7#80<=R7<90;#>; break; case <R8#R8= 5 * R1 + 10;#>: <V2> = <R9#70<=R9<80;#>; break; case <R10#R10= 5 * R1 + 15;#>: <V2> = <R11#60<=R11<70;#>; break; case <R12#R12= 5 * R1 + 20;#>: <V2> = <R13#50<=R13<60;#>; break; case <R14#R14= 5 * R1 + 25;#>: <V2> = <R15#40<=R15<50;#>; break; default: <V2> = <R16#30<=R16<40;#>; break; }<< <V2>;}} 
> 
Type: debug_output 
Hardness: 20 

// 205 switch(<V1> + <R4>)    Cases increase <R1> + 1 to <R1> + 5,    A case matches,      Cases output random constants 
# 205 
Switch.Condition.Switch condition is not an integer expression
> 
[<R1#1<=R1<=9;#>,<R2#float;R2=R1 * 1.0;#>,<R3#1<=R3<=5;#>]{<T0><F0>(){<T1#float#><V1>=<R2>;switch(<V1> + <R3>){ case <R4#R4=R1 + 1;#>: << <R5#50<=R5<60;#>; break; case <R6#R6=R1 + 2;#>: << <R7#40<=R7<50;#>; break; case <R8#R8=R1 + 3;#>:<< <R9#60<=R9<70;#>; break; case <R10#R10=R1 + 4;#>: << <R11#30<=R11<40;#>; break; case <R12#R12=R1 + 5;#>: << <R13#70<=R13<80;#>; break; default: << <R14#20<=R14<30;#>; break;}}} 
> 
Type: debug_output 
Hardness: 30 

// 206 switch(<V1> * <R2>),  Cases increasing int, A case matches, Cases output expressions of <V1> 
# 206 
Switch.Condition.Switch condition is not an integer expression
> 
// {<T0><F0>(){<T1#float#><V1>=<R1#float;1<=R1<5;#>;switch(<V1> * <R2#1<=R2<5;#>){ case <R3#0<=R3<5;#>: << 2 * <V1>; break; case <R4#5<=R4<10;#>: << <V1> + 5; break; case <R5#10<=R5<15;#>: << <V1> - 3; break; case <R6#15<=R6<20;#>: << <V1> - 6; break; case <R7#20<=R7<25;#>: << 2 * <V1> + 1; break; default: << 1 + <V1>; break; }}} 
[<R1#1<=R1<9;#>]{<T0><F0>(){<T1#float#><V1>=<R1>;switch(<V1> * <R2#1<=R2<5;#>){ case <R1>: << 2 * <V1>; break; case <R3#R3 = R1 * 2;#>: << <V1> + 5; break; case <R4#R4 = R1 * 3;#>: << <V1> - 3; break; case <R5#R5 = R1 * 4;#>: << <V1> - 6; break; case <R6#R6 = R1 * 5;#>: << 2 * <V1> + 1; break; default: << 1 + <V1>; break; }}} 
> 
Type: debug_output 
Hardness: 30 

// 207 switch(10 * <V1>), Increase cases by 10,   A case matches,   Cases assign int <V2>,  output after switch 
# 207 
Switch.Condition.Switch condition is not an integer expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#float;R3= R1 + R2;#>]{<T0><F0>(){<T1#float#><V1>=<R3>;<T2#integer#><V2>=<R4#1<=R4<10;#>;switch(<V1> * 10){ case <R5#R5=R1 * 10 + 10;#>: <V2> = <R6#60<=R6<70;#>; break; case <R7#R7=R1 * 10 + 20;#>: <V2> = <R8#30<=R8<40;#>; break; case <R9#R9=R1 * 10 + 30;#>: <V2> = <R10#50<=R10<60;#>; break; case <R11#R11=R1 * 10 + 40;#>: <V2> = <R12#40<=R12<50;#>; break; case <R13#R13=R1 * 10 + 50;#>: <V2> = <R14#70<=R14<80;#>; break; default: <V2> = <R15#20<=R15<30;#>; break; } << <V2>;}} 
> 
Type: debug_output 
Hardness: 30 

// 210  switch(<V1>)   Cases decrease <R1> + 50 to <R1> + 10,    Random case matches,      Action - Cases output random constants 
# 210 
Switch.Condition.Switch condition is not an integer expression
> 
[<R1#1<=R1<=9;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + 10 * R2;#>,<R4#float;R4=R3 * 1.0;#>]{<T0><F0>(){<T1#float#><V1>=<R4>;switch(<V1>){ case <R5#R5=R1 + 50;#>: << <R6#20<=R6<30;#>; break; case <R7#R7=R1 + 40;#>: << <R8#30<=R8<40;#>; break; case <R9#R9=R1 + 30;#>: << <R10#40<=R10<50;#>; break; case <R11#R11=R1 + 20;#>: << <R12#50<=R12<60;#>; break; case <R13#R13=R1 + 10;#>: << <R14#60<=R14<70;#>; break; default: << <R15#70<=R15<80;#>; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 211 switch(<V1>),  Cases decrease <R1> + 5 to <R1> + 1,  Random case matches,   Cases output expressions of <V1> 
# 211 
Switch.Condition.Switch condition is not an integer expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + R2;#>,<R4#float;R4=R3 * 1.0;#>]{<T0><F0>(){<T1#float#><V1>=<R4>;switch(<V1>){ case <R5#R5=R1 + 5;#>: << 9 - <V1>; break; case <R6#R6=R1 + 4;#>: <<  2 * <V1> ; break; case <R7#R7=R1 + 3;#>: << <V1> + 1; break; case <R8#R8=R1 + 2;#>: << <V1> - 2; break; case <R9#R9=R1 + 1;#>: << <V1> * 3; break; default: << <V1> + 4; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 212  switch(<V1>),   Cases decrease  5 * <R1> + 25 to 5 * <R1> + 5,   A case matches,   Cases assign int <V2>,  output after switch 
# 212 
Switch.Condition.Switch condition is not an integer expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=5 * R1 + 5 * R2;#>,<R4#float;R4=R3 * 1.0;#>]{<T0><F0>(){<T1#float#><V1>=<R4>;<T2#integer#><V2>=<R5#20<=R5<30;#>;switch(<V1>){ case <R6#R6= 5 * R1 + 25;#>: <V2> = <R7#80<=R7<90;#>; break; case <R8#R8= 5 * R1 + 20;#>: <V2> = <R9#70<=R9<80;#>; break; case <R10#R10= 5 * R1 + 15;#>: <V2> = <R11#60<=R11<70;#>; break; case <R12#R12= 5 * R1 + 10;#>: <V2> = <R13#50<=R13<60;#>; break; case <R14#R14= 5 * R1 + 5;#>: <V2> = <R15#40<=R15<50;#>; break; default: <V2> = <R16#30<=R16<40;#>; break; }<< <V2>;}} 
> 
Type: debug_output 
Hardness: 20 

// 215  switch (<R4> + <V1>)    Cases increase <R1> + 1 to <R1> + 5,    A case matches,      Cases output random constants 
# 215 
Switch.Condition.Switch condition is not an integer expression
> 
[<R1#1<=R1<=4;#>,<R2#float;R2=R1 * 1.0;#>,<R3#1<=R3<=5;#>]{<T0><F0>(){<T1#float#><V1>=<R2>;switch(<R3> + <V1>){ case <R4#R4=R1 + 5;#>: << <R5#50<=R5<60;#>; break; case <R6#R6=R1 + 4;#>: << <R7#40<=R7<50;#>; break; case <R8#R8=R1 + 3;#>:<< <R9#60<=R9<70;#>; break; case <R10#R10=R1 + 2;#>: << <R11#30<=R11<40;#>; break; case <R12#R12=R1 + 1;#>: << <R13#70<=R13<80;#>; break; default: << <R14#20<=R14<30;#>; break;}}} 
> 
Type: debug_output 
Hardness: 30 

//216 switch(<V1> - <R2>)  Cases decreasing random int, Matches Default, Cases output expressions of <V1> 
# 216 
Switch.Condition.Switch condition is not an integer expression
> 
// {<T0><F0>(){<T1#float#><V1>=<R1#float;5<=R1<9;#>;switch(<V1> - <R2#1<=R2<5;#>){ case <R3#20<=R3<25;#>: << <V1> * 3; break; case <R4#15<=R4<20;#>: << <V1> + 4; break; case <R5#10<=R5<15;#>: << <V1> - 3; break; case <R6#15<=R6<20;#>: << 6 - <V1>; break; case <R7#20<=R7<25;#>: << 2 + <V1>; break; default: << 1 + <V1> * 2; break; }}} 
[<R1#5<=R1<9;#>]{<T0><F0>(){<T1#float#><V1>=<R1>;switch(<V1> - <R2#1<=R2<5;#>){ case <R3#R3 = R1 - 1;#>: << <V1> * 3; break; case <R4#R4 = R1 - 2;#>: << <V1> + 4; break; case <R5#R5 = R1 - 3;#>: << <V1> - 3; break; case <R6#R6 = R1 - 4;#>: << 6 - <V1>; break; case <R7#R7 = R1 - 5;#>: << 2 + <V1>; break; default: << <V1> * 2 + 1; break; }}} 
> 
Type: debug_output 
Hardness: 30 

// 217 switch(5 * <V1>), Cases decreasing by 5,   A case matches,   Cases assign int <V2> a <V2> expression,  output after switch 
# 217 
Switch.Condition.Switch condition is not an integer expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#float;R3= R1 + R2;#>]{<T0><F0>(){<T1#float#><V1>=<R3>;<T2#integer#><V2>=<R4#1<=R4<10;#>;switch(<V1> * 5){ case <R5#R5=R1 * 5 + 25;#>: <V2> = <V2> + <R6#60<=R6<70;#>; break; case <R7#R7=R1 * 5 + 20;#>: <V2> = <V2> + <R8#30<=R8<40;#>; break; case <R9#R9=R1 * 5 + 15;#>: <V2> = <V2> + <R10#50<=R10<60;#>; break; case <R11#R11=R1 * 5 + 10;#>: <V2> = <V2> + <R12#40<=R12<50;#>; break; case <R13#R13=R1 * 5 + 5;#>: <V2> = <V2> + <R14#70<=R14<80;#>; break; default: <V2> = <V2> + <R15#20<=R15<30;#>; break; } << <V2>;}} 
> 
Type: debug_output 
Hardness: 30 


// --------------------------------------------------------------------------- 
// 225 - 249   Switch.Case.Case value is not an integer expression
// Added by Ralph Walde  1/22/2010 

// 225-227 Case real literal, Condition is int variable,  Cases increasing, three kinds of action 
// 230-232 Case real literal or expression, Condition is int variable expression, Cases increasing,  3 kinds of action 
// 235-237 Case real literal or expression, Condition is int variable,  Cases decreasing, 3 kinds of action 
// 240-242 Case real literal or expression, Condition is int variable expression, Cases decreasing, 3 kinds of action 

// 225  One case a literal real, switch(<V1>)   Cases increase <R1> + 10 to <R1> + 50,    Random case matches,   Cases output random constants 
# 225 
Switch.Case.Case value is not an integer expression
> 
// [<R1#1<=R1<=9;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + 10 * R2;#>,<R4#R4=R1 + 10;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;switch(<V1>){ case <R5#double;R5=R4 * 1.0;#>: << <R6#20<=R6<30;#>; break; case <R7#R7=R1 + 20;#>: << <R8#30<=R8<40;#>; break; case <R9#R9=R1 + 30;#>: << <R10#40<=R10<50;#>; break; case <R11#R11=R1 + 40;#>: << <R12#50<=R12<60;#>; break; case <R13#R13=R1 + 50;#>: << <R14#60<=R14<70;#>; break; default: << <R15#70<=R15<80;#>; break;}}} 
[<R1#1<=R1<=9;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 * 10 + R2;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;switch(<V1>){ case <R4#R4 = R1 * 10 + 1;#>: << <R5#20<=R5<30;#>; break; case <R6#double;R6 = R1 * 10 + 2;#>: << <R7#30<=R7<40;#>; break; case <R8#R8 = R1 * 10 + 3;#>: << <R9#40<=R9<50;#>; break; case <R10#R10 = R1 * 10 + 4;#>: << <R11#50<=R11<60;#>; break; case <R12#R12 = R1 * 10 + 5;#>: << <R13#60<=R13<70;#>; break; default: << <R14#70<=R14<80;#>; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 226 One case a literal real, switch(<V1>),  Cases increase <R1> + 1 to <R1> + 5,  Random case matches,   Cases output expressions of <V1> 
# 226 
Switch.Case.Case value is not an integer expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + R2;#>,<R4#R4=R1 + 3;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;switch(<V1>){ case <R5#R5=R1 + 1;#>: << <V1> * 3; break; case <R6#R6=R1 + 2;#>: << <V1> * 2; break; case <R7#double;R7=R4 * 1.0;#>: << 9 - <V1>; break; case <R8#R8=R1 + 4;#>: << <V1> - 2; break; case <R9#R9=R1 + 5;#>: << <V1> * <V1>; break; default: << 2 * <V1> - 6; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 227  One case a literal real, switch(<V1>),   Cases increase  10 * <R1> + 10 to 10 * <R1> + 50,   A case matches,   Cases assign int <V2>,  output after switch 
# 227 
Switch.Case.Case value is not an integer expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=10 * R1 + 10 * R2;#>,<R4#R4=10 * R1 + 40;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T2#integer#><V2>=<R5#1<=R5<10;#>;switch(<V1>){ case <R6#R6= 10 * R1 + 10;#>: <V2> = <R7#80<=R7<90;#>; break; case <R8#R8= 10 * R1 + 20;#>: <V2> = <R9#70<=R9<80;#>; break; case <R10#R10= 10 * R1 + 30;#>: <V2> = <R11#60<=R11<70;#>; break; case <R12#double;R12= R4 * 1.0;#>: <V2> = <R13#50<=R13<60;#>; break; case <R14#R14= 10 * R1 + 50;#>: <V2> = <R15#40<=R15<50;#>; break; default: <V2> = <R16#30<=R16<40;#>; break; }<< <V2>;}} 
> 
Type: debug_output 
Hardness: 20 


// 230 One case literal real,  Switch(<V1> + <R4>),    Cases increase <R1> + 1 to <R1> + 5,    A case matches,      Cases output random constants 
# 230 
Switch.Case.Case value is not an integer expression
> 
[<R1#1<=R1<=4;#>,<R2#R2=R1 + 2;#>,<R3#1<=R3<=5;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;switch(<V1> + <R3>){ case <R4#R4=R1 + 1;#>: << <R5#50<=R5<60;#>; break; case <R6#double;R6=R2 * 1.0;#>: << <R7#40<=R7<50;#>; break; case <R8#R8=R1 + 3;#>:<< <R9#60<=R9<70;#>; break; case <R10#R10=R1 + 4;#>: << <R11#30<=R11<40;#>; break; case <R12#R12=R1 + 5;#>: << <R13#70<=R13<80;#>; break; default: << <R14#20<=R14<30;#>; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 231 One case real constant expression, switch(<V1> + <R2>),   Cases increasing random int,  A case matches,  Cases output expressions of <V1> 
# 231 
Switch.Case.Case value is not an integer expression
> 
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<5;#>;switch(<V1> + <R2#30<=R2<35;#>){ case <R3#0<=R3<5;#>: << 5 + <V1>; break; case <R4#5<=R4<10;#>: << <V1> - 6; break; case <R5#10<=R5<15;#>: << 3 * <V1>; break; case <R6#15<=R6<20;#>: << <V1> + 9; break; case <R7#1<=R7<5;#> + <R8#double;20<=R8<25;#>: << 2 * <V1> - 3; break; default: << 1 + <V1>; break; }}} 
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<5;#>;switch(<V1> + <R2#39<=R2<44;#>){ case <R3#0<=R3<10;#>: << 5 + <V1>; break; case <R4#10<=R4<20;#>: << <V1> - 6; break; case <R5#20<=R5<30;#>: << 3 * <V1>; break; case <R6#30<=R6<40;#>: << <V1> + 9; break; case <R7#double;R7 = R1 + R2;#>: << 2 * <V1> - 3; break; default: << 1 + <V1>; break; }}} 
> 
Type: debug_output 
Hardness: 20 

// 232 One case literal real, switch(10 * <V1>), Cases by 10,   A case matches,   Cases assign int <V2>,  output after switch 
# 232 
Switch.Case.Case value is not an integer expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + R2;#>,<R4#R4=R1 * 10 + 10;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T2#integer#><V2>=<R5#1<=R5<10;#>;switch(<V1> * 10){ case <R6#double;R6=R4 * 1.0;#>: <V2> = <R7#60<=R7<70;#>; break; case <R8#R8=R1 * 10 + 20;#>: <V2> = <R9#30<=R9<40;#>; break; case <R10#R10=R1 * 10 + 30;#>: <V2> = <R11#50<=R11<60;#>; break; case <R12#R12=R1 * 10 + 40;#>: <V2> = <R13#40<=R13<50;#>; break; case <R14#R14=R1 * 10 + 50;#>: <V2> = <R15#70<=R15<80;#>; break; default: <V2> = <R16#20<=R16<30;#>; break; } << <V2>;}} 
> 
Type: debug_output 
Hardness: 20 

//235  One case a literal real, switch(<V1>)   Cases decrease <R1> + 25 to <R1> + 5,    Random case matches,   Cases output random constants 
# 235 
Switch.Case.Case value is not an integer expression
> 
// [<R1#1<=R1<=9;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + 5 * R2;#>,<R4#R4=R1 + 20;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;switch(<V1>){ case <R5#float;R5=R1 + 25;#>: << <R6#20<=R6<30;#>; break; case <R7#R7=float;R7=R4 * 1.0;#>: << <R8#30<=R8<40;#>; break; case <R9#R9=R1 + 15;#>: << <R10#40<=R10<50;#>; break; case <R11#R11=R1 + 10;#>: << <R12#50<=R12<60;#>; break; case <R13#R13=R1 + 5;#>: << <R14#60<=R14<70;#>; break; default: << <R15#70<=R15<80;#>; break;}}} 
[<R1#1<=R1<=9;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + 5 * R2;#>,<R4#R4=R1 + 20;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;switch(<V1>){ case <R5#R5 = R1 + 25;#>: << <R6#20<=R6<30;#>; break; case <R7#double;R7=R4 * 1.0;#>: << <R8#30<=R8<40;#>; break; case <R9#R9=R1 + 15;#>: << <R10#40<=R10<50;#>; break; case <R11#R11=R1 + 10;#>: << <R12#50<=R12<60;#>; break; case <R13#R13 = R1 + 5;#>: << <R14#60<=R14<70;#>; break; default: << <R15#70<=R15<80;#>; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 236 One case a literal real, switch(<V1>),  Cases decrease <R1> + 5 to <R1> + 1,  Random case matches,   Cases output expressions of <V1> 
# 236 
Switch.Case.Case value is not an integer expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + R2;#>,<R4#R4=R1 + 3;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;switch(<V1>){ case <R5#R5=R1 + 5;#>: << <V1> * 3; break; case <R6#R6=R1 + 4;#>: << <V1> * 2; break; case <R7#double;R7=R4 * 1.0;#>: << 9 - <V1>; break; case <R8#R8=R1 + 2;#>: << <V1> - 2; break; case <R9#R9=R1 + 1;#>: << <V1> * <V1>; break; default: << 2 * <V1> - 6; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 237  One case a real constant expression, switch(<V1>),   Cases decrease  10 * <R1> + 50 to 10 * <R1> + 10,   A case matches,   Cases assign int <V2>,  output after switch 
# 237 
Switch.Case.Case value is not an integer expression
> 
// [<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=10 * R1 + 10 * R2;#>,<R4#R4=10 * R1;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T2#integer#><V2>=<R5#1<=R5<10;#>;switch(<V1>){ case <R6#R6= 10 * R1 + 50;#>: <V2> = <R7#80<=R7<90;#>; break; case <R8#R8= 10 * R1 + 40;#>: <V2> = <R9#70<=R9<80;#>; break; case <R10#R10= 10 * R1 + 30;#>: <V2> = <R11#60<=R11<70;#>; break; case 20 + <R12#R12=R4 * 1.0;#>: <V2> = <R13#50<=R13<60;#>; break; case <R14#R14= 10 * R1 + 10;#>: <V2> = <R15#40<=R15<50;#>; break; default: <V2> = <R16#30<=R16<40;#>; break; }<< <V2>;}} 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=10 * R1 + 10 * R2;#>,<R4#R4=10 * R1 + 20;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T2#integer#><V2>=<R5#1<=R5<10;#>;switch(<V1>){ case <R6#R6= 10 * R1 + 50;#>: <V2> = <R7#80<=R7<90;#>; break; case <R8#R8= 10 * R1 + 40;#>: <V2> = <R9#70<=R9<80;#>; break; case <R10#R10= 10 * R1 + 30;#>: <V2> = <R11#60<=R11<70;#>; break; case <R12#double;R12=R4 * 1.0;#>: <V2> = <R13#50<=R13<60;#>; break; case <R14#R14= 10 * R1 + 10;#>: <V2> = <R15#40<=R15<50;#>; break; default: <V2> = <R16#30<=R16<40;#>; break; }<< <V2>;}} 
> 
Type: debug_output 
Hardness: 20 


// 240 One case literal real,  Switch(<V1> + <R1>),    Cases decrease <R1> + 5 to <R1> + 1,    A case matches,      Cases output random constants 
# 240 
Switch.Case.Case value is not an integer expression
> 
// [<R1#1<=R1<=4;#>,<R2#R2=R1 + 4;#>,<R3#1<=R3<=5;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;switch(<V1> + <R1>){ case <R4#R4=R1 + 5;#>: << <R5#50<=R5<60;#>; break; case <R6#double;R6=R2 * 1.0;#>: << <R7#40<=R7<50;#>; break; case <R8#R8=R1 + 3;#>:<< <R9#60<=R9<70;#>; break; case <R10#R10=R1 + 2;#>: << <R11#30<=R11<40;#>; break; case <R12#R12=R1 + 5;#>: << <R13#70<=R13<80;#>; break; default: << <R14#20<=R14<30;#>; break;}}} 
[<R1#1<=R1<=4;#>,<R2#R2=R1 + 4;#>,<R3#1<=R3<=5;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;switch(<V1> + <R1>){ case <R4#R4=R1 + 5;#>: << <R5#50<=R5<60;#>; break; case <R6#double;R6=R2 * 1.0;#>: << <R7#40<=R7<50;#>; break; case <R8#R8=R1 + 3;#>:<< <R9#60<=R9<70;#>; break; case <R10#R10=R1 + 2;#>: << <R11#30<=R11<40;#>; break; case <R12#R12=R1 + 1;#>: << <R13#70<=R13<80;#>; break; default: << <R14#20<=R14<30;#>; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 241 One case literal, switch(<V1> + <R2>),   Cases decreasing random int,  A case matches,  Cases output expressions of <V1> 
# 241 
Switch.Case.Case value is not an integer expression
> 
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<5;#>;switch(<V1> + <R2#30<=R2<35;#>){ case <R3#20<=R3<25;#>: << <R4#5<=R4<10;#> - <V1>; break; case <R5#15<=R5<20;#>: << <R6#1<=R6<5;#> + <V1>; break; case <R7#10<=R7<15;#>: << <V1> * 2; break; case <R8#5<=R8<10;#>: << <V1> + <R9#1<=R9<5;#>; break; case <R10#float;0<=R10<5;#>: << 2 * <V1> - <R11#0<=R11<5;#>; break; default: << <R12#0<=R12<5;#> + <V1>; break; }}} 
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<5;#>;switch(<V1> + <R2#9<=R2<15;#>){ case <R3#90<=R3<100;#>: << <R4#5<=R4<10;#> - <V1>; break; case <R5#70<=R5<80;#>: << <R6#1<=R6<=5;#> + <V1>; break; case <R7#50<=R7<60;#>: << <V1> * 2; break; case <R8#30<=R8<40;#>: << <V1> + <R9#1<=R9<5;#>; break; case <R10#double;R10 = R1 + R2;#>: << 2 * <V1> - <R11#1<=R11<=5;#>; break; default: << <R12#1<=R12<=5;#> + <V1>; break; }}} 
> 
Type: debug_output 
Hardness: 20 

// 242 One case literal real, switch(<V1> * 5), Cases decrease by 5,   A case matches,   Cases assign int <V2>,  output after switch 
# 242 
Switch.Case.Case value is not an integer expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + R2;#>,<R4#R4=R1 * 5 + 20;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T2#integer#><V2>=<R5#1<=R5<10;#>;switch(<V1> * 5){ case <R6#R6=R1 * 5 + 25;#>: <V2> = <R7#60<=R7<70;#>; break; case <R8#double;R8=R4 * 1.0;#>: <V2> = <R9#30<=R9<40;#>; break; case <R10#R10=R1 * 5 + 15;#>: <V2> = <R11#50<=R11<60;#>; break; case <R12#R12=R1 * 5 + 10;#>: <V2> = <R13#40<=R13<50;#>; break; case <R14#R14=R1 * 5 + 5;#>: <V2> = <R15#70<=R15<80;#>; break; default: <V2> = <R16#20<=R16<30;#>; break; } << <V2>;}} 
> 
Type: debug_output 
Hardness: 20 


// --------------------------------------------------------------------------- 
// 250 - 274 Switch.Case.Case value is not a constant expression 
// Added by Ralph Walde  1/22/2010 

// 250-252 Case integer variable, Condition is int variable,  Cases increasing, three kinds of action 
// 255-257 Case integer variable or expression, Condition is int variable expression, Cases increasing,  3 kinds of action 
// 260-262 Case integer variable or expression, Condition is int variable,  Cases decreasing, 3 kinds of action 
// 265-267 Case integer variable or expression, Condition is int variable expression, Cases decreasing, 3 kinds of action 

// 250  One case an integer variable, switch(<V1>)   Cases increase <R1> + 10 to <R1> + 50,    Random case matches,   Cases output random constants 
# 250 
Switch.Case.Case value is not a constant expression
> 
[<R1#1<=R1<=9;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + 10 * R2;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T1><V2>=<R4#R4=R1 + 50;#>;switch(<V1>){ case <R5#R5=R1 + 10;#>: << <R6#20<=R6<30;#>; break; case <R7#R7=R1 + 20;#>: << <R8#30<=R8<40;#>; break; case <R9#R9=R1 + 30;#>: << <R10#40<=R10<50;#>; break; case <R11#R11=R1 + 40;#>: << <R12#50<=R12<60;#>; break; case <V2>: << <R13#60<=R13<70;#>; break; default: << <R14#70<=R14<80;#>; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 251 One case an integer variable, switch(<V1>),  Cases increase <R1> + 1 to <R1> + 5,  Random case matches,   Cases output expressions of <V1> 
# 251 
Switch.Case.Case value is not a constant expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + R2;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T1><V2>=<R4#R4=R1 + 3;#>;switch(<V1>){ case <R5#R5=R1 + 1;#>: << <V1> * 2; break; case <R6#R6=R1 + 2;#>: << <V1> + <R7#1<=R7<=5;#>; break; case <V2>: << <R8#10<=R8<=15;#> - <V1>; break; case <R9#R9=R1 + 4;#>: << <V1> + <R10#1<=R10<=5;#>; break; case <R11#R11=R1 + 5;#>: << <V1> * <V1>; break; default: << 2 * <V1> - <R12#1<=R12<=5;#>; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 252 One case an integer variable, switch(<V1>),   Cases increase  10 * <R1> + 10 to 10 * <R1> + 50,   A case matches,   Cases assign int <V2>,  output after switch 
# 252 
Switch.Case.Case value is not a constant expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=10 * R1 + 10 * R2;#>,<R4#R4=10 * R1 + 40;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T1><V2>=<R5#1<=R5<10;#>;<T1><V3>=<R4>;switch(<V1>){ case <R6#R6= 10 * R1 + 10;#>: <V2> = <R7#80<=R7<90;#>; break; case <R8#R8= 10 * R1 + 20;#>: <V2> = <R9#70<=R9<80;#>; break; case <R10#R10= 10 * R1 + 30;#>: <V2> = <R11#60<=R11<70;#>; break; case <V3>: <V2> = <R12#50<=R12<60;#>; break; case <R13#R13= 10 * R1 + 50;#>: <V2> = <R14#40<=R14<50;#>; break; default: <V2> = <R15#30<=R15<40;#>; break; }<< <V2>;}} 
> 
Type: debug_output 
Hardness: 20 

// 255 One case an integer variable,  Switch(<V1> + <R4>),    Cases increase <R1> + 1 to <R1> + 5,    A case matches,      Cases output random constants 
# 255 
Switch.Case.Case value is not a constant expression
> 
[<R1#1<=R1<=4;#>,<R2#R2=R1 + 2;#>,<R3#1<=R3<=5;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>=<R2>;switch(<V1> + <R3>){ case <R4#R4=R1 + 1;#>: << <R5#50<=R5<60;#>; break; case <V2>: << <R6#40<=R6<50;#>; break; case <R7#R7=R1 + 3;#>:<< <R8#60<=R8<70;#>; break; case <R9#R9=R1 + 4;#>: << <R10#30<=R10<40;#>; break; case <R11#R11=R1 + 5;#>: << <R12#70<=R12<80;#>; break; default: << <R13#20<=R13<30;#>; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 256 One case an integer variable, switch(<V1> + <R2>),   Cases increasing random int,  A case matches,  Cases output expressions of <V1> 
# 256 
Switch.Case.Case value is not a constant expression
> 
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<5;#>;<T1><V2>=<R2#5<=R2<10;#>;switch(<V1> + <R3#30<=R3<35;#>){ case <R4#0<=R4<5;#>: << <V1> + <R5#0<=R5<5;#>; break; case <R6#5<=R6<10;#>: << <R7#5<=R7<10;#> - <V1>; break; case <V2>: << 2 * <V1>; break; case <R8#15<=R8<20;#>: << <R9#0<=R9<5;#> + <V1>; break; case <R10#20<=R10<25;#>: << 2 * <V1> + <R11#0<=R11<5;#>; break; default: << <R12#0<=R12<5;#> + <V1>; break; }}} 
[<R1#19<=R1<24;#>]{<T0><F0>(){<T1#integer#><V1>=<R2#1<=R2<5;#>;<T1><V2>=<R3#R3 = R1 + R2;#>;switch(<V1> + <R1>){ case <R4#0<=R4<10;#>: << <V1> + <R5#1<=R5<=5;#>; break; case <R6#10<=R6<20;#>: << <R7#5<=R7<10;#> - <V1>; break; case <V2>: << 2 * <V1>; break; case <R8#30<=R8<40;#>: << <R9#1<=R9<=5;#> + <V1>; break; case <R10#40<=R10<50;#>: << 2 * <V1> + <R11#1<=R11<=5;#>; break; default: << <R12#1<=R12<=5;#> + <V1>; break; }}} 
> 
Type: debug_output 
Hardness: 20 

// One case an integer variable expression, switch(10 * <V1>), Cases increases by 10,   A case matches,   Cases assign int <V2>,  output after switch 
# 257 
Switch.Case.Case value is not a constant expression
> 
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<6;#>;<T1><V2>=<R2#1<=R2<10;#>;<T1><V3>=20;switch(10 * <V1>){ case 10: <V2> = <R3#10<=R3<20;#>; break; case 20: <V2> = <V2> + <R4#1<=R4<10;#>; break; case 30: <V2> = <V2> * 4; break; case 40: <V2> = 5 * <V2> + <R5#20<=R5<30;#>; break; case 3 * <V3> - 10: <V2> = 3 * <V2> + 2; break; default: <V2> = <R7#20<=R7<30;#> + <V2>; break; }<< <V2>;}} 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + R2;#>,<R4#R4=R1 * 10 + 20;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T1><V2>=<R5#1<=R5<10;#>;<T1><V3>=<R4>;switch(<V1> * 10){ case <R6#R6=R1 * 10 + 10;#>: <V2> = <R7#60<=R7<70;#>; break; case <V3>: <V2> = <R8#30<=R8<40;#>; break; case <R9#R9=R1 * 10 + 30;#>: <V2> = <R10#50<=R10<60;#>; break; case <R11#R11=R1 * 10 + 40;#>: <V2> = <R12#40<=R12<50;#>; break; case <R13#R13=R1 * 10 + 50;#>: <V2> = <R14#70<=R14<80;#>; break; default: <V2> = <R15#20<=R15<30;#>; break; } << <V2>;}} 
> 
Type: debug_output 
Hardness: 20 

//260  One case an integer variable, switch(<V1>)   Cases decrease <R1> + 25 to <R1> + 5,    Random case matches,   Cases output random constants 
# 260 
Switch.Case.Case value is not a constant expression
> 
[<R1#1<=R1<=9;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + 5 * R2;#>,<R4#R4=R1 + 20;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T1><V2>=<R4>;switch(<V1>){ case <R5#R5=R1 + 25;#>: << <R6#20<=R6<30;#>; break; case <V2>: << <R7#30<=R7<40;#>; break; case <R8#R8=R1 + 15;#>: << <R9#40<=R9<50;#>; break; case <R10#R10=R1 + 10;#>: << <R11#50<=R11<60;#>; break; case <R12#R12=R1 + 5;#>: << <R13#60<=R13<70;#>; break; default: << <R14#70<=R14<80;#>; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 261 One case an integer variable, switch(<V1>),  Cases decrease <R1> + 5 to <R1> + 1,  Random case matches,   Cases output expressions of <V1> 
# 261 
Switch.Case.Case value is not a constant expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + R2;#>,<R4#R4=R1 + 3;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T1><V2>=<R4>;switch(<V1>){ case <R5#R5=R1 + 5;#>: << <V1> * 3; break; case <R6#R6=R1 + 4;#>: << <V1> * 2; break; case <V2>: << <R7#1<=R7<=4;#> + <V1>; break; case <R8#R8=R1 + 2;#>: << <V1> - <R9#1<=R9<=4;#>; break; case <R10#R10=R1 + 1;#>: << <V1> * <V1>; break; default: << 2 * <V1> - <R11#1<=R11<=4;#>; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 262  One case an integer variable expression, switch(<V1>),   Cases decrease  10 * <R1> + 50 to 10 * <R1> + 10,   A case matches,   Cases assign int <V2>,  output after switch 
# 262 
Switch.Case.Case value is not a constant expression
> 
// [<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=10 * R1 + 10 * R2;#>,<R4#R4=10 * R1;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T1><V2>=<R5#1<=R5<10;#>;<T1><V3>=<R4>;switch(<V1>){ case <R6#R6= 10 * R1 + 50;#>: <V2> = <R7#80<=R7<90;#>; break; case <R8#R8= 10 * R1 + 40;#>: <V2> = <R9#70<=R9<80;#>; break; case <R10#R10= 10 * R1 + 30;#>: <V2> = <R11#60<=R11<70;#>; break; case <R12#R12=10 * R1 + 20;#>: <V2> = <R13#50<=R13<60;#>; break; case <V3> + 10: <V2> = <R14#40<=R14<50;#>; break; default: <V2> = <R15#30<=R15<40;#>; break; }<< <V2>;}} 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=10 * R1 + 10 * R2;#>,<R4#R4 = 10 * R1 + 10;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T1><V2>=<R5#1<=R5<10;#>;<T1><V3>=<R4>;switch(<V1>){ case <R6#R6= 10 * R1 + 50;#>: <V2> = <R7#80<=R7<90;#>; break; case <R8#R8= 10 * R1 + 40;#>: <V2> = <R9#70<=R9<80;#>; break; case <R10#R10= 10 * R1 + 30;#>: <V2> = <R11#60<=R11<70;#>; break; case <R12#R12=10 * R1 + 20;#>: <V2> = <R13#50<=R13<60;#>; break; case <V3>: <V2> = <R14#40<=R14<50;#>; break; default: <V2> = <R15#30<=R15<40;#>; break; }<< <V2>;}} 
> 
Type: debug_output 
Hardness: 20 

// 265 One case an integer variable,  Switch(<V1> + <R1>),    Cases decrease <R1> + 5 to <R1> + 1,    A case matches,      Cases output random constants 
# 265 
Switch.Case.Case value is not a constant expression
> 
// [<R1#1<=R1<=4;#>,<R2#R2=R1 + 4;#>,<R3#1<=R3<=5;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T1><V2>=<R2>;switch(<V1> + <R1>){ case <R4#R4=R1 + 5;#>: << <R5#50<=R5<60;#>; break; case <V2>: << <R6#40<=R6<50;#>; break; case <R7#R7=R1 + 3;#>:<< <R8#60<=R8<70;#>; break; case <R9#R9=R1 + 2;#>: << <R10#30<=R10<40;#>; break; case <R11#R11=R1 + 5;#>: << <R12#70<=R12<80;#>; break; default: << <R13#20<=R13<30;#>; break;}}} 
[<R1#1<=R1<=4;#>,<R2#R2=R1 + 4;#>,<R3#1<=R3<=5;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>=<R2>;switch(<V1> + <R3>){ case <R4#R4=R1 + 5;#>: << <R5#50<=R5<60;#>; break; case <V2>: << <R6#40<=R6<50;#>; break; case <R7#R7=R1 + 3;#>:<< <R8#60<=R8<70;#>; break; case <R9#R9=R1 + 2;#>: << <R10#30<=R10<40;#>; break; case <R11#R11=R1 + 1;#>: << <R12#70<=R12<80;#>; break; default: << <R13#20<=R13<30;#>; break;}}} 
> 
Type: debug_output 
Hardness: 20 

// 266 One case an integer variable expression, switch(<V1> + <R3>),   Cases decreasing random int,  A case matches,  Cases output expressions of <V1> 
# 266 
Switch.Case.Case value is not a constant expression
> 
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<5;#>;<T1><V2>=<R2#0<=R2<4;#>;switch(<V1> + <R3#30<=R3<35;#>){ case <R4#20<=R4<25;#>: << <R5#5<=R5<10;#> - <V1>; break; case <R6#15<=R6<20;#>: << <R7#1<=R7<5;#> + <V1>; break; case <R8#10<=R8<15;#>: << <V1> * 2; break; case <R9#5<=R9<10;#>: << <V1> + <R10#1<=R10<5;#>; break; case <V2> + 1: << 2 * <V1> - <R11#0<=R11<5;#>; break; default: << <R12#0<=R12<5;#> + <V1>; break; }}} 
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<5;#>;<T1><V2>=<R2#40<=R2<50;#>;switch(<V1> + <R3#59<=R3<64;#>){ case <R4#80<=R4<90;#>: << <R5#5<=R5<10;#> - <V1>; break; case <R6#70<=R6<80;#>: << <R7#1<=R7<5;#> + <V1>; break; case <R8#R8 = R1 + R3;#>: << <V1> * 2; break; case <R9#50<=R9<60;#>: << <V1> + <R10#1<=R10<5;#>; break; case <V2>: << 2 * <V1> - <R11#1<=R11<=5;#>; break; default: << <R12#1<=R12<=5;#> + <V1>; break; }}} 
> 
Type: debug_output 
Hardness: 20 

// 267 One case an integer variable, switch(<V1> * 5), Cases decrease by 5,   A case matches,   Cases assign int <V2>,  output after switch 
# 267 
Switch.Case.Case value is not a constant expression
> 
[<R1#1<=R1<=4;#>,<R2#1<=R2<=5;#>,<R3#R3=R1 + R2;#>,<R4#R4=R1 * 5 + 20;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T1><V2>=<R5#1<=R5<10;#>;<T1><V3>=<R4>;switch(<V1> * 5){ case <R6#R6=R1 * 5 + 25;#>: <V2> = <R7#60<=R7<70;#>; break; case <V3>: <V2> = <R8#30<=R8<40;#>; break; case <R9#R9=R1 * 5 + 15;#>: <V2> = <R10#50<=R10<60;#>; break; case <R11#R11=R1 * 5 + 10;#>: <V2> = <R12#40<=R12<50;#>; break; case <R13#R13=R1 * 5 + 5;#>: <V2> = <R14#70<=R14<80;#>; break; default: <V2> = <R15#20<=R15<30;#>; break; } << <V2>;}} 
> 
Type: debug_output 
Hardness: 20 


// ---------------------------------------------------------------------------
// 300
// Switch.Body.No statement (has break)

// 3 out of 6 cases with no statement but break - either evenly interspersed or back to back
// Inc versus dec
// print inSitu / update a variable and print at the end 

// Incrementing, inSitu printing, alternate even cases
# 300
Switch.Body.No statement
>
[<R1#1<=R1<=9;#>,<R2#1<=R2<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2*2;#>;switch(<V1>){ case <R4#R4=R1+1;#>: << <V1> - 1; break; case <R5#R5=R1+2;#>: break; case <R6#R6=R1+3;#>: << <V1> + 1; break; case <R7#R7=R1+4;#>: break; case <R8#R8=R1+5;#>: << <V1>; break; case <R9#R9=R1+6;#>: break; default: << <V1> * 2; break; }}}
>
Type: debug_output
Hardness: 30

// Incrementing, @end printing - variable update, back-to-back cases
# 301
Switch.Body.No statement
>
[<R1#1<=R1<=9;#>,<R2#3<=R2<=5;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2;#>;<T1><V2>=<R1>; switch(<V1>){ case <R4#R4=R1+1;#>: <V2> = <V2> + 1; break; case <R5#R5=R1+2;#>: <V2> = <V2> - 1; break; case <R6#R6=R1+3;#>: break; case <R7#R7=R1+4;#>: break; case <R8#R8=R1+5;#>: break; case <R9#R9=R1+6;#>: <V2> = <V2> + 10; break; default: <V2> = <V2> * 10; break; } << <V2>; }}
>
Type: debug_output
Hardness: 35

// Incrementing, @end printing - variable initialization, alternate odd cases
# 302
Switch.Body.No statement
>
[<R1#3<=R1<=9;#>,<R2#0<=R2<=2;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2*2+1;#>;<T1><V2>=0; switch(<V1>){ case <R4#R4=R1+1;#>: break; case <R5#R5=R1+2;#>: <V2> = <R2>; break; case <R6#R6=R1+3;#>: break; case <R7#R7=R1+4;#>: <V2> = <R1>; break; case <R8#R8=R1+5;#>: break; case <R9#R9=R1+6;#>: <V2> = <R10#10<=R10<=15;#>; break; default: <V2> = <R11#16<=R11<=19;#>; break; } << <V2>; }}
>
Type: debug_output
Hardness: 35

// Incrementing, inSitu printing, back-to-back cases
# 303
Switch.Body.No statement
>
[<R1#1<=R1<=9;#>,<R2#1<=R2<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2;#>; switch(<V1>){ case <R4#R4=R1+1;#>: break; case <R5#R5=R1+2;#>: break; case <R6#R6=R1+3;#>: break; case <R7#R7=R1+4;#>: << <V1>; break; case <R8#R8=R1+5;#>: << <V1> + 1; break; case <R9#R9=R1+6;#>: << <V1> - 1; break; default: << <V1> + 10; break; } }}
>
Type: debug_output
Hardness: 30

// Incrementing, @end printing - variable initialization- used to modify condition variable at the end, alternate even cases
# 304
Switch.Body.No statement
>
[<R1#4<=R1<=9;#>,<R2#1<=R2<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2*2;#>;<T1><V2>=0; switch(<V1>){ case <R4#R4=R1+1;#>: <V2> = <R2>; break; case <R5#R5=R1+2;#>: break; case <R6#R6=R1+3;#>: <V2> = <R1>; break; case <R7#R7=R1+4;#>: break; case <R8#R8=R1+5;#>: <V2> = <V1>; break; case <R9#R9=R1+6;#>: break; default: <V2> = <V1> - <R2>; break; } <V1> = <V1> - <V2>; << <V1>; }}
>
Type: debug_output
Hardness: 35

// Incrementing, @end printing - variable initialization- used to modify condition variable at the end, back-to-back
# 305
Switch.Body.No statement
>
[<R1#1<=R1<=9;#>,<R2#2<=R2<=4;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1*10+R2;#>;<T1><V2>=0; switch(<V1>){ case <R4#R4=R1*10+1;#>: <V2> = <R1>; break; case <R5#R5=R1*10+2;#>: break; case <R6#R6=R1*10+3;#>: break; case <R7#R7=R1*10+4;#>: break; case <R8#R8=R1*10+5;#>: <V2> = <R2>; break; case <R9#R9=R1*10+6;#>: <V2> = 10; break; default: <V2> = <R3>; break; } <V1> = <V1> + <V2>; << <V1>; }}
>
Type: debug_output
Hardness: 30



// Decrementing, inSitu printing, alternate even cases
# 310
Switch.Body.No statement
>
[<R1#1<=R1<=9;#>,<R2#1<=R2<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2*2;#>;switch(<V1>){ case <R4#R4=R1+6;#>: break; case <R5#R5=R1+5;#>: << <V1>; break; case <R6#R6=R1+4;#>: break; case <R7#R7=R1+3;#>: << <V1>; break; case <R8#R8=R1+2;#>: break; case <R9#R9=R1+1;#>: << <V1>; break; default: << <V1>; break; }}}
>
Type: debug_output
Hardness: 30

// Decrementing, @end printing - variable update, back-to-back cases
# 311
Switch.Body.No statement
>
[<R1#1<=R1<=9;#>,<R2#3<=R2<=5;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2;#>;<T1><V2>=<R1>; switch(<V1>){ case <R4#R4=R1+6;#>: <V2> = <V2> * 2; break; case <R5#R5=R1+5;#>: break; case <R6#R6=R1+4;#>: break; case <R7#R7=R1+3;#>: break; case <R8#R8=R1+2;#>: <V2> = <V2> / 2; break; case <R9#R9=R1+1;#>: <V2> = <V2> % 2; break; default: <V2> = <V2> + 2; break; } << <V2>; }}
>
Type: debug_output
Hardness: 35

// Decrementing, @end printing - variable initialization, alternate odd cases
# 312
Switch.Body.No statement
>
[<R1#3<=R1<=9;#>,<R2#0<=R2<=2;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2*2+1;#>;<T1><V2>=0; switch(<V1>){ case <R4#R4=R1+6;#>: <V2> = <R2>; break; case <R5#R5=R1+5;#>: break; case <R6#R6=R1+4;#>: <V2> = <R10#10<=R10<=15;#>; break; case <R7#R7=R1+3;#>: break; case <R8#R8=R1+2;#>: <V2> = <R1>; break; case <R9#R9=R1+1;#>: break; default: <V2> = <R11#16<=R11<=19;#>; break; } << <V2>; }}
>
Type: debug_output
Hardness: 35

// Decrementing, inSitu printing, back-to-back cases
# 313
Switch.Body.No statement
>
[<R1#1<=R1<=9;#>,<R2#1<=R2<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2;#>; switch(<V1>){ case <R4#R4=R1+6;#>: << <V1> - 1; break; case <R5#R5=R1+5;#>: << <V1>; break; case <R6#R6=R1+4;#>: << <V1> + 1; break; case <R7#R7=R1+3;#>: break; case <R8#R8=R1+2;#>: break; case <R9#R9=R1+1;#>: break; default: << <V1>; break; } }}
>
Type: debug_output
Hardness: 30

// Decrementing, @end printing - variable initialization- used to modify condition variable at the end, alternate even cases
# 314
Switch.Body.No statement
>
[<R1#4<=R1<=9;#>,<R2#1<=R2<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2*2;#>;<T1><V2>=0; switch(<V1>){ case <R4#R4=R1+6;#>: break; case <R5#R5=R1+5;#>: <V2> = <R1>; break; case <R6#R6=R1+4;#>: break; case <R7#R7=R1+3;#>: <V2> = <V1>; break; case <R8#R8=R1+2;#>: break; case <R9#R9=R1+1;#>: <V2> = <R2>; break; default: <V2> = <V1> - <R2>; break; } <V1> = <V1> - <V2>; << <V1>; }}
>
Type: debug_output
Hardness: 35

// Decrementing, @end printing - variable initialization- used to modify condition variable at the end, back to back
# 315
Switch.Body.No statement
>
[<R1#1<=R1<=9;#>,<R2#2<=R2<=4;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1*10+R2;#>;<T1><V2>=0; switch(<V1>){ case <R4#R4=R1*10+6;#>: <V2> = <R2>; break; case <R5#R5=R1*10+5;#>: <V2> = 10; break; case <R6#R6=R1*10+4;#>: break; case <R7#R7=R1*10+3;#>: break; case <R8#R8=R1*10+2;#>: break; case <R9#R9=R1*10+1;#>: <V2> = <R1>; break; default: <V2> = <R3>; break; } <V1> = <V1> + <V2>; << <V1>; }}
>
Type: debug_output
Hardness: 30


// ---------------------------------------------------------------------------
// DONE
// Since these are errors for C#, problem type is debug_output
// 325
// Switch.Body.No break.Has statements
// Incrementing vs Decrementing
//  Printing Vs Adding to a variable 

// THE FOLLOWING TEMPLATES ARE DESIGNED FOR PRIMARY USE BY C#. THEY HAVE EXACTLY ONE CASE WITH NO BREAK, AND THE CONDITION EVALUATES TO THAT CASE.
// THEREFORE, THE TEMPLATES WILL WORK FOR C++ AND JAVA. BUT, SINCE THEY HAVE ONLY ONE CASE WITH NO BREAK, THEY WILL ALSO WORK FOR C# - REQUIRING
// USER TO IDENTIFY ONLY ONE ERROR INSTEAD OF SAY 5 OR 6 ERRORS CORRESPONDING TO THE 5 OR 6 CASES WITH NO BREAK

// 5 random values for cases
# 325
Switch.Body.No break.Has statements
>
{<T0><F0>(){<T1#integer#><V1>=<R1#30<=R1<40;#>;switch(<V1>){ case <R2#40<=R2<50;#>: << <R1>; break; case <R3#20<=R3<30;#>: << <R2>; break; case <R4#50<=R4<60;#>: << <R3>; break; case <R1>: << <R4>; case <R5#10<=R5<20;#>: << <R6#60<=R6<70;#>; break; default: << <R7#70<=R7<100;#>; break; }}}
>
Type: debug_output
Hardness: 30

# 326
Switch.Body.No break.Has statements
>
{<T0><F0>(){<T1#integer#><V1>=<R1#40<=R1<50;#>;switch(<V1>){ case <R2#20<=R2<30;#>: << <V1> + 10; break; case <R1>: << <V1> + 20; case <R3#10<=R3<20;#>: << <V1> - 10; break; case <R4#50<=R4<60;#>: << 100 - <V1>; break; case <R5#30<=R5<40;#>: << <V1> - 20; break; default: << <V1> + <V1>; break; }}}
>
Type: debug_output
Hardness: 30

# 327
Switch.Body.No break.Has statements
>
{<T0><F0>(){<T1#integer#><V1>=<R1#10<=R1<20;#>;<T1><V2>=<R2#20<=R2<30;#>;switch(<V1>){ case <R3#30<=R3<40;#>: << <V2> / <V1>; break; case <R4#50<=R4<60;#>: << <V2> * <V1>; break; case <R2>: << <V1> * <V1>; break; case <R5#40<=R5<50;#>: << <V2> % <V1>; break; case <R1>: << <V2> - <V1>; default: << <V2> + <V1>; break; }}}
>
Type: debug_output
Hardness: 30

# 328
Switch.Body.No break.Has statements
>
{<T0><F0>(){<T1#integer#><V1>=<R1#60<=R1<70;#>;<T1><V2>=<R2#1<=R2<10;#>;switch(<V1>){ case <R3#20<=R3<30;#>: <V2> = <V1> / <V2>; break; case <R4#50<=R4<60;#>: <V2> = <V2> * <V2>; break; case <R1>: <V2> = <V2> + 10; case <R5#40<=R5<50;#>: <V2> = <V2> * 10; break; case <R6#30<=R6<40;#>: <V2> = <V1> - <V2>; break; default: <V2> = <V1> % <V2>; break; } << <V2>;}}
>
Type: debug_output
Hardness: 30

# 329
Switch.Body.No break.Has statements
>
{<T0><F0>(){<T1#integer#><V1> = 10;switch(<V1>){ case 10: << <V1> / 10; case 8: << <V1> * 10; break; case 6: << <V1> + <V1>; break; case 4: << <V1> % 2; break; case 2: << <V1> * <V1>; break; default: << <V1> % 10; break; }}}
>
Type: debug_output
Hardness: 30

# 330
Switch.Body.No break.Has statements
>
[<R1#6<=R1<=10;#>]{<T0><F0>(){<T1#integer#><V1> = 15;<T1><V2> = <R2#R2 = R1 * 10;#>;switch(<V1>){ case 25: << <V2> / 10; break; case 20: << <V2> - <V1>; break; case 15: << <V1>; case 10: << <V2>; break; case 5: << <V2> + <V1>; break; default: << <V2> * <V1>; break; }}}
>
Type: debug_output
Hardness: 30

# 331
Switch.Body.No break.Has statements
>
[<R1#1<=R1<=5;#>]{<T0><F0>(){<T1#integer#><V1> = <R2#R2 = R1 + 2;#>;<T1><V2> = <R3#R3 = R1 + 4;#>;switch(<V1>){ case <R4#R4 = R1 + 5;#>: << <V2> * 10; break; case <R3>: << <V1> * 10; break; case <R5#R5 = R1 + 3;#>: << <V2>; break; case <R2>: << <V1> * 100; case <R6#R6 = R1 + 1;#>: << <V2> * 100; break; default: << <V1>; break; }}}
>
Type: debug_output
Hardness: 30

# 332
Switch.Body.No break.Has statements
>
{<T0><F0>(){<T1#integer#><V1> = 70;<T1><V2> = 100;switch(<V1>){ case 90: <V2> = <V2> / 10; break; case 80: <V2> = <V1> - 30; break; case 70: <V2> = <V1>; case 60: <V2> = <V2> + 20; break; case 50: <V2> = <V2> * 2; break; default: <V2> = <V2> * 10; break; } << <V2>;}}
>
Type: debug_output
Hardness: 30

# 333
Switch.Body.No break.Has statements
>
[<R1#10<=R1<=15;#>]{<T0><F0>(){<T1#integer#><V1> = <R2#R2 = R1 + 2;#>;<T1><V2> = <R3#R3 = R1 + 4;#>;switch(<V1>){ case <R4#R4 = R1 + 1;#>: << <V1> + 1; break; case <R2>: << <V2> + 1; case <R5#R5 = R1 + 3;#>: << <V1> - 1; break; case <R3>: << <V2> - 1; break; case <R6#R6 = R1 + 5;#>: << <V1>; break; default: << <V2>; break; }}}
>
Type: debug_output
Hardness: 30


// THESE TEMPLATES ARE PREFERABLE FOR C++ AND JAVA. FOR C#, THEY GENERATE MULTIPLE ERRORS

// Incrementing
# 335
Switch.Body.No break.Has statements
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#3<=R1<=5;#>;switch(<V1>){ case 1: << <R2#1<=R2<4;#> * 10; case 2: << <R3#4<=R3<7;#> * 10; case 3: << <R4#7<=R4<10;#> * 10; case 4: << <R5#10<=R5<13;#> * 10; case 5: << <R6#13<=R6<16;#> * 10; default: << <R7#16<=R7<20;#> * 10; }}}
[<R1#1<=R1<=25;#>,<R2#R2=R1+2;#>,<R3#0<=R3<=2;#>]{<T0><F0>(){<T1#integer#><V1>=<R4#R4=R2+R3;#>;switch(<V1>){ case <R1>: << <R5#1<=R5<4;#>; case <R6#R6=R1+1;#>: << <R7#4<=R7<7;#>; case <R2>: << <R8#7<=R8<10;#>; case <R9#R9=R1+3;#>: << <R10#10<=R10<13;#>; case <R11#R11=R1+4;#>5: << <R12#13<=R12<16;#>; default: << <R13#16<=R13<20;#>; }}}
>
Type: debug_output
Hardness: 30

# 336
Switch.Body.No break.Has statements
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#2<=R1<=4;#>;switch(<V1>){ case 1: << <V1>; break; case 2: << <V1>; case 3: << <V1>; case 4: << <V1>; case 5: << <V1>; break; default: << <V1>; break; }}}
[<R1#1<=R1<=25;#>,<R2#1<=R2<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2;#>;switch(<V1>){ case <R1>: << <V1> - 2; break; case <R4#R4=R1+1;#>: << <V1> - 1; case <R5#R5=R1+2;#>: << <V1>; case <R6#R6=R1+3;#>: << <V1> + 1; case <R7#R7=R1+4;#>: << <V1> + 2; break; default: << <V1>; break; }}}
>
Type: debug_output
Hardness: 35

# 337
Switch.Body.No break.Has statements
>
{<T0><F0>(){<T1#integer#><V1>=<R1#3<=R1<=5;#>;<T1><V2>=<R2#6<=R2<=10;#>;switch(<V1>){ case 1: <V2> = <V2> - 1; case 2: <V2> = <V2> - 1; case 3: <V2> = <V2> - 1; case 4: <V2> = <V2> - 1; case 5: <V2> = <V2> - 1; default: <V2> = <V2> - 1; } << <V2>; }}
>
Type: debug_output
Hardness: 30

# 338
Switch.Body.No break.Has statements
>
{<T0><F0>(){<T1#integer#><V1>=<R1#2<=R1<=4;#>;<T1><V2>=<R2#1<=R2<=5;#>;switch(<V1>){ case 1: <V2> = <V2> + 1; break; case 2: <V2> = <V2> + 1; case 3: <V2> = <V2> + 1; case 4: <V2> = <V2> + 1; case 5: <V2> = <V2> + 1; break; default: <V2> = <V2> + 1; break; } << <V2>;}}
>
Type: debug_output
Hardness: 35

# 339
Switch.Body.No break.Has statements
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#2<=R1<=4;#> * 10;<T1><V2>=1;switch(<V1>){ case 10: <V2> = <V2> * 2; case 20: <V2> = <V2> * 2; case 30: <V2> = <V2> * 2; case 40: <V2> = <V2> * 2; case 50: <V2> = <V2> * 2; default: << <V2>; } << <V2>; }}
[<R1#2<=R1<=4;#>]{<T0><F0>(){<T1#integer#><V1>=<R2#R2=R1*10;#>;<T1><V2>=1;switch(<V1>){ case 10: <V2> = <V2> * 2; case 20: <V2> = <V2> * 2; case 30: <V2> = <V2> * 2; case 40: <V2> = <V2> * 2; case 50: <V2> = <V2> * 2; default: << <V2>;  } << <V2>; }}
>
Type: debug_output
Hardness: 35

# 340
Switch.Body.No break.Has statements
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#2<=R1<=4;#> * 10;<T1><V2>=0;switch(<V1>){ case 10: <V2> = <V2> + 10; break; case 20: <V2> = <V2> + 10; case 30: <V2> = <V2> + 10; case 40: <V2> = <V2> + 10; case 50: <V2> = <V2> + 10; break; default: << <V2>; break; } << <V2>;}}
[<R1#2<=R1<=4;#>,<R2#0<=R2<=2;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1*10;#>;<T1><V2>=<R4#R4=R2*10;#>;switch(<V1>){ case 10: <V2> = <V2> + 10; break; case 20: <V2> = <V2> + 10; case 30: <V2> = <V2> + 10; case 40: <V2> = <V2> + 10; case 50: <V2> = <V2> + 10; break; default: << <V2>; break; } << <V2>;}}
>
Type: debug_output
Hardness: 35

// Decrementing
# 344
Switch.Body.No break.Has statements
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=3;#>;switch(<V1>){ case 5: << <R2#9<=R2<11;#> * 10; case 4: << <R3#7<=R3<9;#> * 10; case 3: << <R4#5<=R4<7;#> * 10; case 2: << <R5#3<=R5<5;#> * 10; case 1: << <R6#1<=R6<3;#> * 10; default: << <V1> * 10; }}}
[<R1#1<=R1<=3;#>,<R2#9<=R2<11;#>,<R3#7<=R3<9;#>,<R4#5<=R4<7;#>,<R5#3<=R5<5;#>,<R6#1<=R6<3;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;switch(<V1>){ case 5: << <R7#R7=R2*10;#>; case 4: << <R8#R8=R3*10;#>; case 3: << <R9#R9=R4*10;#>; case 2: << <R10#R10=R5*10;#>; case 1: << <R11#R11=R6*10;#>; default: << <R12#R12=R1*10;#>; }}}
>
Type: debug_output
Hardness: 30

# 345
Switch.Body.No break.Has statements
>
{<T0><F0>(){<T1#integer#><V1>=<R1#2<=R1<=4;#>;switch(<V1>){ case 5: << <V1> + 10; break; case 4: << <V1> + 1; case 3: << <V1>; case 2: << <V1> - 1; case 1: << <V1> * 10; break; default: << <V1>; break; }}}
>
Type: debug_output
Hardness: 35

# 346
Switch.Body.No break.Has statements
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=3;#>;<T1><V2>=0;switch(<V1>){ case 5: <V2> = <V2> + 2; case 4: <V2> = <V2> + 2; case 3: <V2> = <V2> + 2; case 2: <V2> = <V2> + 2; case 1: <V2> = <V2> + 2; default: <V2> = <V2> + 2; } << <V2>; }}
>
Type: debug_output
Hardness: 30

# 347
Switch.Body.No break.Has statements
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#2<=R1<=4;#>;<T1><V2>=10;switch(<V1>){ case 5: <V2> = <V2> - 2; break; case 4: <V2> = <V2> - 2; case 3: <V2> = <V2> - 2; case 2: <V2> = <V2> - 2; case 1: <V2> = <V2> - 2; break; default: <V2> = <V2> - 2; break; } << <V2>;}}
[<R1#2<=R1<=4;#>,<R2#5<=R2<=9;#>,<R3#R3=R2*2;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>=<R3>;switch(<V1>){ case 5: <V2> = <V2> - 2; break; case 4: <V2> = <V2> - 2; case 3: <V2> = <V2> - 2; case 2: <V2> = <V2> - 2; case 1: <V2> = <V2> - 2; break; default: <V2> = <V2> - 2; break; } << <V2>;}}
>
Type: debug_output
Hardness: 35

# 348
Switch.Body.No break.Has statements
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#2<=R1<=4;#> * 10;<T1><V2>=16;switch(<V1>){ case 50: <V2> = <V2> / 2; case 40: <V2> = <V2> / 2; case 30: <V2> = <V2> / 2; case 20: <V2> = <V2> / 2; case 10: <V2> = <V2> / 2; default: << <V2>; } << <V2>; }}
[<R1#2<=R1<=4;#>,<R2#1<=R2<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1*10;#>;<T1><V2>=<R4#R4=R2*16;#>;switch(<V1>){ case 50: <V2> = <V2> / 2; case 40: <V2> = <V2> / 2; case 30: <V2> = <V2> / 2; case 20: <V2> = <V2> / 2; case 10: <V2> = <V2> / 2; default: << <V2>; } << <V2>; }}
>
Type: debug_output
Hardness: 35

# 349
Switch.Body.No break.Has statements
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#2<=R1<=4;#> * 10;<T1><V2>=50;switch(<V1>){ case 50: <V2> = <V2> - 10; break; case 40: <V2> = <V2> - 10; case 30: <V2> = <V2> - 10; case 20: <V2> = <V2> - 10; case 10: <V2> = <V2> - 10; break; default: << <V2>; break; } << <V2>;}}
[<R1#2<=R1<=4;#>,<R2#5<=R2<=9;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1*10;#>;<T1><V2>=<R4#R4=R2*10;#>;switch(<V1>){ case 50: <V2> = <V2> - 10; break; case 40: <V2> = <V2> - 10; case 30: <V2> = <V2> - 10; case 20: <V2> = <V2> - 10; case 10: <V2> = <V2> - 10; break; default: << <V2>; break; } << <V2>;}}
>
Type: debug_output
Hardness: 35

// ---------------------------------------------------------------------------
// 350
// Switch.Body.No break.No statement
// DONE

// Incrementing
# 350
Switch.Body.No break.No statement
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=3;#> * 10;<V1> = <V1> + <R2#6<=R2<=8;#>;switch(<V1>){ case 16: case 17: case 18: case 19: case 20: << <R1>; break; case 26: case 27: case 28: case 29: case 30: << <R2>; break; case 36: case 37: case 38: case 39: case 40: << <R3#4<=R3<=6;#>; break; default: << <R4#7<=R4<=9;#>; break; }}}
[<R1#1<=R1<=3;#>,<R2#6<=R2<=8;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1*10+R2;#>;switch(<V1>){ case 16: case 17: case 18: case 19: case 20: << <R1>; break; case 26: case 27: case 28: case 29: case 30: << <R2>; break; case 36: case 37: case 38: case 39: case 40: << <R4#4<=R4<=6;#>; break; default: << <R5#7<=R5<=9;#>; break; }}}
>
Type: debug_output
Hardness: 30

# 351
Switch.Body.No break.No statement
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#4<=R1<=6;#> * 10;<T1><V2> = <V1> + <R2#1<=R2<=3;#>;switch(<V2>){ case 41: case 42: case 43: case 44: case 45: << <V1> / 10; break; case 51: case 52: case 53: case 54: case 55: << <V2> * 10; break; case 61: case 62: case 63: case 64: case 65: << <V2> + <R1>; break; default: << <R1> - <V2>; break; }}}
[<R1#4<=R1<=6;#>,<R2#1<=R2<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1*10;#>;<T1><V2> = <R4#R4=R1*10+R2;#>;switch(<V2>){ case 41: case 42: case 43: case 44: case 45: << <V1> / 10; break; case 51: case 52: case 53: case 54: case 55: << <V2> * 10; break; case 61: case 62: case 63: case 64: case 65: << <V2> + <R1>; break; default: << <R1> - <V2>; break; }}}
>
Type: debug_output
Hardness: 30

# 352
Switch.Body.No break.No statement
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=3;#> * 10;<V1> = <V1> + <R2#1<=R2<=3;#>;<T1><V2>=<R2#1<=R2<=9;#>;switch(<V1>){ case 11: case 12: case 13: case 14: case 15: <V2> = <V2> + 10; break; case 21: case 22: case 23: case 24: case 25: <V2> = <V2> * 10; break; case 31: case 32: case 33: case 34: case 35: <V2> = <V2> + 1; break; default: <V2> = <V2> * 2; break; } << <V2>; }}
[<R1#1<=R1<=3;#>,<R2#1<=R2<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1*10+R2;#>;<T1><V2>=<R4#1<=R4<=9;#>;switch(<V1>){ case 11: case 12: case 13: case 14: case 15: <V2> = <V2> + 10; break; case 21: case 22: case 23: case 24: case 25: <V2> = <V2> * 10; break; case 31: case 32: case 33: case 34: case 35: <V2> = <V2> + 1; break; default: <V2> = <V2> * 2; break; } << <V2>; }}
>
Type: debug_output
Hardness: 30

# 353
Switch.Body.No break.No statement
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#7<=R1<=9;#> * 10;<T1><V2> = <V1> + <R2#4<=R2<=6;#>;<T1><V3>;switch(<V2>){ case 74: case 75: case 76: case 77: case 78: <V3> = <V1>; break; case 84: case 85: case 86: case 87: case 88: <V3> = <V2> * 10; break; case 94: case 95: case 96: case 97: case 98: <V3> = <R3#1<=R3<=3;#> * 10; break; default: <V3> = <R4#11<=R4<=19;#> * 10; break; } << <V3>;}}
[<R1#7<=R1<=9;#>,<R2#4<=R2<=6;#>,<R3#1<=R3<=3;#>,<R4#11<=R4<=19;#>]{<T0><F0>(){<T1#integer#><V1>= <R5#R5=R1*10;#>;<T1><V2> = <R6#R6=R5+R2;#>;<T1><V3>;switch(<V2>){ case 74: case 75: case 76: case 77: case 78: <V3> = <V1>; break; case 84: case 85: case 86: case 87: case 88: <V3> = <V2> * 10; break; case 94: case 95: case 96: case 97: case 98: <V3> = <R7#R7=R3*10;#>; break; default: <V3> = <R8#R8=R4*10;#>; break; } << <V3>;}}
>
Type: debug_output
Hardness: 30

# 354
Switch.Body.No break.No statement
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=3;#> * 2;<T1><V2> = <R2#4<=R2<=6;#> * 10;<T1><V3> = <V1> + <V2>;switch(<V3>){ case 42: case 44: case 46: case 48: case 50: << <V1>; break; case 52: case 54: case 56: case 58: case 60: << <V2>; break; case 62: case 64: case 66: case 68: case 70: << <R1> + <R2>; break; default: << <V3>; break; }}}
[<R1#1<=R1<=3;#>,<R2#4<=R2<=6;#>]{<T0><F0>(){<T1#integer#><V1>= <R3#R3=R1*2;#>;<T1><V2> = <R4#R4=R2*10;#>;<T1><V3> = <V1> + <V2>;switch(<V3>){ case 42: case 44: case 46: case 48: case 50: << <V1>; break; case 52: case 54: case 56: case 58: case 60: << <V2>; break; case 62: case 64: case 66: case 68: case 70: << <R5#R5=R1+R2;#>; break; default: << <V3>; break; }}}
>
Type: debug_output
Hardness: 30

# 355
Switch.Body.No break.No statement
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#5<=R1<=7;#> * 10;<T1><V2> = <R2#1<=R2<=3;#> * 100;<T1><V3> = <V1> + <V2>;<T1><V4>;switch(<V3>){ case 150: case 160: case 170: case 180: case 190: <V4> = <R1> * 100; break; case 250: case 260: case 270: case 280: case 290: <V4> = <V2>; break; case 350: case 360: case 370: case 380: case 390: <V4> = <R3#8<=R3<=10;#> * 10; break; default: <V4> = <V3>; break; } << <V4>;}}
[<R1#5<=R1<=7;#>,<R2#1<=R2<=3;#>,<R3#8<=R3<=10;#>]{<T0><F0>(){<T1#integer#><V1>= <R4#R4=R1*10;#>;<T1><V2> = <R5#R5=R2*100;#>;<T1><V3> = <V1> + <V2>;<T1><V4>;switch(<V3>){ case 150: case 160: case 170: case 180: case 190: <V4> = <R6#R6=R1*100;#>; break; case 250: case 260: case 270: case 280: case 290: <V4> = <V2>; break; case 350: case 360: case 370: case 380: case 390: <V4> = <R7#R7=R3*10;#>; break; default: <V4> = <V3>; break; } << <V4>;}}
>
Type: debug_output
Hardness: 30


// Decrementing
# 360
Switch.Body.No break.No statement
>
[<R1#4<=R1<=6;#>,<R2#7<=R2<=9;#>]{<T0><F0>(){<T1#integer#><V1>= <R3#R3=R1*10+R2;#>;switch(<V1>){  case 69: case 68: case 67: case 66: case 65: << <R2>; break; case 59: case 58: case 57: case 56: case 55: << <R1>; break; case 49: case 48: case 47: case 46: case 45: << <R4#1<=R4<=3;#>; break; default: << <R5#1<=R5<=9;#>; break; }}}
>
Type: debug_output
Hardness: 30

# 361
Switch.Body.No break.No statement
>
// [<R1#7<=R1<=9;#>]{<T0><F0>(){<T1#integer#><V1>=<R2#R2 = R1 * 10;#>;<T1><V2> = <V1> + <R3#3<=R3<=5;#>;switch(<V2>){ case 95: case 94: case 93: case 92: case 91: << <V1> + 10; break; case 85: case 84: case 83: case 82: case 81: << <V2> + 10; break; case 75: case 74: case 73: case 72: case 71: << <V1> - 10; break; default: << <V2> - 10; break; }}}
[<R1#7<=R1<=9;#>,<R2#R2=R1*10;#>,<R3#3<=R3<=5;#>,<R4#R4=R2+R3;#>]{<T0><F0>(){<T1><V1>=<R2>;<T1><V2> = <R4>;switch(<V2>){ case 95: case 94: case 93: case 92: case 91: << <V1> + 10; break; case 85: case 84: case 83: case 82: case 81: << <V2> + 10; break; case 75: case 74: case 73: case 72: case 71: << <V1> - 10; break; default: << <V2> - 10; break; }}}
>
Type: debug_output
Hardness: 30

# 362
Switch.Body.No break.No statement
>
[<R1#1<=R1<=3;#>,<R2#6<=R2<=8;#>]{<T0><F0>(){<T1#integer#><V1>= <R3#R3=R1*10+R2;#>;<T1><V2>=<R4#2<=R4<=9;#>;switch(<V1>){  case 38: case 37: case 36: case 35: case 34: <V2> = <V2> * 10; break; case 28: case 27: case 26: case 25: case 24: <V2> = <V2> + 10; break; case 18: case 17: case 16: case 15: case 14: <V2> = <V2> + 2; break; default: <V2> = <V2> - 2; break; } << <V2>; }}
>
Type: debug_output
Hardness: 30

# 363
Switch.Body.No break.No statement
>
[<R1#7<=R1<=9;#>,<R2#7<=R2<=9;#>,<R3#1<=R3<=3;#>,<R4#4<=R4<=6;#>]{<T0><F0>(){<T1#integer#><V1>=<R5#R5=R1*10+R2;#>;<T1><V2>;switch(<V1>){ case 99: case 98: case 97: case 96: case 95: <V2> = <V1>; break; case 89: case 88: case 87: case 86: case 85: <V2> = <R6#R6=R3*10;#>; break; case 79: case 78: case 77: case 76: case 75: <V2> = <R7#R7=R4*10;#>; break; default: <V2> = <R7#11<=R7<=19;#>; break; } << <V2>;}}
>
Type: debug_output
Hardness: 30

# 364
Switch.Body.No break.No statement
>
// [<R1#2<=R1<=4;#>,<R2#7<=R2<=9;#>]{<T0><F0>(){<T1#integer#><V1>= <R3#R3=R1*2;#>;<T1><V2> = <R4#R4=R2*10;#>;<T1><V3> = <V1> + <V2>;switch(<V3>){ case 98: case 96: case 94: case 92: case 90: << <V1>; break; case 88: case 86: case 84: case 82: case 80: << <V2>; break; case 78: case 76: case 74: case 72: case 70: << <R2> - <R1>; break; default: << <V3>; break; }}}
[<R1#2<=R1<=4;#>,<R2#7<=R2<=9;#>,<R3#R3=R1*2;#>,<R4#R4=R2*10;#>,<R5#R5=R3+R4;#>]{<T0><F0>(){<T1#integer#><V1>= <R3>;<T1><V2> = <R4>;<T1><V3> = <R5>;switch(<V3>){ case 98: case 96: case 94: case 92: case 90: << <V1>; break; case 88: case 86: case 84: case 82: case 80: << <V2>; break; case 78: case 76: case 74: case 72: case 70: << <R2> - <R1>; break; default: << <V3>; break; }}}
>
Type: debug_output
Hardness: 30

# 365
Switch.Body.No break.No statement
>
// [<R1#3<=R1<=5;#>,<R2#4<=R2<=6;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1*10;#>;<T1><V2> = <R4#R4=R2*100;#>;<T1><V3> = <V1> + <V2>;<T1><V4>;switch(<V3>){ case 650: case 640: case 630: case 620: case 610: <V4> = <R5#1<=R5<=3;#> * 100; break; case 550: case 540: case 530: case 520: case 510: <V4> = <V2>; break; case 450: case 440: case 430: case 420: case 410: <V4> = <R6#7<=R6<=9;#> * 100; break; default: <V4> = 1000; break; } << <V4>;}}
[<R1#3<=R1<=5;#>,<R2#4<=R2<=6;#>,<R3#R3=R1*10;#>,<R4#R4=R2*100;#>,<R5#R5=R3+R4;#>]{<T0><F0>(){<T1#integer#><V1>=<R3>;<T1><V2> = <R4>;<T1><V3> = <R5>;<T1><V4>;switch(<V3>){ case 650: case 640: case 630: case 620: case 610: <V4> = <R5#1<=R5<=3;#> * 100; break; case 550: case 540: case 530: case 520: case 510: <V4> = <V2>; break; case 450: case 440: case 430: case 420: case 410: <V4> = <R6#7<=R6<=9;#> * 100; break; default: <V4> = 1000; break; } << <V4>;}}
>
Type: debug_output
Hardness: 30





// ---------------------------------------------------------------------------
// 400
// Switch.Nested
// Considered incrementing versus decrementing
//  Printing in-situ versus printing at the end of the nested switch versus printing at the end of the nesting switch (much harder, must ensure uniqueness of all 9 cases)
// inc-inc/in-situ/var - 400
//        /end-of-nested/var - 401
//        /in-situ/expr - 402
//        /@ end/expr - 403
//        /in-situ/expr - 404
//        /end-of-nested/expr with multiples of 100 - 405


// Incrementing
# 400
Switch.Nested
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=3;#>;<T1><V2>=<R2#4<=R2<=6;#>;<T1><V3>=<R3#7<=R3<=9;#>;switch(<V1>){ case 1: switch(<V2>){ case 4: << <V1>; break; case 5: << <V2>; break; case 6: << <V3>; break; default: << <V1>; << <V2>; break; } break; case 2: switch(<V3>){ case 7: << <V3>; break; case 8: << <V2>; break; case 9: << <V1>; break; default: << <V1>; << <V3>; break; } break; case 3: switch(<V2>){ case 4: << <V2>; break; case 5: << <V3>; break; case 6: << <V1>; break; default: << <V1>; << <V2>; break; } break; default: << <V1>; << <V2>; << <V3>; break; }}}
>
Type: output
Hardness: 50

# 401
Switch.Nested
>
{<T0><F0>(){<T1#integer#><V1>=<R1#4<=R1<=6;#>;<T1><V2>=<R2#7<=R2<=9;#>;<T1><V3>=<R3#1<=R3<=3;#>;<T1><V4>;switch(<V1>){ case 4: switch(<V3>){ case 1: <V4> = <V3>; break; case 2: <V4> = <V2>; break; case 3: <V4> = <V1>; break; default: <V4> = <R4#11<=R4<=19;#>; break; } << <V4>; break; case 5: switch(<V2>){ case 7: <V4> = <V2>; break; case 8: <V4> = <V1>; break; case 9: <V4> = <V3>; break; default: <V4> = <R4>; break; } << <V4>; break; case 6: switch(<V3>){ case 1: <V4> = <V1>; break; case 2: <V4> = <V2>; break; case 3: <V4> = <V3>; break; default: <V4> = <R4>; break; } << <V4>; break; default: << <V1>; << <V2>; << <V3>; break; }}}
>
Type: output
Hardness: 50

# 402
Switch.Nested
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=3;#>;<T1><V2>=<R2#7<=R2<=9;#>;<T1><V3>=<R3#4<=R3<=6;#>;switch(<V1>){ case 1: switch(<V3>){ case 4: << <V3> + <V1>; break; case 5: << <V3> + <V2>; break; case 6: << <V1> + <V2>; break; default: << <V1>; << <V3>; break; } break; case 2: switch(<V3>){ case 4: << <V3> - <V1>; break; case 5: << <V2> - <V3>; break; case 6: << <V2> - <V1>; break; default: << <V3>; << <V1>; break; } break; case 3: switch(<V2>){ case 7: << <V1> - <V3>; break; case 8: << <V3> - <V2>; break; case 9: << <V1> - <V2>; break; default: << <V1>; << <V2>; break; } break; default: << <V1>; << <V2>; << <V3>; break; }}}
>
Type: output
Hardness: 50

# 403
Switch.Nested
>
[<R1#7<=R1<=9;#>]{<T0><F0>(){<T1#integer#><V1>=<R2#R2=R1*10;#>;<T1><V2>;<T1><V3>;switch(<V1>){ case 70: <V2> = <R3#1<=R3<=3;#>; switch(<V2>){ case 1: <V3> = <V2> * 10; break; case 2: <V3> = <V2> + 10; break; case 3: <V3> = <V2>; break; default: <V3> = <R6#101<=R6<=124;#>; break; } break; case 80: <V2> = <R4#7<=R4<=9;#>; switch(<V2>){ case 7: <V3> = <V2> + 10; break; case 8: <V3> = <V2>; break; case 9: <V3> = <V2> * 10; break; default: <V3> = <R7#125<=R7<=149;#>; break; } break; case 90: <V2> = <R5#4<=R5<=6;#>; switch(<V2>){ case 4: <V3> = <V2>; break; case 5: <V3> = <V2> * 10; break; case 6: <V3> = <V2> + 10; break; default: <V3> = <R8#150<=R8<=174;#>; break; } break; default: <V3> = <R9#175<=R9<=199;#>; break; } << <V3>; }}
>
Type: output
Hardness: 50

# 404
Switch.Nested
>
[<R1#1<=R1<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R2#R2=R1*10;#>;<T1><V2>;switch(<V1>){ case 10: <V2> = <R3#1<=R3<=3;#>; switch(<V2>){ case 1: << <V1> + <V2>; break; case 2: << <V1> / <V2>; break; case 3: << <V1> - <V2>; break; default: << <V2> * 10; break; } break; case 20: <V2> = <R4#4<=R4<=6;#>; switch(<V2>){ case 4: << <V1> / <V2>; break; case 5: << <V1> + <V2>; break; case 6: << <V1> - <V2>; break; default: << <V1>; << <V2>; break; } break; case 30: <V2> = <R5#7<=R5<=9;#>; switch(<V2>){ case 7: << <V1>; break; case 8: << <V1> + <V2>; break; case 9: << <V1> - <V2>; break; default: << <V2>; << <V1>; break; } break; default: << <V1>; << <V2> * 10; break; }}}
>
Type: output
Hardness: 50

# 405
Switch.Nested
>
[<R1#4<=R1<=6;#>,<R2#7<=R2<=9;#>,<R3#4<=R3<=6;#>,<R4#1<=R4<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R5#R5=R1*100;#>;<T1><V2>;<T1><V3>;switch(<V1>){ case 400: <V2> = <R6#R6=R2*10;#>; switch(<V2>){ case 70: <V3> = <V1> / 10; break; case 80: <V3> = <V2>; break; case 90: <V3> = <V2> / 10; break; default: <V3> = <V1>; break; } << <V3>; break; case 500: <V2> = <R7#R7=R3*10;#>; switch(<V2>){ case 40: <V3> = <V2> / 10; break; case 50: <V3> = <V1> / <V2>; break; case 60: <V3> = <V1> / 10; break; default: <V3> = <V1>; break; } << <V3>; break; case 600: <V2> = <R8#R8=R4*10;#>; switch(<V2>){ case 10: <V3> = <V1> / 10; break; case 20: <V3> = <V1> / <V2>; break; case 30: <V3> = <V2> / 10; break; default: <V3> = <V1>; break; } << <V3>; break; default: << <V1>; << <V2>; break; }}}
>
Type: output
Hardness: 50

// Decrementing
# 410
Switch.Nested
>
{<T0><F0>(){<T1#integer#><V1>=<R1#4<=R1<=6;#>;<T1><V2>=<R2#1<=R2<=3;#>;<T1><V3>=<R3#7<=R3<=9;#>;switch(<V1>){ case 6: switch(<V2>){ case 3: << <V3>; break; case 2: << <V1>; break; case 1: << <V2>; break; default: << <V1>; << <V2>; break; } break; case 5: switch(<V3>){ case 9: << <V2>; break; case 8: << <V1>; break; case 7: << <V3>; break; default: << <V1>; << <V3>; break; } break; case 4: switch(<V2>){ case 3: << <V3>; break; case 2: << <V1>; break; case 1: << <V2>; break; default: << <V1>; << <V2>; break; } break; default: << <V1>; << <V2>; << <V3>; break; }}}
>
Type: output
Hardness: 50

# 411
Switch.Nested
>
{<T0><F0>(){<T1#integer#><V1>=<R1#7<=R1<=9;#>;<T1><V2>=<R2#4<=R2<=6;#>;<T1><V3>=<R3#1<=R3<=3;#>;<T1><V4>;switch(<V1>){ case 9: switch(<V3>){ case 3: <V4> = <V1>; break; case 2: <V4> = <V2>; break; case 1: <V4> = <V3>; break; default: <V4> = <R4#11<=R4<=19;#>; break; } << <V4>; break; case 8: switch(<V2>){ case 6: <V4> = <V3>; break; case 5: <V4> = <V2>; break; case 4: <V4> = <V1>; break; default: <V4> = <R4>; break; } << <V4>; break; case 7: switch(<V2>){ case 6: <V4> = <V1>; break; case 5: <V4> = <V3>; break; case 4: <V4> = <V2>; break; default: <V4> = <R4>; break; } << <V4>; break; default: << <V1>; << <V2>; << <V3>; break; }}}
>
Type: output
Hardness: 50

# 412
Switch.Nested
>
{<T0><F0>(){<T1#integer#><V1>=<R1#7<=R1<=9;#>;<T1><V2>=<R2#1<=R2<=3;#>;<T1><V3>=<R3#4<=R3<=6;#>;switch(<V1>){ case 9: switch(<V3>){ case 6: << <V1> / 3; break; case 5: << <V1> - <V2>; break; case 4: << <V3> / 2; break; default: << <V1>; << <V3>; break; } break; case 8: switch(<V3>){ case 6: << <V1> / 4; break; case 5: << <V1> - <V3>; break; case 4: << <V3> / 2; break; default: << <V3>; << <V1>; break; } break; case 7: switch(<V2>){ case 3: << <V1> + <V2>; break; case 2: << <V1> * <V2>; break; case 1: << <V1> - <V2>; break; default: << <V1>; << <V2>; break; } break; default: << <V1>; << <V2>; << <V3>; break; }}}
>
Type: output
Hardness: 50

# 413
Switch.Nested
>
[<R1#7<=R1<=9;#>]{<T0><F0>(){<T1#integer#><V1>=<R2#R2=R1*10;#>;<T1><V2>;<T1><V3>;switch(<V1>){ case 90: <V2> = <R3#4<=R3<=6;#>; switch(<V2>){ case 6: <V3> = <V2> + 10; break; case 5: <V3> = <V2> * 10; break; case 4: <V3> = <V2>; break; default: <V3> = <R6#101<=R6<=124;#>; break; } break; case 80: <V2> = <R4#7<=R4<=9;#>; switch(<V2>){ case 9: <V3> = <V2>; break; case 8: <V3> = <V2> + 10; break; case 7: <V3> = <V2> * 10; break; default: <V3> = <R7#125<=R7<=149;#>; break; } break; case 70: <V2> = <R5#1<=R5<=3;#>; switch(<V2>){ case 3: <V3> = <V2> * 10; break; case 2: <V3> = <V2>; break; case 1: <V3> = <V2> + 10; break; default: <V3> = <R8#150<=R8<=174;#>; break; } break; default: <V3> = <R9#175<=R9<=199;#>; break; } << <V3>; }}
>
Type: output
Hardness: 50

# 414
Switch.Nested
>
[<R1#1<=R1<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R2#R2=R1*10;#>;<T1><V2>;switch(<V1>){ case 30: <V2> = <R3#7<=R3<=9;#>; switch(<V2>){ case 9: << <V1> / 10; break; case 8: << <V2> / 2; break; case 7: << <V2>; break; default: << <V2> * 10; break; } break; case 20: <V2> = <R4#4<=R4<=6;#>; switch(<V2>){ case 6: << <V2> / 2; break; case 5: << <V1> + <V2>; break; case 4: << <V1> / 10; break; default: << <V2> * 10; break; } break; case 10: <V2> = <R5#1<=R5<=3;#>; switch(<V2>){ case 3: << <V1> - <V2>; break; case 2: << <V1> / <V2>; break; case 1: << <V1> + <V2>; break; default: << <V1> * 10; break; } break; default: << <V1>; << <V2>; break; }}}
>
Type: output
Hardness: 50

# 415
Switch.Nested
>
[<R1#4<=R1<=6;#>,<R2#7<=R2<=9;#>,<R3#4<=R3<=6;#>,<R4#1<=R4<=3;#>]{<T0><F0>(){<T1#integer#><V1>=<R5#R5=R1*100;#>;<T1><V2>;<T1><V3>;switch(<V1>){ case 600: <V2> = <R6#R6=R4*10;#>; switch(<V2>){ case 30: <V3> = <V1> / 100; break; case 20: <V3> = <V2> / 10; break; case 10: <V3> = <V1> / <V2>; break; default: <V3> = <V1>; break; } << <V3>; break; case 500: <V2> = <R7#R7=R3*10;#>; switch(<V2>){ case 60: <V3> = <V2> / 10; break; case 50: <V3> = <V1> / <V2>; break; case 40: <V3> = <V1> / 10; break; default: <V3> = <V1>; break; } << <V3>; break; case 400: <V2> = <R8#R8=R2*10;#>; switch(<V2>){ case 90: <V3> = <V2> / 10; break; case 80: <V3> = <V1> + <V2>; break; case 70: <V3> = <V1> / 10; break; default: <V3> = <V1>; break; } << <V3>; break; default: << <V1>; << <V2>; break; }}}
>
Type: output
Hardness: 50

// ---------------------------------------------------------------------------
// Multiple switches
// Incrementing versus decrementing: ii, id, di, dd
// independent versus dependent: pp, vp, vv (after each switch versus at the end, one variable versus two)

// assign to variable in first, use it as condition of second to print
// assign to variable in first, use it as condition of second to assign to another variable and print it after second switch
// Modify value of same variable in both switch statements, and print after second switch
// inc-inc, inc-dec, dec-inc, dec-dec
// 

// inc-inc, @end-@end (m + n and m - n)
# 500
Switch.Multiple
>
[<R1#6<=R1<=9;#>,<R2#1<=R2<=5;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2;#>;<T1><V2> = <R4#R4 = R1 - R2;#>;<T1><V3>;switch(<V1>){ case <R5#R5=R1+1;#>: <V3> = <V2>; break; case <R6#R6=R1+2;#>: <V3> = <V1>; break; case <R7#R7=R1+3;#>: <V3> = <V1> + 1; break; case <R8#R8=R1+4;#>: <V3> = <V2> - 1; break; case <R9#R9=R1+5;#>: <V3> = <R1>; break; default: <V3> = <R10#R10=R1*2;#>; break;} << <V3>; switch(<V2>){ case <R11#R11 = R1 - 1;#>: <V3> = <V3> + 10; break; case <R12#R12 = R1 - 2;#>: <V3> = <V3> + 1; break; case <R13#R13 = R1 - 3;#>: <V3> = <V3> - 1; break; case <R14#R14 = R1 - 4;#>: <V3> = <V3> * 10; break; case <R15#R15 = R1 - 5;#>: <V3> = <V3> - 10; break; default: <V3> = 0; break;} << <V3>; }}
>
Type: output
Hardness: 40

// inc-dec, inSitu-@end (m + 2n and m - 2n)
# 501
Switch.Multiple
>
[<R1#11<=R1<=19;#>,<R2#1<=R2<=5;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2+R2;#>;<T1><V2> = <R4#R4 = R1 - R2 - R2;#>;switch(<V1>){ case <R5#R5=R1+2;#>: << <V2>; break; case <R6#R6=R1+4;#>: << <V1>; break; case <R7#R7=R1+6;#>: << <V1> + 2; break; case <R8#R8=R1+8;#>: << <V2> - 2; break; case <R9#R9=R1+10;#>: << <R1>; break; default: << <R10#R10=R1*2;#>; break;} <T1><V3>; switch(<V2>){ case <R11#R11 = R1 - 10;#>: <V3> = <R10>; break; case <R12#R12 = R1 - 8;#>: <V3> = <R6>; break; case <R13#R13 = R1 - 6;#>: <V3> = <R5>; break; case <R14#R14 = R1 - 4;#>: <V3> = <R8>; break; case <R15#R15 = R1 - 2;#>: <V3> = <R9>; break; default: <V3> = <R7>; break;} << <V3>; }}
>
Type: output
Hardness: 40

// dec-inc, @end-inSitu (m - 2n, and its multiples of 10)
# 502
Switch.Multiple
>
[<R1#6<=R1<=9;#>,<R2#1<=R2<=5;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3 = R1 - R2;#>;<T1><V2> = <R4#R4=R3*10;#>;<T1><V3>;switch(<V1>){ case <R5#R5 = R1 - 5;#>: <V3> = <R1>; break; case <R6#R6 = R1 - 4;#>: <V3> = <R2>; break; case <R7#R7 = R1 - 3;#>: <V3> = <R16#R16=R1*10;#>; break; case <R8#R8 = R1 - 2;#>: <V3> = <R17#R17=R2*10;#>; break; case <R9#R9 = R1 - 1;#>: <V3> = <R18#R18=R1+R2;#>; break; default: <V3> = 0; break;} << <V3>; switch(<V2>){ case <R11#R11=R9*10;#>: << <V3>; break; case <R12#R12=R8*10;#>: << <V3> + 1; break; case <R13#R13=R7*10;#>: << <V3> - 1; break; case <R14#R14=R6*10;#>: << <V3> + 2; break; case <R15#R15=R5*10;#>: << <V3> - 2; break; default: << <V3> * 2; break;} }}
>
Type: output
Hardness: 40

// dec-dec, inSitu-inSitu (Multiples of 100 and 10)
# 503
Switch.Multiple
>
[<R1#6<=R1<=10;#>,<R2#1<=R2<=5;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1*100;#>;<T1><V2> = <R4#R4=R2*10;#>;switch(<V1>){ case 1000: << <V1>; break; case 900: << <V2>; break; case 800: << <V1> / 100; break; case 700: << <V2> / 10; break; case 600: << <V1> / 10; break; default: << <V1>; << <V2>; break;} switch(<V2>){ case 50: << <V2> + 10; break; case 40: << <V2> - 10; break; case 30: << <V2> * 10; break; case 20: << <V1> + <V2>; break; case 10: << <V1> / <V2>; break; default: << <V2>; << <V1>; break;} }}
>
Type: output
Hardness: 40


// inc-inc, inSitu-@end (Multiples of 3 and 2)
# 504
Switch.Multiple
>
// [<R1#1<=R1<=9;#>,<R2#1<=R2<=5;#>,<R3#R3=R1+R2;#>]{<T0><F0>(){<T1#integer#><V1>=<R4#R4=R3*3;#>;<T1><V2> = <R5#R5=R3*2;#>;switch(<V1>){ case <R5#R5=R1*3+3;#>: << <V2> * 10; break; case <R6#R6=R1*3+6;#>: << <V3> * 10; break; case <R7#R7=R1*3+9;#>: << <V3> + 10; break; case <R8#R8=R1*3+12;#>: << <V2> + 10; break; case <R9#R9=R1*3+15;#>: << <V3> + 100; break; default: << <V2> + 100; break;} <T1><V3>; switch(<V2>){ case <R11#R11=R1*2+2;#>: <V3> = <R9>; break; case <R12#R12=R1*2+4;#>: <V3> = <R7>; break; case <R13#R13=R1*2+6;#>: <V3> = <R5>; break; case <R14#R14=R1*2+8;#>: <V3> = <R8>; break; case <R15#R15=R1*2+10;#>: <V3> = <R6>; break; default: <V3> = <R1>; break;} << <V3>; }}
[<R1#1<=R1<=9;#>,<R2#1<=R2<=5;#>,<R3#R3=R1+R2;#>]{<T0><F0>(){<T1#integer#><V1>=<R4#R4=R3*3;#>;<T1><V2> = <R5#R5=R3*2;#>; <T1><V3>=<R1>;switch(<V1>){ case <R6#R6=R1*3+3;#>: << <V2> * 10; break; case <R7#R7=R1*3+6;#>: << <V3> * 10; break; case <R8#R8=R1*3+9;#>: << <V3> + 10; break; case <R9#R9=R1*3+12;#>: << <V2> + 10; break; case <R10#R10=R1*3+15;#>: << <V3> + 100; break; default: << <V2> + 100; break;} switch(<V2>){ case <R11#R11=R1*2+2;#>: <V3> = <R9>; break; case <R12#R12=R1*2+4;#>: <V3> = <R7>; break; case <R13#R13=R1*2+6;#>: <V3> = <R5>; break; case <R14#R14=R1*2+8;#>: <V3> = <R8>; break; case <R15#R15=R1*2+10;#>: <V3> = <R6>; break; default: <V3> = <R1>; break;} << <V3>; }}
>
Type: output
Hardness: 40

// inc-dec, @end-@end (multiples of 5 and 10)
# 505
Switch.Multiple
>
[<R1#1<=R1<=5;#>,<R2#1<=R2<=5;#>,<R3#R3=R1+R2;#>]{<T0><F0>(){<T1#integer#><V1>=<R4#R4=R3*5;#>;<T1><V2> = <R5#R5=R3*10;#>;<T1><V3>;switch(<V1>){ case <R6#R6=R1*5+5;#>: <V3> = <R11#R11=R1*10+50;#>; break; case <R7#R7=R1*5+10;#>: <V3> = <R12#R12=R1*10+40;#>; break; case <R8#R8=R1*5+15;#>: <V3> = <R13#R13=R1*10+30;#>; break; case <R9#R9=R1*5+20;#>: <V3> = <R14#R14=R1*10+20;#>; break; case <R10#R10=R1*5+25;#>: <V3> = <R15#R15=R1*10+10;#>; break; default: <V3> = <R1> * 10; break;} << <V3>; switch(<V2>){ case <R11>: <V3> = <R7>; break; case <R12>: <V3> = <R10>; break; case <R13>: <V3> = <R8>; break; case <R14>: <V3> = <R6>; break; case <R15>: <V3> = <R9>; break; default: <V3> = <R1> * 5; break;} << <V3>; }}
>
Type: output
Hardness: 40

// dec-inc, inSitu-inSitu (odd, even)
# 506
Switch.Multiple
>
[<R1#1<=R1<=5;#>,<R2#1<=R2<=5;#>,<R3#R3=R1*2+R2*2;#>]{<T0><F0>(){<T1#integer#><V1>=<R4#R4=R3+1;#>;<T1><V2> = <R3>; switch(<V1>){ case <R6#R6=R1*2+11;#>: << <V1> - 1; break; case <R7#R7=R1*2+9;#>: << <V1> + 1; break; case <R8#R8=R1*2+7;#>: << <V1>; break; case <R9#R9=R1*2+5;#>: << <V1> - 1; break; case <R10#R10=R1*2+3;#>: << <V1> + 1; break; default: << <V1>; break;} switch(<V2>){ case <R11#R11=R1*2+2;#>: << <V2> + 2; break; case <R12#R12=R1*2+4;#>: << <V2> - 2; break; case <R13#R13=R1*2+6;#>: << <V2>; break; case <R14#R14=R1*2+8;#>: << <V2> + 2; break; case <R15#R15=R1*2+10;#>: << <V2> - 2; break; default: << <V2>; break;} }}
>
Type: output
Hardness: 40

// dec-dec, @end-inSitu (10m + 10n, 10m - 10n)
# 507
Switch.Multiple
>
[<R1#6<=R1<=15;#>,<R2#1<=R2<=5;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1*10+R2*10;#>;<T1><V2> = <R4#R4=R1*10-R2*10;#>; <T1><V3>; switch(<V1>){ case <R5#R5=R1*10+50;#>: <V3> = <V1> / 10; break; case <R6#R6=R1*10+40;#>: <V3> = <V1> * 10; break; case <R7#R7=R1*10+30;#>: <V3> = <V1> - 10; break; case <R8#R8=R1*10+20;#>: <V3> = <V1> + 10; break; case <R9#R9=R1*10+10;#>: <V3> = <V1> + 100; break; default: <V3> = <V1>; break;} << <V3>; switch(<V2>){ case <R11#R11= R1 * 10 - 10;#>: << <V2>; break; case <R12#R12= R1 * 10 - 20;#>: << <V1>; break; case <R13#R13 = R1 * 10 - 30;#>: << <V3>; break; case <R14#R14 = R1 * 10 - 40;#>: << <V1>; break; case <R15#R15 = R1 * 10 - 50;#>: << <V2>; break; default: << <V2> * 10; break;} }}
>
Type: output
Hardness: 40


// Dependent switches
// [<R1#1<=R1<=5;#>,<R2#0<=R2<=4;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2;#>;<T1><V2>;switch(<V1>){ case <R1>: <V2> = <R4#R4=R1 * 10 + 30;#>; break; case <R5#R5=R1+1;#>: <V2> = <R6#R6 = R1 * 10 + 10;#>; break; case <R7#R7=R1+2;#>: <V2> = <R8#R8 = R1 * 10;#>; break; case <R9#R9=R1+3;#>: <V2> = <R10#R10 = R1 * 10 + 40;#>; break; case <R11#R11=R1+4;#>: <V2> = <R12#R12 = R1 * 10 + 20;#>; break; default: <V2> = <R13#R13 = R1 * 10 + 50;#>; break;} << <V2>; <T1><V3>; switch(<V2>){ case <R10>: <V3> = <R14#R14 = ;#>; break; case <R4>: <V3> = <R3#20<=R3<30;#>; break; case <R12>: <V3> = <R4#30<=R4<40;#>; break; case <R6>: <V3> = <R5#40<=R5<50;#>; break; case <R8>: <V3> = <R6#50<=R6<60;#>; break; default: <V3> = <R7#60<=R7<100;#>; break;} << <V3>; }}

// [<R1#1<=R1<=5;#>,<R2#0<=R2<=4;#>]{<T0><F0>(){<T1#integer#><V1>=<R3#R3=R1+R2;#>;<T1><V2>;switch(<V1>){ case <R1>: <V2> = <R4#R4=R1 * 10 + 30;#>; break; case <R5#R5=R1+1;#>: <V2> = <R6#R6 = R1 * 10 + 10;#>; break; case <R7#R7=R1+2;#>: <V2> = <R8#R8 = R1 * 10;#>; break; case <R9#R9=R1+3;#>: <V2> = <R10#R10 = R1 * 10 + 40;#>; break; case <R11#R11=R1+4;#>: <V2> = <R12#R12 = R1 * 10 + 20;#>; break; default: <V2> = <R13#R13 = R1 * 10 + 50;#>; break;} << <V2>; switch(<V2>){ case <R8>: << <R14#10<=R14<20;#>; break; case <R6>: << <R15#20<=R15<30;#>; break; case <R12>: << <R16#30<=R16<40;#>; break; case <R4>: << <R17#40<=R17<50;#>; break; case <R10>: << <R18#50<=R18<60;#>; break; default: << <R19#60<=R19<100;#>; break;} }}


// // FOLLOWING DOES NOT WORK IF VALUE OF CONDITION IS 2 OR GREATER - BUG TO BE FIXED - 
// // BLOCK INSIDE A STATEMENTSEQUENCE SEEMS TO GENERATE A PROBLEM
// # 600
// Switch.Condition.Matches case
// >
// // {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;switch(<V1>){ case 1: << <R2#10<=R2<20;#>; break; case 2: << <R3#20<=R3<30;#>; break; case 3: << <R4#30<=R4<40;#>; break; case 4: << <R5#40<=R5<50;#>; break; case 5: << <R6#50<=R6<60;#>; break; default: << <R7#60<=R7<100;#>; break; }}}
// {<T0><F0>(){<T1#integer#><V1>=2;switch(<V1>){ case 1: {<< <R2#10<=R2<20;#>; break;} case 2: {<< <R3#20<=R3<30;#>;} break; case 3: {<< <R3>;} << <R4#30<=R4<40;#>; break; case 4: {<< <R3>;} << <R5#40<=R5<50;#>; {<< <R3>;} break; case 5: << <R6#50<=R6<60;#>; break; default: << <R7#60<=R7<100;#>; break; }}}
// >
// Type: debug_output
// Hardness: 20


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

// How to enter an output
# 90
Demonstration
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=9;#>;<<<V1>;}}
>
Type: debug_output
Hardness: 10

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

// How to enter NO output
# 92
Demonstration
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=9;#>;<T1><V2>=<R2#integer;1<=R2<=9;#>;<T1><V3>;<V3> = <V1> + <V2>;}}
>
Type: debug_output
Hardness: 10



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