// Master template
//
// // Declaring a structure variable when the structure definition is out of scope - 100
// Structure.Definition.Definition is not in scope
//
// // Same name is used for fields in more than one structure - 150
// Structure.Declaration.Conflict in the name of structure fields
//
// // Initialization of all the fields of a structure - 200
// Structure.Initialization.Complete
// // Initialization of only some of the fields of a structure - 225
// Structure.Initialization.Incomplete?
//
// // Assignment to a field of a structure variable - 300
// Structure.Assignment.Field.Correct
// // Assignment of a value of incorrect data type to a field of a structure variable - 325
// Structure.Assignment.Field.Value of incorrect data type assigned to variable
// // Assigning to the field of a structure without using the dot operator - 350
// Structure.Assignment.Field.Referring to field independent of the variable
// // Assigning from one structure variable to another in aggregate - 375
// Structure.Assignment.Aggregate
// // Assigning to structure type instead of structure variable - 400
// Structure.Assignment.Assigning to structure type instead of structure variable
//
// // Correctly referencing the field of a structure variable - 500
// Structure.Referencing.Field.Correct
// // Referencing the field of a structure variable before initializing it - 525
// Structure.Referencing.Field.Referencing variable before initializing its value
// // Referencing a field that is not part of a structure variable - 550
// Structure.Referencing.Field.Referencing field that is not part of the structure
// // Referencing the field of a structure variable without using the dot operator- 575
// // Same as Structure.Assignment.Field.Referring to field independent of the variable
// // Structure.Referencing.Field.Missing dot operator in the statement
//
// // Testing that values assigned in caller propagate to the called function
// // Structure variable passed as a parameter to a function where it is referenced - 600
// Structure.Parameter.Aggregate.Accessed
// // Testing that changes in a function do not propagate back to caller
// // Structure variable passed as a parameter to a function where it is modified - 625
// Structure.Parameter.Aggregate.Modified
// // Field of a structure variable passed as a parameter to a function - 650
// Structure.Parameter.Field
//
// // One is a structure, other a variable corresponding to one of its fields - 675
// Structure.Parameter.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
//
// // Entire structure is returned by a function - 700
// Structure.Returned
//
// // Declaring variable of nested structure - 800
// Structure.Nested.Declaring variable of nested structure
// // Assigning to nested field - 825
// Structure.Nested.Assigning to nested field
// // Referencing nested field - 850
// Structure.Nested.Referencing nested field
//
// // =================================================================================
// // Declaring a structure variable when the structure definition is out of scope - 100
// Structure.Definition.Definition is not in scope

# 100
Structure.Definition.Definition is not in scope
>
{
<T0><F1>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
   };
   <S1><V4>;
   >> <V4>.<V1>;
}
<T0><F0>(){
   <F1>();
   <S1><V3>;
   >> <V3>.<V2>;
   << <V3>.<V2>;   
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 101
Structure.Definition.Definition is not in scope
>
{
<T0><F1>(){
   <S1><V4>;
   >> <V4>.<V2>;
}
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
   };
   <F1>();
   <S1><V3>;
   >> <V3>.<V1>;   
   >> <V3>.<V1>;   
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 102
Structure.Definition.Definition is not in scope
>
{
<T0><F1>(<S1><V4>){
   >> <V4>.<V1>;
}
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
   };
   <S1><V3>;
   <F1>(<V3>);
   >> <V3>.<V2>;   
   << <V3>.<V2>;   
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Same name is used for fields in more than one structure - 150
// Structure.Declaration.Conflict in the name of structure fields

# 150
Structure.Declaration.Conflict in the name of structure fields
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
   };
   <S2>{
      <T1#signed#><V1>;
      <T3#bool#><V3>;
   };
   <S1><V4>;
   >> <V4>.<V2>;   
   <S2><V5>;
   >> <V5>.<V1>;
   << <V4>.<V2>;
   << <V5>.<V1>;
}}
>
Input: "<R1#float;1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 151
Structure.Declaration.Conflict in the name of structure fields
>
{
<T0><F0>(){
   <S1>{
      <T2#char#><V1>;
      <T1#signed#><V2>;
   };
   <S2>{
      <T3#bool#><V1>;
      <T1#signed#><V3>;
   };
   <S1><V4>;
   <V4>.<V2> = <R1#1<=R1<=4;#>;   
   <S2><V5>;
   >> <V5>.<V3>;
   <T1><V6> = <V5>.<V3> - <V4>.<V2>;
   << <V6>;
}}
>
Input: "<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 152
Structure.Declaration.Conflict in the name of structure fields
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
   };
   <S2>{
      <T1#signed#><V1>;
      <T3#char#><V3>;
   };
   <S1><V4>;
   <V4>.<V2> = <R1#float;1<=R1<=4;#>;   
   <S2><V5>;
   <V5>.<V1> = <R2#5<=R2<=9;#>;
   << <V5>.<V1>;
   << <V4>.<V2>;
}}
>
Type: debug_output
Hardness: 10 

# 153
Structure.Declaration.Conflict in the name of structure fields
>
{
<T0><F0>(){
   <S1>{
      <T2#char#><V1>;
      <T1#signed#><V2>;
   };
   <S2>{
      <T3#bool#><V1>;
      <T1#signed#><V3>;
   };
   <S1><V4>;
   >> <V4>.<V2>;   
   <S2><V5>;
   <V5>.<V3> = <R2#5<=R2<=9;#>;
   << <V5>.<V3> - <V4>.<V2>;
}}
>
Input: "<R1#1<=R1<=4;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Initialization of all the fields of a structure - 200
// Structure.Initialization.Complete

