// In multi-step loops, does not handle condition parameter correctly
// Does not yet handle assignment operators
// What about () in student code? actual template?

// Use this file to test new templates

// *********************For Loop*********************************************

// Only the loop parameters, upcounting, by 1
# 100
Program.Control.Sequence.Compound Statement
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = ^Initialization Value^<R1#1<=R1<=5;#>^;<V1> < ^Comparison Value^<R2#integer;6<=R2<=9;#>^;<V1> = <V1> + ^Update Value^1^){<<<V1>;}}}
>
Type: cloze
Hardness: 20

// PROBLEM: STUDENTS CAN ENTER ANY OF SEVERAL VALUES FOR CONDITION - SO GRADING HAS TO BE SMARTER
// Only the loop parameters, upcounting, by many
# 101
Program.Control.Sequence.Compound Statement
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = ^Initialization Value^<R1#1<=R1<=5;#>^;<V1> < ^Comparison Value^<R2#integer;11<=R2<=19;#>^;<V1> = <V1> + ^Update Value^<R3#1<=R3<=4;#>^){<<<V1>;}}}
>
Type: cloze
Hardness: 20

// Only the loop parameters, downcounting, by 1
# 102
Program.Control.Sequence.Compound Statement
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = ^Initialization Value^<R1#6<=R1<=9;#>^;<V1> > ^Comparison Value^<R2#integer;1<=R2<=5;#>^;<V1> = <V1> - ^Update Value^1^){<<<V1>;}}}
>
Type: cloze
Hardness: 20

// Only the loop parameters, downcounting, by many
# 103
Program.Control.Sequence.Compound Statement
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = ^Initialization Value^<R1#11<=R1<=19;#>^;<V1> >= ^Comparison Value^<R2#integer;1<=R2<=5;#>^;<V1> = <V1> - ^Update Value^<R3#1<=R3<=4;#>^){<<<V1>;}}}
>
Type: cloze
Hardness: 20