# 200
Structure.Initialization.Complete
?
Structure.Referencing.Field.Correct
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
      <T3#bool#><V3>;
   };
   <S1><V4> = { <R1#1<=R1<=4;#>, <R2#float;5<=R2<=9;#>, true };
   << <V4>.<V2> - <V4>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

# 201
Structure.Initialization.Complete
?
Structure.Referencing.Field.Correct
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T2#signed#><V2>;
      <T3#char#><V3>;
   };
   <S1><V4> = { <R1#float;1<=R1<=4;#>, <R2#5<=R2<=9;#>, <R3#char;'a'<=R3<='z';#> };
   << <V4>.<V2> * 10;
}}
>
Type: debug_output
Hardness: 10 

# 202
Structure.Initialization.Complete
?
Structure.Referencing.Field.Correct
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#char#><V2>;
      <T3#bool#><V3>;
   };
   <S1><V4> = { <R1#1<=R1<=9;#>, <R3#char;'A'<=R3<='Z';#>, true };
   << <V4>.<V1> + 10;
}}
>
Type: debug_output
Hardness: 10 

# 203
Structure.Initialization.Complete
?
Structure.Referencing.Field.Correct
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T2#bool#><V2>;
      <T3#char#><V3>;
   };
   <S1><V4> = { <R1#float;1<=R1<=9;#>, false, <R3#char;'a'<=R3<='z';#> };
   << <V4>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// TO DO - CHECK WHAT HAPPENS IN REAL CODE
// // Initialization of only some of the fields of a structure - 225
// Structure.Initialization.Incomplete

# 225
Structure.Initialization.Incomplete
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#bool#><V2>;
      <T3#real#><V3>;
   };
   <S1><V4> = { <R1#1<=R1<=4;#> };
   << <V4>.<V3>;
}}
>
Type: debug_output
Hardness: 10 

# 226
Structure.Initialization.Incomplete
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T2#char#><V2>;
      <T3#signed#><V3>;
   };
   <S1><V4> = { <R1#float;1<=R1<=4;#>, <R3#char;'a'<=R3<='z';#> };
   << <V4>.<V3> + 1;
}}
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Assignment to a field of a structure variable - 300
// Structure.Assignment.Field.Correct

# 300
Structure.Assignment.Field.Correct
?
Structure.Referencing.Field.Correct
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
   };
   <S1><V3>;
   <V3>.<V1> = <R1#1<=R1<=4;#>;   
   >> <V3>.<V2>;
   << <V3>.<V2> - <V3>.<V1>;
}}
>
Input: "<R2#float;5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 301
Structure.Assignment.Field.Correct
?
Structure.Referencing.Field.Correct
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T2#signed#><V2>;
   };
   <S1><V3>;
   >> <V3>.<V1>;
   <V3>.<V2> = <R1#1<=R1<=4;#>;   
   << <V3>.<V1> - <V3>.<V2>;
}}
>
Input: "<R2#float;5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 302
Structure.Assignment.Field.Correct
?
Structure.Referencing.Field.Correct
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
   };
   <S1><V3>;
   <V3>.<V1> = <R1#1<=R1<=9;#>;   
   << <V3>.<V1>;
   <V3>.<V2> = <R2#float;1<=R2<=9;#>;
   << <V3>.<V2>;
}}
>
Type: debug_output
Hardness: 10 

// Two inputs - will it be a problem? - may be not since inputs are back to back
# 303
Structure.Assignment.Field.Correct
?
Structure.Referencing.Field.Correct
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T2#signed#><V2>;
   };
   <S1><V3>;
   >> <V3>.<V1>;
   >> <V3>.<V2>;   
   << <V3>.<V1>;
   << <V3>.<V2>;
}}
>
Input: "<R2#float;1<=R2<=9;#>\n<R1#1<=R1<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Assignment of a value of incorrect data type to a field of a structure variable - 325
// Structure.Assignment.Field.Value of incorrect data type assigned to variable

# 325
Structure.Assignment.Field.Value of incorrect data type assigned to variable
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
   };
   <S1><V3>;
   <T2><V4> = <R1#float;1<=R1<=9;#>;   
   <V3>.<V1> = <V4>;
   << <V4> * 10;
}}
>
Type: debug_output
Hardness: 10 

# 326
Structure.Assignment.Field.Value of incorrect data type assigned to variable
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T2#signed#><V2>;
   };
   <T1><V4> = <R1#float;1<=R1<=9;#>;
   <S1><V3>;
   <V3>.<V2> = <V4>;
   << <V4> + 10;
}}
>
Type: debug_output
Hardness: 10 

# 327
Structure.Assignment.Field.Value of incorrect data type assigned to variable
>
{
<T0><F0>(){
   <S1>{
      <T1#char#><V1>;
      <T2#signed#><V2>;
   };
   <S1><V3>;
   <T3#real#><V4>;
   >> <V4>;
   <V3>.<V1> = <V4>;
   << <V4>;
}}
>
Input: "<R1#float;5<=R1<=9;#>\n<R2#float;1<=R2<=4;#>\n<R3#float;11<=R3<=19;#>"
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Assigning to the field of a structure without using the dot operator - 350
// Structure.Assignment.Field.Referring to field independent of the variable

# 350
Structure.Assignment.Field.Referring to field as independent variable
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
   };
   <T1><V3> = <R1#1<=R1<=9;#>;   
   <V1> = <V3>;
   << <V3>;
}}
>
Type: debug_output
Hardness: 10 

# 351
Structure.Assignment.Field.Referring to field as independent variable
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T2#signed#><V2>;
   };
   <T1><V3>;
   >> <V3>;
   >> <V1>;
   << <V3>;
}}
>
Input: "<R1#float;5<=R1<=9;#>\n<R2#float;1<=R2<=4;#>\n<R3#float;11<=R3<=19;#>"
>
Type: debug_output
Hardness: 10 

# 352
Structure.Assignment.Field.Referring to field as independent variable
>
{
<T0><F0>(){
   <S1>{
      <T2#char#><V2>;
      <T1#signed#><V1>;
   };
   <T1><V3> = <R1#1<=R1<=5;#>;   
   <S1><V4>;
   >> <V1>;
   << <V3>;
}}
>
Input: "<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 353
Structure.Assignment.Field.Referring to field as independent variable
>
{
<T0><F0>(){
   <S1>{
      <T2#bool#><V2>;
      <T1#real#><V1>;
   };
   <S1><V4>;
   <T1><V3>;
   >> <V3>;
   <V1> = <V3>;
   << <V3>;
}}
>
Input: "<R1#float;5<=R1<=9;#>\n<R2#float;1<=R2<=4;#>\n<R3#float;11<=R3<=19;#>"
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Assigning from one structure variable to another in aggregate - 375
// Structure.Assignment.Aggregate

# 375
Structure.Assignment.Aggregate
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
   };
   <S1><V3>;
   <V3>.<V1> = <R1#1<=R1<=4;#>;   
   <V3>.<V2> = <R2#float;5<=R2<=9;#>;
   <S1><V4>;
   <V4> = <V3>;
   << <V4>.<V2> - <V4>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

// Two inputs - will it be a problem? - may be not since inputs are back to back
# 376
Structure.Assignment.Aggregate
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T2#signed#><V2>;
   };
   <S1><V3>;
   >> <V3>.<V1>;
   >> <V3>.<V2>;
   <S1><V4>;
   <V4> = <V3>;
   << <V4>.<V1> - <V4>.<V2>;
}}
>
Input: "<R1#float;5<=R1<=9;#>\n<R2#1<=R2<=4;#>\n<R3#float;15<=R3<=19;#>\n<R4#11<=R4<=14;#>"
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Assigning to structure type instead of structure variable - 400
// Structure.Assignment.Assigning to structure type instead of structure variable

# 400
Structure.Assignment.Assigning to structure type instead of structure variable
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
   };
   <S1>.<V1> = <R1#1<=R1<=9;#>;   
   <T1><V3>;
   <V3> = <R1> * <R1>;
   << <V3>;
}}
>
Type: debug_output
Hardness: 10 

# 401
Structure.Assignment.Assigning to structure type instead of structure variable
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T2#signed#><V2>;
   };
   >> <S1>.<V1>;
   <T1><V3>;
   >> <V3>;
   << <V3> * 10;
}}
>
Input: "<R1#float;5<=R1<=9;#>\n<R2#float;1<=R2<=4;#>\n<R3#float;15<=R3<=19;#>\n"
>
Type: debug_output
Hardness: 10 

# 402
Structure.Assignment.Assigning to structure type instead of structure variable
>
{
<T0><F0>(){
   <S1>{
      <T2#char#><V2>;
      <T1#signed#><V1>;
   };
   <T1><V3> = <R1#1<=R1<=5;#>;   
   >> <S1>.<V1>;
   << <V3>;
}}
>
Input: "<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 403
Structure.Assignment.Assigning to structure type instead of structure variable
>
{
<T0><F0>(){
   <S1>{
      <T2#bool#><V2>;
      <T1#real#><V1>;
   };
   <T1><V3>;
   >> <V3>;
   <S1>.<V1> = <V3>;
   << <V3>;
}}
>
Input: "<R1#float;5<=R1<=9;#>\n<R2#float;1<=R2<=4;#>\n<R3#float;15<=R3<=19;#>\n"
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Correctly referencing the field of a structure variable - 500
// Structure.Referencing.Field.Correct

# 500
Structure.Referencing.Field.Correct
?
Structure.Assignment.Field.Correct
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#char#><V2>;
      <T3#real#><V3>;
   };
   <S1><V4>;
   <V4>.<V1> = <R1#1<=R1<=4;#>;   
   >> <V4>.<V3>;
   <T3><V5> = <V4>.<V3> - <V4>.<V1>;
   << <V5>;
}}
>
Input: "<R2#float;5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 501
Structure.Referencing.Field.Correct
?
Structure.Assignment.Field.Correct
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T2#signed#><V2>;
      <T3#bool#><V3>;
   };
   <S1><V4>;
   >> <V4>.<V1>;
   <V4>.<V2> = <R1#-4 <= R1 <= -1;#>;   
   << <V4>.<V1> + <V4>.<V2>;
}}
>
Input: "<R2#float;5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// Two inputs - will it be a problem? - may be not since inputs are back to back
# 502
Structure.Referencing.Field.Correct
?
Structure.Assignment.Field.Correct
>
{
<T0><F0>(){
   <S1>{
      <T1#char#><V1>;
      <T2#signed#><V2>;
      <T3#signed#><V3>;
   };
   <S1><V4>;
   >> <V4>.<V2>;
   >> <V4>.<V3>;
   << <V4>.<V2>;
   << <V4>.<V3>;
}}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 503
Structure.Referencing.Field.Correct
?
Structure.Assignment.Field.Correct
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T2#bool#><V2>;
      <T3#real#><V3>;
   };
   <S1><V4>;
   <V4>.<V1> = <R1#float;1<=R1<=9;#>;
   << <V4>.<V1>;
   <V4>.<V3> = <R2#float;1<=R2<=9;#>;   
   << <V4>.<V3>;
}}
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Referencing the field of a structure variable before initializing it - 525
// Structure.Referencing.Field.Referencing variable before initializing its value