// Entire loop header statements, upcounting, by 1
# 105
Program.Control.Sequence.Compound Statement
>
{<T0><F0>(){<T1#integer#><V1>;for(^Initialize <V1> to <R1>^<V1> = <R1#1<=R1<=5;#>^;^Condition^<V1> < <R2#integer;6<=R2<=9;#>^;^Update <V1>^<V1> = <V1> + 1^){<<<V1>;}}}
>
Type: cloze
Hardness: 40

// Entire loop header statements, upcounting, by many
# 106
Program.Control.Sequence.Compound Statement
>
{<T0><F0>(){<T1#integer#><V1>;for(^Initialize <V1> to <R1>^<V1> = <R1#1<=R1<=5;#>^;^Condition^<V1> < <R2#integer;11<=R2<=19;#>^;^Update <V1>^<V1> = <V1> + <R3#1<=R3<=4;#>^){<<<V1>;}}}
>
Type: cloze
Hardness: 40

// Entire loop header statements, downcounting, by 1
# 107
Program.Control.Sequence.Compound Statement
>
{<T0><F0>(){<T1#integer#><V1>;for(^Initialize <V1> to <R1>^<V1> = <R1#6<=R1<=9;#>^;^Condition^<V1> > <R2#integer;1<=R2<=5;#>^;^Update <V1>^<V1> = <V1> - 1^){<<<V1>;}}}
>
Type: cloze
Hardness: 40

// Entire loop header statements, downcounting, by many
# 108
Program.Control.Sequence.Compound Statement
>
{<T0><F0>(){<T1#integer#><V1>;for(^Initialize <V1> to <R1>^<V1> = <R1#11<=R1<=19;#>^;^Condition^<V1> > <R2#integer;1<=R2<=5;#>^;^Update <V1>^<V1> = <V1> - <R3#1<=R3<=4;#>^){<<<V1>;}}}
>
Type: cloze
Hardness: 40

# 109
Program.Control.Sequence.Compound Statement
>
{<T0><F0>(){<T1#integer#><V1>;^Write control^for^(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: cloze
Hardness: 20

// ****************************Variables****************************************************

// Declaration type
# 110
Program.Control.Sequence.Simple Statement
>
{<T0><F0>(){^Declare <V1> of type <T1>^<T1#integer#>^<V1>;<V1> = <R1#1<=R1<=5;#>;<<<V1>;}}
>
Type: cloze
Hardness: 10

// Declaration statement
# 111
Program.Control.Sequence.Simple Statement
>
{<T0><F0>(){^Declare <V1> of type <T1>^<T1#integer#><V1>;^^Declare <V2> of type <T1>^<T1#integer#><V2>;^<V1> = <R1#1<=R1<=5;#>;<<<V1>;}}
>
Type: cloze
Hardness: 10

// Initialization value
# 112
Program.Control.Sequence.Simple Statement
>
{<T0><F0>(){<T1#integer#><V1>=^Initialization Value^<R1#1<=R1<=5;#>^;<<<V1>;}}
>
Type: cloze
Hardness: 10

// Initialization statement
# 113
Program.Control.Sequence.Simple Statement
>
{<T0><F0>(){^Declare <V1> of type <T1> and initialize it to <R1>^<T1#integer#><V1>=<R1#1<=R1<=5;#>;^<<<V1>;}}
>
Type: cloze
Hardness: 10

// Assignment Value
# 114
Program.Control.Sequence.Simple Statement
>
{<T0><F0>(){<T1#integer#><V1>;<V1> = ^Assignment Value^<R1#1<=R1<=5;#>^;<<<V1>;}}
>
Type: cloze
Hardness: 10

// Assignment Statement
# 115
Program.Control.Sequence.Simple Statement
>
{<T0><F0>(){<T1#integer#><V1>;^Assign <R1> to <V1>^<V1> = <R1#1<=R1<=5;#>;^<<<V1>;}}
>
Type: cloze
Hardness: 10

// Declaration + Assignment Statement
# 116
Program.Control.Sequence.Simple Statement
>
{<T0><F0>(){^Declare <V1> of type <T1>^<T1#integer#><V1>;^^Assign <R1> to <V1>^<V1> = <R1#1<=R1<=5;#>;^<<<V1>;}}
>
Type: cloze
Hardness: 10

// Declaration + Assignment Statement
# 117
Program.Control.Sequence.Simple Statement
>
{<T0><F0>(){^Declare <V1> of type <T1>^<T1#integer#><V1>;^^Assign <R1> to <V1>^<V1> = <R1#1<=R1<=5;#>;^<<<V1>;^Increment <V1>^<V1> = <V1> + 1;^<<<V1>;}}
>
Type: cloze
Hardness: 10

// Declaration + Assignment Statement
# 118
Program.Control.Sequence.Simple Statement
>
{<T0><F0>(){^Declare <V1> of type <T1>^<T1#integer#><V1>;^^Assign <R1> to <V1>^<V1> = <R1#1<=R1<=5;#>;^<<<V1>;^Double value of <V1>^<V1> = <V1> + <V1>;^<<<V1>;}}
>
Type: cloze
Hardness: 10


// Combination of variables - expressions
# 120
Program.Control.Sequence.Simple Statement
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#6<=R2<=9;#>;<T1><V3>;<V3> = ^Sum of <V1> and <V2>^<V1> + <V2>^;<<<V3>;}}
>
Type: cloze
Hardness: 20

// Combination of variables - expressions
# 121
Program.Control.Sequence.Simple Statement
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#6<=R2<=9;#>;<T1><V3>;<V3> = ^Product of <V1> and <V2>^<V1> * <V2>^;<<<V3>;}}
>
Type: cloze
Hardness: 20

// Combination of variables - expressions
# 122
Program.Control.Sequence.Simple Statement
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#6<=R2<=9;#>;<T1><V3>;<V3> = ^Remainder of dividing <V1> by <V2>^<V1> % <V2>^;<<<V3>;}}
>
Type: cloze
Hardness: 20


// Combination of variables - expressions
# 123
Program.Control.Sequence.Simple Statement
>
{<T0><F0>(){^Declare <V1> of type <T1>^<T1#integer#><V1>;^^Declare <V2> of type <T1>^<T1><V2>;^^Input <V1>^>> <V1>;^
^Assign <V1> * <V1> to <V2>^<V2> = <V1> * <V1>;^^Print <V2>^<< <V2>;^}}
>
Type: cloze
Hardness: 20


// Combination of variables - expressions
# 500
Program.Control.Selection.ifElse.Condition.Relational.true
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R2#6<=R2<=9;#>;<T1><V3>;if( <V1> < <V2> ) { << <V1>; <V3> = <V1>; << <V2>; } else { << <V1>; <V3> = <V2>; << <V2>; } << <V3>; }}
>
Type: refactor
Hardness: 20


// Testing variable name recommendations
# 897
Program.Control.Sequence.Simple Statement
>
{/* Define main function */<T0><F0>(){
/* [1] Statement: Declare Purpose: income Type: real */^^<T1#float#><V1>;^
/* [2] Statement: Declare Purpose: days Type: whole number */^^<T2#integer#><V2>;^
/* [3] Statement: Declare Purpose: expenses Type: real */^^<T1><V3>;^
/* [4] Statement: Declare Purpose: age of insured Type: whole number */^^<T2><V4>;^
/* [5] Statement: Declare Purpose: interest rate Type: real */^^<T1><V5>;^
/* [6] Statement: Declare Purpose: minimum limit Type: whole number */^^<T2><V6>;^
}}
>
Type: code
Hardness: 20

// THIS DOES NOT WORK - VARIABLES DECLARED AS PART OF THE PROGRAM SHOW  UP AS UNKNOWN! in FEEDBACK
//   BECAUSE STUDENTSYMBOLTABLE IS NOT AWARE OF THEM
// Testing feedback provided by expressions
# 898
Program.Control.Sequence.Simple Statement
>
{/* Define main function */<T0><F0>(){
<T1#float#><V1#first,operand1,leftOp#>;
<T1><V2#second,operand2,rightOp#>;
<T1><V3#result,quantity#>;
<< "Enter first operand";
>> <V1>;
<< "Enter second operand";
>> <V2>;
/* [1] Statement: Compute Purpose: result BasedOn: sum of the two operands */^^<V3> = <V1> + <V2>;^
<< <V3>;
/* [2] Statement: Compute Purpose: result BasedOn: difference of the two operands */^^<V3> = <V1> - <V2>;^
<< <V3>;
/* [3] Statement: Compute Purpose: result BasedOn: product of the two operands */^^<V3> = <V1> * <V2>;^
<< <V3>;
/* [4] Statement: Compute Purpose: result BasedOn: division of the two operands */^^<V3> = <V1> / <V2>;^
<< <V3>;
/* [5] Statement: Compute Purpose: result BasedOn: remainder of the two operands */^^<V3> = <V1> % <V2>;^
<< <V3>;
}}
>
Type: code
Hardness: 20

// Testing feedback provided by expressions
# 899
Program.Control.Sequence.Simple Statement
>
{/* Define main function */<T0><F0>(){
/* [1] Statement: Declare Purpose: first operand Name: <V1> Type: whole number */^^<T1#integer#><V1#first,operand1,leftOp#>;^
/* [2] Statement: Declare Purpose: second operand Name: <V2> Type: whole number */^^<T1><V2#second,operand2,rightOp#>;^
/* [3] Statement: Declare Purpose: result Name: <V3> Type: whole number */^^<T1><V3#result#>;^
<< "Enter first operand";
>> <V1>;
<< "Enter second operand";
>> <V2>;
/* [4] Statement: Compute Purpose: result BasedOn: sum of the two operands */^^<V3> = <V1> + <V3> * <V2>;^
<< <V3>;
/* [5] Statement: Compute Purpose: result BasedOn: difference of the two operands */^^<V3> = <V1> - <V2> * <V3>;^
<< <V3>;
/* [6] Statement: Compute Purpose: result BasedOn: product of the two operands */^^<V3> = <V1> * <V2>;^
<< <V3>;
/* [7] Statement: Compute Purpose: result BasedOn: division of the two operands */^^<V3> = <V1> / <V2>;^
<< <V3>;
/* [8] Statement: Compute Purpose: result BasedOn: remainder of the two operands */^^<V3> = <V1> % <V2>;^
<< <V3>;
}}
>
Type: code
Hardness: 20


// ---------------------------Subtraction-------------------------------------------
// Calculate balance of income - expenses
# 900
Program.Control.Sequence.Simple Statement
>
{/* Define main function */<T0><F0>(){
/* [1] Statement: Declare Purpose: income Name: <V1> Type: real */^^<T1#float#><V1#income,pay,earnings#>;^
/* [4] Statement: Declare Purpose: expenses Name: <V2> Type: real */^^<T1><V2#expenses,costs,charges#>;^
/* [7] Statement: Declare Purpose: balance Name: <V3> Type: real */^^<T1><V3#balance,savings,result#>;^

/* [2-1] Statement: Prompt Purpose: income Format: Enter income */^^<< "Enter income";^
/* [3-2] Statement: Input Purpose: income */^^>> <V1>;^

/* [5-4] Statement: Prompt Purpose: expenses Format: Enter expenses */^^<< "Enter expenses";^
/* [6-5] Statement: Input Purpose: expenses */^^>> <V2>;^

/* [8-3,6,7] Statement: Compute Purpose: balance BasedOn: difference of income and expenses */^^<V3> = <V1> - <V2>;^
/* [9-8] Statement: Output Purpose: balance */^^<< <V3>;^
}}
>
Type: code
Hardness: 20



// ---------------------------Multiplication-------------------------------------------
// Calculate the interest on a loan
# 925
Program.Control.Sequence.Simple Statement
>
{/* Define main function */<T0><F0>(){
/* [1] Statement: Declare Purpose: principal Name: <V1> Type: real */^^<T1#float#><V1#principal,amount,loan#>;^
/* [4] Statement: Declare Purpose: interest rate Name: <V2> Type: real */^^<T1><V2#rate,percent#>;^
/* [7] Statement: Declare Purpose: interest Name: <V3> Type: real */^^<T1><V3#interest,result,payment#>;^

/* [2-1] Statement: Prompt Purpose: principal Format: Enter principal */^^<< "Enter principal";^
/* [3-2] Statement: Input Purpose: principal */^^>> <V1>;^

/* [5-4] Statement: Prompt Purpose: interest rate Format: Enter interest rate */^^<< "Enter interest rate";^
/* [6-5] Statement: Input Purpose: interest rate */^^>> <V2>;^

/* [8-3,6,7] Statement: Compute Purpose: interest BasedOn: product of principal and interest rate */^^<V3> = <V1> * <V2>;^
/* [9-8] Statement: Output Purpose: interest */^^<< <V3>;^
}}
>
Type: code
Hardness: 20

// Input hourly rate, number of hours, compute total pay
# 926
Program.Control.Sequence.Simple Statement
>
{/* Define main function */<T0><F0>(){
/* [1] Statement: Declare Purpose: hourly rate Name: <V1> Type: real */^^<T1#float#><V1#rate,hourlyPay,payrate#>;^
/* [4] Statement: Declare Purpose: number of hours Name: <V2> Type: real */^^<T1><V2#hours,numHours,timeSpent#>;^
/* [7] Statement: Declare Purpose: total pay Name: <V3> Type: real */^^<T1><V3#pay,total,amount#>;^

/* [2] Statement: Prompt Purpose: hourly rate Format: Enter hourly rate */^^<< "Enter hourly rate";^
/* [3-2,1] Statement: Input Purpose: hourly rate */^^>> <V1>;^

/* [5] Statement: Prompt Purpose: number of hours Format: Enter number of hours */^^<< "Enter number of hours";^
/* [6-5,4] Statement: Input Purpose: number of hours */^^>> <V2>;^

/* [8-3,6,7] Statement: Compute Purpose: total pay BasedOn: product of hourly rate and number of hours */^^<V3> = <V1> * <V2>;^
/* [9-8] Statement: Output Purpose: total pay */^^<< <V3>;^
}}
>
Type: code
Hardness: 20

// Calculate volume of cube of length, width and height - all ints
# 927
Program.Control.Sequence.Simple Statement
>
{/* Define main function */<T0><F0>(){
/* [1] Statement: Declare Purpose: length Name: <V1> Type: whole number */^^<T1#integer#><V1#length,lsize#>;^
/* [4] Statement: Declare Purpose: width Name: <V2> Type: whole number */^^<T1><V2#width,wsize#>;^
/* [7] Statement: Declare Purpose: height Name: <V3> Type: whole number */^^<T1><V3#height,hsize#>;^
/* [10] Statement: Declare Purpose: volume Name: <V4> Type: whole number */^^<T1><V4#volume,result#>;^

/* [2-1] Statement: Prompt Purpose: length Format: Enter length */^^<< "Enter length";^
/* [3-2] Statement: Input Purpose: length */^^>> <V1>;^

/* [5-4] Statement: Prompt Purpose: width Format: Enter width */^^<< "Enter width";^
/* [6-5] Statement: Input Purpose: width */^^>> <V2>;^

/* [8-7] Statement: Prompt Purpose: height Format: Enter height */^^<< "Enter height";^
/* [9-8] Statement: Input Purpose: height */^^>> <V3>;^

/* [11-3,6,9,10] Statement: Compute Purpose: volume BasedOn: product of length, width and height */^^<V4> = <V1> * <V2> * <V3>;^
/* [12-11] Statement: Output Purpose: volume */^^<< <V4>;^
}}
>
Type: code
Hardness: 20



// ---------------------------Division-------------------------------------------

// Calculate the shares bought
# 925
Program.Control.Sequence.Simple Statement
>
{/* Define main function */<T0><F0>(){
/* [1] Statement: Declare Purpose: investment Name: <V1> Type: real */^^<T1#float#><V1#money,invest,amount#>;^
/* [4] Statement: Declare Purpose: share price Name: <V2> Type: real */^^<T1><V2#price,perShare,cost#>;^
/* [7] Statement: Declare Purpose: number of shares Name: <V3> Type: real */^^<T1><V3#shares,number,result#>;^

/* [2-1] Statement: Prompt Purpose: investment Format: Enter investment */^^<< "Enter investment";^
/* [3-2] Statement: Input Purpose: investment */^^>> <V1>;^

/* [5-4] Statement: Prompt Purpose: share price Format: Enter price per share */^^<< "Enter price per share";^
/* [6-5] Statement: Input Purpose: share price */^^>> <V2>;^

/* [8-3,6,7] Statement: Compute Purpose: number of shares BasedOn: dividing investment by share price */^^<V3> = <V1> / <V2>;^
/* [9-8] Statement: Output Purpose: number of shares */^^<< <V3>;^
}}
>
Type: code
Hardness: 20





// ---------------------------Remainder-------------------------------------------

// NEED A WAY TO SAY CHANGE = CHANGE % 25 CAN ALSO BE WRITTEN AS CHANGE = CHANGE - NUMQUARTERS * 25
// Number of quarters, dimes, nickels and pennies in change
# 902
Program.Control.Sequence.Simple Statement
>
{/* Define main function */<T0><F0>(){
/* [1] Statement: Declare Purpose: change Type: whole number */^^<T1#integer#><V1>;^
/* [4] Statement: Declare Purpose: number of quarters Type: whole number */^^<T1><V2>;^
/* [7] Statement: Declare Purpose: number of dimes Type: whole number */^^<T1><V3>;^
/* [10] Statement: Declare Purpose: number of nickels Type: whole number */^^<T1><V4>;^
/* [12] Statement: Declare Purpose: number of pennies Type: whole number */^^<T1><V5>;^
/* [14] Statement: Declare Purpose: copy of change Type: whole number */^^<T1><V6>;^

/* [2] Statement: Prompt Purpose: change */^^<< "Enter change";^
/* [3-2,1] Statement: Input Purpose: change */^^>> <V1>;^

/* [15-14] Statement: Compute Purpose: copy of change BasedOn: change */^^<V6> = <V1>;^
/* [5-4,3] Statement: Compute Purpose: number of quarters BasedOn: number of times 25 divides change */^^<V2> = <V1> / 25;^
/* [6-5] Statement: Compute Purpose: remaining change BasedOn: remainder after 25 divides change */^^<V1> = <V1> % 25;^

/* [8-7,6] Statement: Compute Purpose: number of dimes BasedOn: number of times 10 divides change */^^<V3> = <V1> / 10;^
/* [9-8] Statement: Compute Purpose: remaining change BasedOn: remainder after 10 divides change */^^<V1> = <V1> % 10;^

/* [11-10,9] Statement: Compute Purpose: number of nickels BasedOn: number of times 5 divides change */^^<V4> = <V1> / 5;^
/* [13-12,11] Statement: Compute Purpose: number of pennies BasedOn: remainder after 5 divides change */^^<V5> = <V1> % 5;^

/* [16-15] Statement: Output Purpose: copy of change Format: c cents = */^^<< <V6> << "cents =";^
/* [17-16,13] Statement: Output Purpose: number of quarters Format: q quarters */^^<< <V2> << "quarters";^
/* [18-16,13] Statement: Output Purpose: number of dimes Format: d dimes */^^<< <V3> << "dimes";^
/* [19-16,13] Statement: Output Purpose: number of nickels Format: n nickels */^^<< <V4> << "nickels";^
/* [20-16,13] Statement: Output Purpose: number of pennies Format: p pennies */^^<< <V5> << "pennies";^
}}
>
Type: code
Hardness: 20




// ---------------------------Parentheses-------------------------------------------

// NOT SURE OF PARENTHESES GRADING YET
// Calculate average temperature given min and max
# 901
Program.Control.Sequence.Simple Statement
>
{/* Define main function */<T0><F0>(){
/* [1] Statement: Declare Purpose: minimum temperature Type: whole number */^^<T1#integer#><V1>;^
/* [4] Statement: Declare Purpose: maximum temperature Type: whole number */^^<T1><V2>;^
/* [7] Statement: Declare Purpose: average temperature Type: real */^^<T2#float#><V3>;^
/* [2] Statement: Prompt Purpose: minimum temperature */^^<< "Enter minimum temperature";^
/* [3-2,1] Statement: Input Purpose: minimum temperature */^^>> <V1>;^
/* [5] Statement: Prompt Purpose: maximum temperature */^^<< "Enter maximum temperature";^
/* [6-5,4] Statement: Input Purpose: maximum temperature */^^>> <V2>;^
/* [8-3,6,7] Statement: Compute Purpose: average temperature BasedOn: sum of minimum temperature and maximum temperature divided by 2 */^^<V3> = (<V1> + <V2>) / 2;^
/* [9-8] Statement: Output Purpose: average temperature */^^<< <V3>;^
}}
>
Type: code
Hardness: 20






// /* [4] Statement: Declare Purpose: interest rate Type: real Value: <R2> */^^<T1><V2>;^
// /* If interest is more than 100, print 'expensive', else 'cheap' */if( ^[9.1]Condition^ <V3> > 100^ ){ ^[9.2]^<< <V1>;^}else{^[9.3]^<< <V2>;^}




// Template for testing only
# 999
Program.Control.Sequence.Simple Statement
>
{/* Define main function */<T0><F0>(){
/* [1] Statement: Declare Purpose: quantity Type: whole number Value: <R1> */^^<T1#integer#><V1> = <R1#1<=R1<=5;#>;^
/* [2] Statement: Declare Purpose: quantity Type: whole number Value: <R2> */^^<T1><V2> = <R2#1<=R2<=5;#>;^
/* [3-1,2] Statement: Compute Purpose: increment quantity */^^<V1> = <V1> + 1;^
/* [4-3] Statement: Output Purpose: quantity */^^<< <V1>;^
}}
>
Type: code
Hardness: 20


// // To test character data type - IT WORKS!!
// # 903
// Program.Control.Sequence.Simple Statement
// ?
// Program.Control.Sequence.Simple Statement
// >
// "It reads numerical grade, converts it to letter grade (90 and up is A, 80-89 is B, 70-79 is D, 55-69 is D and F otherwise) and prints it."
// {<T0><F0>(){
// /* Declare <V1> */
// <T1#integer#><V1#numGrade,number,gradeNumber#>;
// /* Declare <V2> */
// <T2#char#><V2#letterGrade,letter,gradeLetter#>;
// /* Read <V1> */
// <V1> = <R1#45<=R1<=99;#>;
// /* Compute <V2> based on <V1> */
// if(<V1> >= 90){<V2> = 'A';}else{if(<V1> >= 80){<V2> = 'B';}else{if(<V1> >= 70){<V2> = 'C';}else{if(<V1> >= 55){<V2> = 'D';}else{<V2> = 'F';}}} }
// /* Print <V2> */
// << <V2>;
// }
// >
// Type: output
// Hardness: 20