# 525
Structure.Referencing.Field.Referencing variable before initializing its value
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#char#><V2>;
   };
   <S1><V3>;
   <V3>.<V2> = <R1#char;'a'<=R1<='z';#>;   
   << <V3>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

# 526
Structure.Referencing.Field.Referencing variable before initializing its value
>
{
<T0><F0>(){
   <S1>{
      <T1#bool#><V1>;
      <T2#real#><V2>;
   };
   <S1><V3>;
   <V3>.<V1> = true;
   << <V3>.<V2>;
}}
>
Type: debug_output
Hardness: 10 

# 527
Structure.Referencing.Field.Referencing variable before initializing its value
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T1><V2>;
   };
   <S1><V3>;
   >> <V3>.<V1>;
   << <V3>.<V2>;
}}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 528
Structure.Referencing.Field.Referencing variable before initializing its value
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T1><V2>;
   };
   <S1><V3>;
   >> <V3>.<V2>;
   << <V3>.<V1>;
}}
>
Input: "<R1#float;1<=R1<=5;#>\n<R2#float;6<=R2<=9;#>\n<R3#float;11<=R3<=15;#>\n"
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Referencing a field that is not part of a structure variable - 550
// Structure.Referencing.Field.Referencing field that is not part of the structure

# 550
Structure.Referencing.Field.Referencing field that is not part of the structure
>
{
<T0><F0>(){
   <S1>{
      <T1#signed#><V1>;
      <T2#char#><V2>;
      <T3#real#><V3>;
   };
   <S1><V4>;
   <V4>.<V1> = <R1#1<=R1<=4;#>;   
   >> <V4>.<V3>;
   <V4>.<V5> = <R5#char;'A'<=R5<='Z';#>;
   << <V4>.<V3>;
}}
>
Input: "<R2#float;5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 551
Structure.Referencing.Field.Referencing field that is not part of the structure
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T2#signed#><V2>;
      <T3#bool#><V3>;
   };
   <S1><V4>;
   >> <V4>.<V1>;
   <V4>.<V2> = <R1#1 <= R1 <= 4;#>;   
   <V4>.<V5> = <R1>;
   << <V4>.<V1> - <V4>.<V2>;
}}
>
Input: "<R2#float;5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 552
Structure.Referencing.Field.Referencing field that is not part of the structure
>
{
<T0><F0>(){
   <S1>{
      <T1#char#><V1>;
      <T2#signed#><V2>;
      <T3#signed#><V3>;
   };
   <S1><V4>;
   >> <V4>.<V2>;
   >> <V4>.<V3>;
   <V4>.<V5> = <R5#char;'a'<=R5<='z';#>;
   << <V4>.<V2> * <V4>.<V3>;
}}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 553
Structure.Referencing.Field.Referencing field that is not part of the structure
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T2#bool#><V2>;
      <T3#real#><V3>;
   };
   <S1><V4>;
   <V4>.<V1> = <R1#float;1<=R1<=9;#>;
   << <V4>.<V1>;
   <V4>.<V3> = <R2#float;1<=R2<=9;#>;   
   <V4>.<V5> = false;
   << <V4>.<V3>;
}}
>
Type: debug_output
Hardness: 10 

# 554
Structure.Referencing.Field.Referencing field that is not part of the structure
>
{
<T0><F0>(){
   <S1>{
      <T1#char#><V1>;
      <T2#signed#><V2>;
      <T3#signed#><V3>;
   };
   <S1><V4>;
   >> <V4>.<V2>;
   << <V4>.<V2> * <V4>.<V2>;
   <T1><V5> = <R5#char;'a'<=R5<='z';#>;
   << <V4>.<V5>;
}}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 555
Structure.Referencing.Field.Referencing field that is not part of the structure
>
{
<T0><F0>(){
   <S1>{
      <T1#real#><V1>;
      <T2#bool#><V2>;
      <T3#real#><V3>;
   };
   <S1><V4>;
   <V4>.<V1> = <R1#float;1<=R1<=9;#>;
   << <V4>.<V1> * 2;
   <T2><V5> = false;
   << <V4>.<V5>;
}}
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// Testing that values of a caller propagate to a function
// // Structure variable passed as a parameter to a function where it is referenced - 600
// Structure.Parameter.Aggregate.Accessed

# 600
Structure.Parameter.Aggregate.Accessed
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<S1>{
     <T1#signed#><V1>;
     <T2#char#><V2>;
  };
<T0><F1>(<S1><V4>){
   << <V4>.<V1> + 10;
}
<T0><F0>(){
   <S1><V3>;
   >> <V3>.<V1>;
   <F1>(<V3>);
   << <V3>.<V1>;   
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 601
Structure.Parameter.Aggregate.Accessed
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<S1>{
     <T1#bool#><V2>;
     <T2#real#><V1>;
  };
<T0><F1>(<S1><V4>){
   << <V4>.<V1>;
}
<T0><F0>(){
   <S1><V3>;
   <V3>.<V1> = <R1#float;1<=R1<=9;#>;
   <F1>(<V3>);
   << <V3>.<V1>;   
}}
>
Type: debug_output
Hardness: 10 

# 602
Structure.Parameter.Aggregate.Accessed
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<S1>{
     <T1#real#><V1>;
     <T2#char#><V2>;
  };
<T0><F1>(<S1><V4>){
   << <V4>.<V1> + 1;
}
<T0><F0>(){
   <S1><V3>;
   >> <V3>.<V1>;
   << <V3>.<V1>;   
   <F1>(<V3>);
}}
>
Input: "<R1#float;1<=R1<=4;#>\n<R2#float;5<=R2<=9;#>\n<R3#float;11<=R3<=14;#>\n<R4#float;15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 603
Structure.Parameter.Aggregate.Accessed
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<S1>{
     <T1#bool#><V2>;
     <T2#signed#><V1>;
  };
<T0><F1>(<S1><V4>){
   << <V4>.<V1> * 10;
}
<T0><F0>(){
   <S1><V3>;
   <V3>.<V1> = <R1#1<=R1<=9;#>;
   << <V3>.<V1>;   
   <F1>(<V3>);
}}
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// Testing that changes in a function do not propagate back to caller
// // Structure variable passed as a parameter to a function where it is modified - 625
// Structure.Parameter.Aggregate.Modified

# 625
Structure.Parameter.Aggregate.Modified
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<S1>{
     <T1#signed#><V1>;
     <T2#char#><V2>;
  };
<T0><F1>(<S1><V4>){
   <V4>.<V1> = <R2#5<=R2<=9;#>;
   << <V4>.<V1>;
}
<T0><F0>(){
   <S1><V3>;
   >> <V3>.<V1>;
   <F1>(<V3>);
   << <V3>.<V1>;   
}}
>
Input: "<R1#1<=R1<=4;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 626
Structure.Parameter.Aggregate.Modified
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<S1>{
     <T1#bool#><V2>;
     <T2#real#><V1>;
  };
<T0><F1>(<S1><V4>){
   <V4>.<V1> = <R2#float;5<=R2<=9;#>;
   << <V4>.<V1>;
}
<T0><F0>(){
   <S1><V3>;
   <V3>.<V1> = <R1#float;1<=R1<=4;#>;
   <F1>(<V3>);
   << <V3>.<V1>;   
}}
>
Type: debug_output
Hardness: 10 

# 627
Structure.Parameter.Aggregate.Modified
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<S1>{
     <T1#real#><V1>;
     <T2#char#><V2>;
  };
<T0><F1>(<S1><V4>){
   <V4>.<V1> = <R2#float;5<=R2<=9;#>;
   << <V4>.<V1>;
}
<T0><F0>(){
   <S1><V3>;
   >> <V3>.<V1>;
   <F1>(<V3>);
   << <V3>.<V1>;   
}}
>
Input: "<R1#float;1<=R1<=4;#>\n<R3#float;11<=R3<=14;#>\n<R4#float;15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 628
Structure.Parameter.Aggregate.Modified
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<S1>{
     <T1#bool#><V2>;
     <T2#signed#><V1>;
  };
<T0><F1>(<S1><V4>){
   >> <V4>.<V1>;
   << <V4>.<V1>;
}
<T0><F0>(){
   <S1><V3>;
   <V3>.<V1> = <R1#1<=R1<=4;#>;
   <F1>(<V3>);
   << <V3>.<V1>;   
}}
>
Input: "<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Field of a structure variable passed as a parameter to a function - 650
// Structure.Parameter.Field

# 650
Structure.Parameter.Field
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<T0><F1>(<T1#signed#><V4>){
   << <V4> + 10;
   <V4> = <R2#5<=R2<=9;#>;
   << <V4> + 10;
}
<T0><F0>(){
  <S1>{
     <T1><V1>;
     <T2#char#><V2>;
  };
   <S1><V3>;
   >> <V3>.<V1>;
   <F1>(<V3>.<V1>);
   << <V3>.<V1> + 10;   
}}
>
Input: "<R1#1<=R1<=4;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 651
Structure.Parameter.Field
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<T0><F1>(<T2#real#><V4>){
   << <V4>;
   <V4> = <R2#float;5<=R2<=9;#>;
   << <V4>;
}
<T0><F0>(){
  <S1>{
     <T1#bool#><V2>;
     <T2><V1>;
  };
   <S1><V3>;
   <V3>.<V1> = <R1#float;1<=R1<=4;#>;
   <F1>(<V3>.<V1>);
   << <V3>.<V1>;   
}}
>
Type: debug_output
Hardness: 10 

# 652
Structure.Parameter.Field
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<T0><F1>(<T1#real#><V4>){
   << <V4>;
   >> <V4>;
   << <V4>;
}
<T0><F0>(){
  <S1>{
     <T1><V1>;
     <T2#char#><V2>;
  };
   <S1><V3>;
   <V3>.<V1> = <R1#float;1<=R1<=4;#>;
   <V3>.<V2> = <R5#char;'a'<=R5<='z';#>;
   <F1>(<V3>.<V1>);
   << <V3>.<V1>;   
}}
>
Input: "<R2#float;5<=R2<=9;#>\n<R3#float;11<=R3<=14;#>\n<R4#float;15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 653
Structure.Parameter.Field
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<T0><F1>(<T1#signed#><V4>){
   << <V4> * 10;
   <V4> = <R2#5<=R2<=9;#>;
   << <V4> * 10;
}
<T0><F0>(){
  <S1>{
     <T2#bool#><V2>;
     <T1><V1>;
  };
   <S1><V3>;
   <V3>.<V1> = <R1#1<=R1<=4;#>;
   <V3>.<V2> = false;
   <F1>(<V3>.<V1>);
   << <V3>.<V1> * 10;   
}}
>
Type: debug_output
Hardness: 10 

# 655
Structure.Parameter.Field
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<T0><F1>(<T1#signed#><V4>,<T2#real#><V5>){
   << <V4> + 1;
   <V4> = <R2#5<=R2<=9;#>;
   >> <V5>;
   << <V4> - 1;
}
<T0><F0>(){
  <S1>{
     <T1><V1>;
     <T2><V2>;
  };
   <S1><V3>;
   <V3>.<V1> = <R1#1<=R1<=4;#>;
   >> <V3>.<V2>;
   <F1>(<V3>.<V1>,<V3>.<V2>);
   << <V3>.<V1>;   
   << <V3>.<V2>;   
}}
>
Input: "<R3#float;11<=R3<=14;#>\n<R4#float;15<=R4<=19;#>\n<R5#float;21<=R5<=29;#>"
>
Type: debug_output
Hardness: 20 

# 656
Structure.Parameter.Field
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
<T0><F1>(<T1#real#><V4>,<T2#signed#><V5>){
   << <V4>; 
   >> <V5>;
   <V4> = <R2#float;5<=R2<=9;#>;
   << <V5> * 10;
}
<T0><F0>(){
  <S1>{
     <T1><V1>;
     <T2><V2>;
  };
   <S1><V3>;
   <V3>.<V1> = <R1#float;1<=R1<=4;#>;
   <V3>.<V2> = <R3#5<=R3<=9;#>;
   <F1>(<V3>.<V1>,<V3>.<V2>);
   << <V3>.<V1>;   
   << <V3>.<V2>;   
}}
>
Input: "<R4#1<=R4<=4;#>\n<R5#11<=R5<=19;#>"
>
Type: debug_output
Hardness: 20 

// // ---------------------------------------------------------------------------------
// // One is a structure, other a variable corresponding to one of its fields - 675
// Structure.Parameter.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition

# 675
Structure.Parameter.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{
<T0><F1>(<T1#signed#><V4>){
   << <V4> + 10;
   <V4> = <R2#5<=R2<=9;#>;
   << <V4> + 10;
}
<T0><F0>(){
  <S1>{
     <T1><V1>;
     <T2#char#><V2>;
  };
   <S1><V3>;
   >> <V3>.<V1>;
   <F1>(<V3>);
   << <V3>.<V1> + 10;   
}}
>
Input: "<R1#1<=R1<=4;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 676
Structure.Parameter.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{
<S1>{
     <T1#signed#><V1>;
     <T2#char#><V2>;
  };
<T0><F1>(<S1><V4>){
   <V4>.<V1> = <R2#5<=R2<=9;#>;
   << <V4>.<V1>;
}
<T0><F0>(){
   <S1><V3>;
   >> <V3>.<V1>;
   <F1>(<V3>.<V1>);
   << <V3>.<V1>;   
}}
>
Input: "<R1#1<=R1<=4;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 677
Structure.Parameter.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{
<T0><F1>(<T2#real#><V4>){
   << <V4>;
   <V4> = <R2#float;5<=R2<=9;#>;
   << <V4>;
}
<T0><F0>(){
  <S1>{
     <T1#bool#><V2>;
     <T2><V1>;
  };
   <S1><V3>;
   <V3>.<V1> = <R1#float;1<=R1<=4;#>;
   <F1>(<V3>);
   << <V3>.<V1>;   
}}
>
Type: debug_output
Hardness: 10 

# 678
Structure.Parameter.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{
<S1>{
     <T1#bool#><V2>;
     <T2#real#><V1>;
  };
<T0><F1>(<S1><V4>){
   <V4>.<V1> = <R2#float;5<=R2<=9;#>;
   << <V4>.<V1>;
}
<T0><F0>(){
   <S1><V3>;
   <V3>.<V1> = <R1#float;1<=R1<=4;#>;
   <F1>(<V3>.<V1>);
   << <V3>.<V1>;   
}}
>
Type: debug_output
Hardness: 10 

# 679
Structure.Parameter.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{
<T0><F1>(<T1#real#><V4>){
   << <V4>;
   >> <V4>;
   << <V4>;
}
<T0><F0>(){
  <S1>{
     <T1><V1>;
     <T2#char#><V2>;
  };
   <S1><V3>;
   >> <V3>.<V1>;
   <V3>.<V2> = <R5#char;'a'<=R5<='z';#>;
   <F1>(<V3>);
   << <V3>.<V1>;   
}}
>
Input: "<R1#float;1<=R1<=4;#>\n<R2#float;5<=R2<=9;#>\n<R3#float;11<=R3<=14;#>\n<R4#float;15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 680
Structure.Parameter.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{
<S1>{
     <T1#real#><V1>;
     <T2#char#><V2>;
  };
<T0><F1>(<S1><V4>){
   <V4>.<V1> = <R2#float;5<=R2<=9;#>;
   << <V4>.<V1>;
}
<T0><F0>(){
   <S1><V3>;
   >> <V3>.<V1>;
   <F1>(<V3>.<V1>);
   << <V3>.<V1>;   
}}
>
Input: "<R1#float;1<=R1<=4;#>\n<R3#float;11<=R3<=14;#>\n<R4#float;15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 681
Structure.Parameter.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{
<T0><F1>(<T1#signed#><V4>){
   << <V4> * 10;
   <V4> = <R2#5<=R2<=9;#>;
   << <V4> * 10;
}
<T0><F0>(){
  <S1>{
     <T2#bool#><V2>;
     <T1><V1>;
  };
   <S1><V3>;
   <V3>.<V1> = <R1#1<=R1<=4;#>;
   <V3>.<V2> = false;
   <F1>(<V3>);
   << <V3>.<V1> * 10;   
}}
>
Type: debug_output
Hardness: 10 

# 682
Structure.Parameter.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{
<S1>{
     <T1#bool#><V2>;
     <T2#signed#><V1>;
  };
<T0><F1>(<S1><V4>){
   >> <V4>.<V1>;
   << <V4>.<V1>;
}
<T0><F0>(){
   <S1><V3>;
   <V3>.<V1> = <R1#1<=R1<=4;#>;
   <F1>(<V3>.<V1>);
   << <V3>.<V1>;   
}}
>
Input: "<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Entire structure is returned by a function - 700
// Structure.Returned

# 700
Structure.Returned
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
 <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
   };
<S1><F1>(){
   <S1><V4>;
   >> <V4>.<V1>;
   >> <V4>.<V2>;
   return <V4>;
}
<T0><F0>(){
   <S1><V3> = <F1>();
   << <V3>.<V1>;
   << <V3>.<V2>;   
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#float;5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#float;15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 701
Structure.Returned
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
 <S1>{
      <T1#real#><V2>;
      <T2#signed#><V1>;
   };
<S1><F1>(){
   <S1><V4>;
   <V4>.<V2> = <R2#float;5<=R2<=9;#>;
   <V4>.<V1> = <R1#1<=R1<=4;#>;
   return <V4>;
}
<T0><F0>(){
   <S1><V3> = <F1>();
   << <V3>.<V2>;   
   << <V3>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

# 702
Structure.Returned
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
 <S1>{
      <T1#signed#><V1>;
      <T3#char#> <V5>;
      <T2#real#><V2>;
   };
<S1><F1>(){
   <S1><V4>;
   >> <V4>.<V1>;
   <V4>.<V2> = <R2#float;5<=R2<=9;#>;
   <V4>.<V5> = <R4#char;'a'<=R4<='z';#>;
   return <V4>;
}
<T0><F0>(){
   <S1><V3> = <F1>();
   << <V3>.<V1>;
   << <V3>.<V2>;   
}}
>
Input: "<R1#1<=R1<=4;#>\n<R3#11<=R3<=14;#>\n"
>
Type: debug_output
Hardness: 10 

# 703
Structure.Returned
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct}
>
{
 <S1>{
      <T1#real#><V1>;
      <T2#bool#> <V5>;
      <T3#signed#><V2>;
   };
<S1><F1>(){
   <S1><V4>;
   <V4>.<V2> = <R4#1<=R4<=9;#>;
   <V4>.<V5> = true;
   >> <V4>.<V1>;
   return <V4>;
}
<T0><F0>(){
   <S1><V3> = <F1>();
   << <V3>.<V2>;   
   << <V3>.<V1>;
}}
>
Input: "<R1#float;1<=R1<=9;#>\n<R2#float;11<=R2<=19;#>\n"
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Declaring variable of nested structure - 800
// Structure.Nested.Declaring variable of nested structure

# 800
Structure.Nested.Declaring variable of nested structure
>
{
 <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
      <S2>{
        <T1><V3>;
        <T3#char#><V4>;
      } <V5>;
   };
<T0><F0>(){
   <S1><V6>;
   >> <V6>.<V1>;
   <S2><V7>;
   << <V6>.<V1> * 2;   

}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 801
Structure.Nested.Declaring variable of nested structure
>
{
 <S1>{
      <T1#real#><V1>;
      <T2#signed#><V2>;
      <S2>{
        <T1><V3>;
        <T3#bool#><V4>;
      } <V5>;
   };
<T0><F0>(){
   <S1><V6>;
   <S2><V7>;
   >> <V6>.<V1>;
   << <V6>.<V1> * 10;   

}}
>
Input: "<R1#float;1<=R1<=4;#>\n<R2#float;5<=R2<=9;#>\n<R3#float;11<=R3<=14;#>\n<R4#float;15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 802
Structure.Nested.Declaring variable of nested structure
>
{
 <S1>{
      <T1#signed#><V1>;
      <S2>{
        <T2#char#><V2>;
        <T3#bool#><V3>;
      } <V4>;
      <T4#real#><V5>;
   };
<T0><F0>(){
   <S1><V6>;
   >> <V6>.<V1>;
   <S2><V7>;
   >> <V6>.<V5>;
   << <V6>.<V5> - <V6>.<V1>;   

}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#float;5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#float;15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 803
Structure.Nested.Declaring variable of nested structure
>
{
 <S1>{
      <T1#real#><V1>;
      <S2>{
        <T2#bool#><V2>;
        <T3#char#><V3>;
      } <V4>;
      <T4#signed#><V5>;
   };
<T0><F0>(){
   <S1><V6>;
   <S2><V7>;
   >> <V6>.<V1>;
   << <V6>.<V1>;   
   >> <V6>.<V5>;
   << <V6>.<V5>;
}}
>
Input: "<R1#float;1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#float;11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Assigning to nested field - 825
// Structure.Nested.Assigning to nested field

# 825
Structure.Nested.Assigning to nested field
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct,Nested.Referencing nested field}
>
{
 <S1>{
      <T1#signed#><V1>;
      <T2#real#><V2>;
      <S2>{
        <T1><V3>;
        <T3#char#><V4>;
      } <V5>;
   };
<T0><F0>(){
   <S1><V6>;
   >> <V6>.<V5>.<V3>;
   >> <V6>.<V1>;
   << <V6>.<V5>.<V3> * 2;

}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 826
Structure.Nested.Assigning to nested field
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct,Nested.Referencing nested field}
>
{
 <S1>{
      <T1#real#><V1>;
      <T2#signed#><V2>;
      <S2>{
        <T1><V3>;
        <T3#bool#><V4>;
      } <V5>;
   };
<T0><F0>(){
   <S1><V6>;
   >> <V6>.<V5>.<V3>;
   >> <V6>.<V1>;
   << <V6>.<V5>.<V3> + 1;
}}
>
Input: "<R1#float;1<=R1<=4;#>\n<R2#float;5<=R2<=9;#>\n<R3#float;11<=R3<=14;#>\n<R4#float;15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 827
Structure.Nested.Assigning to nested field
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct,Nested.Referencing nested field}
>
{
 <S1>{
      <T1#bool#><V1>;
      <S2>{
        <T2#char#><V2>;
        <T3#signed#><V3>;
      } <V4>;
      <T4#real#><V5>;
   };
<T0><F0>(){
   <S1><V6>;
   >> <V6>.<V4>.<V3>;
   <V6>.<V1> = true;
   <V6>.<V5> = <R2#float;5<=R2<=9;#>;
   << <V6>.<V4>.<V3> * 10;
}}
>
Input: "<R1#1<=R1<=4;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 828
Structure.Nested.Assigning to nested field
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct,Nested.Referencing nested field}
>
{
 <S1>{
      <T1#signed#><V1>;
      <S2>{
        <T2#real#><V2>;
        <T3#bool#><V3>;
      } <V4>;
      <T4#char#><V5>;
   };
<T0><F0>(){
   <S1><V6>;
   >> <V6>.<V4>.<V2>;
   <V6>.<V1> = <R2#5<=R2<=9;#>;
   << <V6>.<V4>.<V2>;
   <V6>.<V5> = <R4#char;'A'<=R4<='Z';#>;
}}
>
Input: "<R1#float;1<=R1<=4;#>\n<R3#float;5<=R3<=9;#>\n"
>
Type: debug_output
Hardness: 10 

// // ---------------------------------------------------------------------------------
// // Referencing nested field - 850
// Structure.Nested.Referencing nested field

# 850
Structure.Nested.Referencing to nested field
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct,Nested.Assigning to nested field}
>
{
 <S1>{
      <T1#signed#><V1>;
      <T2#char#><V2>;
      <S2>{
        <T1><V3>;
        <T3#real#><V4>;
      } <V5>;
   };
<T0><F0>(){
   <S1><V6>;
   <V6>.<V1> = <R1#1<=R1<=4;#>;
   <V6>.<V5>.<V3> = <R2#5<=R2<=9;#>;
   <V6>.<V2> = <R3#char;'a'<=R3<='z';#>;
   << <V6>.<V5>.<V3> - 5;
}}
>
Type: debug_output
Hardness: 10 

# 851
Structure.Nested.Referencing to nested field
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct,Nested.Assigning to nested field}
>
{
 <S1>{
      <T1#real#><V1>;
      <S2>{
        <T3#signed#><V4>;
        <T1><V3>;
      } <V5>;
      <T2#bool#><V2>;
   };
<T0><F0>(){
   <S1><V6>;
   <V6>.<V5>.<V4> = <R1#1<=R1<=4;#>;
   <V6>.<V1> = <R2#float;5<=R2<=9;#>;
   <V6>.<V2> = false;
   << <V6>.<V5>.<V4> * 2;
   >> <V6>.<V5>.<V3>;
}}
>
Input: "<R3#float;11<=R3<=14;#>\n<R4#float;15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 852
Structure.Nested.Referencing to nested field
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct,Nested.Assigning to nested field}
>
{
 <S1>{
      <T1#bool#><V1>;
      <S2>{
        <T2#char#><V2>;
        <T3#real#><V3>;
      } <V4>;
      <T4#signed#><V5>;
   };
<T0><F0>(){
   <S1><V6>;
   <V6>.<V4>.<V3> = <R2#float;5<=R2<=9;#>;
   <V6>.<V1> = true;
   >> <V6>.<V5>;
   << <V6>.<V4>.<V3>;
   >> <V6>.<V5>;
}}
>
Input: "<R1#1<=R1<=4;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 853
Structure.Nested.Referencing to nested field
?
Structure.{Assignment.Field.Correct,Referencing.Field.Correct,Nested.Assigning to nested field}
>
{
 <S1>{
      <T1#signed#><V1>;
      <T4#bool#><V5>;
      <S2>{
        <T2#real#><V2>;
        <T3#char#><V3>;
      } <V4>;
   };
<T0><F0>(){
   <S1><V6>;
   >> <V6>.<V4>.<V2>;
   >> <V6>.<V1>;
   <V6>.<V5> = false;
   >> <V6>.<V1>;
   << <V6>.<V4>.<V2> + 1;
   <V6>.<V4>.<V3> = <R4#char;'a'<=R4<='z';#>;
}}
>
Input: "<R1#float;1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#1<=R3<=4;#>\n"
>
Type: debug_output
Hardness: 10 

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