CodeGraderBench/CodeGraderBench huggingface dataset:
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>
int gcd(int n,int m){
	while (m%n!=0){
		int remainder=m%n;
		m=n;
		n=remainder;
	}
	return n;
}
int lcm(int m,int n){
	return m*n/gcd(m,n);
}
main_program{
	int a,b;
	cin>>a>>b;
	cout<<lcm(a,b)<<endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int gcd
(int m,int n){
	while(m%n!=0)
	{		int r=m%n;
	m=n;
	n=r;
}
return n;
}
int lcm
(int m, int n)
{ return (m*n)/gcd(m,n);
}
int main(){
	int A,B;
	cin>>A>>B;
	cout<<lcm(A,B)<<endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
main_program{
	int p,q,x,y,i,j;
	cin>>x>>y;
while(x*i=y*j){
	int i=1;j=1;
	x*i=p;
	y*j=q;
	i++;
	j++;}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int lcm(int a,int b){
	if(a%b==0){
		cout<<a;
	}
	else if(b%a==0){
		cout<<b;
	}
	else if(a%2==1 && b%2==1){
		cout<<a*b;
	}
	else if(a%2==0 && b%2==1 &&( a%b!=0 || b%a!=0)){
		cout<<((a*b)/abs(b-a));
	}
	else if(b%2==0 && a%2==1 &&( b%a!=0 || a%b!=0)){
		cout<<((a*b)/abs(b-a));
	}

	return lcm(a,b);
}
main_program{
	int a,b;
	cin>>a>>b;
	cout<<lcm(a,b)<<endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>

unsigned int lcm (int A, int B){
	// we find hcfand do lcm = A*B/hcf
	int r, Atemp, Btemp;
	Atemp = A;
	Btemp = B;
	while (A % B > 0){
		r = A%B;
		A = B;
		B = r;
	}	
	return (Atemp * Btemp)/B;
}

main_program{
	int a, b;
	cin >> a >> b;
	if (a >= b) cout << lcm(a, b);
	else cout << lcm(b, a);
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>
main_program {
	int a, b; cin >> a >> b;
	}
int gcd ( int m, int n) {
	while ( m % n != 0) {
		int remainder;
		remainder = m % n;
		m = n;
		n = remainder;
	}
	return n;
} 
int lcm ( int m, int n) {
	int lcm = m*n /  gcd ( m , n) ;
	return lcm;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int gcd(int a,int b){
    int c=a;
    a=max(a,b);
    if(a==b) b=c;
    else b=b;

    while(a%b!=0){
	    int remain=a%b;
	    a=b;
	    b=remain;
    }
    return b;


}

int LCM(int a,int b){
    int lcm=(a*b)/gcd(a,b);



return lcm;
}



main_program{
   int A,B;
   cin>>A>>B;

   cout<<LCM(A,B);  




}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int gcd(int m,int n){
	int remainder;
	while(m%n!=0){
			remainder=m%n;
			m=n;
			n=remainder;
			}
			return n;
			}
			int lcm(int c,int d){
			int lcm=c*d/gcd(c,d);
			return lcm;}

main_program{
	int a,b;
	cin >>a;
	cin>>b;
	cout<<lcm(a,b);}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int gcd;
gcd(int a,int b){
if (a%b==0)
   { a=b;
     b=a%b;}
     return  b;}
     int main () {
	     int m,n;
	     cin>>m>>n;
	     cout<<gcd(int m,int n)<<endl;}
	     lcm(a,b)*gcd(a,b)=a*b;

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int LCM(int a, int b){
	int x = a;
	int y = b;
	while(a%b!=0){
		int remainder = a%b;
		a = b;
		b = remainder;
	}
	int l =x * y /b;
	return l;
}
main_program{
int a, b;
cin>>a>>b;
if (a>b) {cout<<LCM(a,b);}
else cout<<LCM(b,a);
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int lcm(int &a,int &b){
	while(a%b!=0){
		int remainder=a%b;
		a=b;
		b=remainder;
	}
	return (b);
}
int main(){
	int a,b;
	cin>>a>>b;
	cout<<(a*b)/lcm(a,b)<<endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>
main_program{
	int A,B;
		cin >> A >> B;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>

	int lcm (int a, int b) {
		int n1 = a, n2 = b, gcd = 0;
		while (a%b >0) {
			if (b-a >0)
			b = b-a;
			else b = a -b;
			gcd = b;
			
		}
		int answer  = (n1*n2)/gcd;
		return answer;
	}
 main_program {
	 int x1; cin >> x1;
	 int x2; cin >> x2;
	 cout << lcm (x1, x2);


 }

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int lcm(int x1, int x2)
{
	int rem;
	int m = x2 , n = x1;
	while(x2 % x1 != 0)
	{
		rem = x2 % x1;
		x2 = x1;
		x1 = rem;
	}

	int ans= (m*n) / x1;
	return ans;
}
main_program
{
	int a,b;
	int an;
	cin>>a>>b;
	if(a>b)
	{
		 an = lcm(b,a);
	}

	else
	{
		an = lcm(a,b);
	}

	cout<<an;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>
int lcm(int num1,int num2){
	int lim=min(num1,num2);
	int hcf;
	for(int i=1;i<=lim;++i){
		if(num1%i==0 && num2%i==0)
			hcf=i;
	}
	return (num1*num2)/hcf;
}
main_program{
	int num1,num2;
	cin>>num1>>num2;
	cout<<lcm(num1,num2)<<endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int lcm(int n,int m){
	int remainder=0;
	int q=m;
	if (m%n == 0) cout<<m<<endl;
	else 
	while(m%n >0){
		remainder=m%n;
		m=n;
		n=remainder;
	}
        cout<<m*q/n<<endl;
        return 0;
}
int main(){
	int A,B;
	cin>>A>>B;
	lcm(A,B);
	return 0;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>
int gcd( int a,int b){
	while(a%b!=0){
		int r=a%b;
	        a=b;
		b=r;
	}
	return b;
}
int lcm(int a , int b){
	return a*b/gcd(a,b);
}
main_program{ 
	int c,d;
	cin>>c>>d;
	cout<< lcm(c,d);
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int gcd(int m , int n)
{
	while(m%n != 0){
		int remainder = m%n;
		m=n;
		n=remainder;
	}
	return n;
}
int lcm(int m , int n ){
	return m*n/gcd(m,n);
}

int main(){
	int m,n;
	cin >> m >> n ;
	cout << lcm(m,n) << endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
main_program {
	int a,b; cin>>a>>b;// b>a
		int m=b,n=a;
	while(m%n !=0)  {
		int remainder=m%n;
		m=n;
		n=remainder;
	}
	
	int lcm= (a*b)/n;
	cout<< lcm<<endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
main_program{
	int a,b,A,B,lcm;
	cin>> a>>b;
	A=a;
	B=b;
	
		while(b%a != 0){ 
			int rem;
		rem =b%a;
		b=a ;
		a=rem;
		}
		lcm=(A*B)/a;
		cout<<lcm;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
	int gcd(int n,int m){
		int remainder;
		while(m%n !=0){
			remainder=m%n;
			m=n;
			n=remainder;
		}
		return n;
	}
int lcm(int n, int m){
	int k;
	k=(n*m)/gcd(n,m);
	return k;
}
main_program{
	int A,B;
	cin>>A>>B;
	cout<<lcm(A,B)<<endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>
int lcm(int a,int b){
	int m,n,remainder;
	m=a; n=b;
	while(m%n!=0){
		remainder =m%n;
		m=n;
		n=remainder;
	}
	return a*b/n;
}
int main(){
	int x,y; cin>>x>>y;
	cout<< lcm(x,y) << endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>

	int lcm(int a, int b){
	int gcd;
	if(a%b==0){
		gcd=b;}
	lcm=((a*b)/gcd);
	return lcm;
	}
main_program{
	int m, n;
	cin>>m>>n;
	cout<<lcm(m,n)<<" ";
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int lcm
(int a,int b){
	if (b>a){
		int temp;
		temp=a;
		a=b;
		b=temp;
	}
	int p=a*b;
	while(a%b!=0){
		int Remainder=a%b;
		a=b;
		b=Remainder;
	}
	int l=p/b;
	return l;
}
main_program{
	int x,y;
	cin>>x>>y;
	int LCM=lcm(x,y);
	cout<<LCM;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>


int lcm(int a, int b){
	int d=b;
	while(d%a != 0 || d%b != 0)
	d++;
	
	return d;
}
main_program{
        int a,b;
        cin>>a>>b;
        cout<<lcm(a,b);
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
main_program{
	int a,b,t=1,p,q;
	cin>>a>>b;
	while(true){
		p = t%a;
		q = t%b;
		if (p==0&&q==0){
		       	cout<<t;
		       	break;
		}
		else t+=1;
	}
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>

int LCM
(int c,int d,int GCD)
{
int 	lcm=c*d/GCD;
return lcm;}
int gcd
(int a,int b)
{
while(a%b!=0)
{	int rem=a%b;
a=b;
b=rem;
}

return b;

}
main_program{
	int A,B;
	cin>>A>>B;
	int GCD=gcd( A, B);
	int lcm=LCM(A,B,GCD);
	cout<<endl<<lcm;}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int LCM(int a, int b) {
	int remainder;
	int l;
	l = a*b;
	while ( b % a != 0){
		remainder = b % a;
		b = a;
		a = remainder;
	}
	int r;
	r = l / a;
	return r;
	
}
main_program {
	int A, B;
	cin>>A>>B;
	cout<<LCM(A,B);
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>
int lcm (int m, int n){
	cin >> m >> n;
	int i;
	for(i=1; i>0; i++){
		while( i%m == 0 && i%n == 0){
			cout << i << endl;
			break;
		}
	}
	return i;
}

main_program{
	int A, B;
	cin >> A >> B;
	lcm(A, B);
	cout << lcm(A, B) << endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int get_lcm(int m, int n)
{
	int a=m, b=n;
	while(a%b!=0)
	{
		int rem=a%b;
		a=b;
		b=rem;
	}
	int lcm=m*n/b;
	return lcm;
}

main_program
{
	int A,B;
	cin>>A>>B;
	cout<<get_lcm(A,B);
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>
main_program{
	int A,B;
	cin >> A>>B;
	int LCM;
	LCM=60;
	cout<<LCM<<endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>

int gcd(int m,int n) {

	int remainder;

	while(m%n!=0) {
		remainder = m%n;
		m = n;
		n = remainder;
	}
	return remainder;
}

main_program {

	int m,n;
	cin >> m >> n;
		

	cout<<(m*n)/gcd(m,n)<<endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>

int gcd(int m,int n){
	while(m%n!=0){
		int temp=m%n;
		m=n;
		n=temp;
	}
	return n;
}

main_program{
	int x,y,a,b;
	cin>>x>>y;
	if(x>y){
		a=x;
		b=y;
	}
	else{
		b=x;
		a=y;
	}
	int lcm=a*b/gcd(a,b);
	cout<<lcm<<endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>

int gcd(int m,int n)     //creating function of gcd to compute gcd of two numbers
{
	while(n%m!=0)
	{
		int Remainder=n%m;
		n=m;
		m=Remainder;
	}
	return m;
}

float lcm(int m,int n)   //creating function of lcm to compute the lcm of two numbers
{
	float lcm=(m*n)/gcd(m,n);    //using the gcd function created above
	return lcm;
}

main_program
{
	int m,n;
	cin>>m>>n;       //taking input from user

	cout<<lcm(m,n)<<endl;      //prints the lcm of both numbers given by user
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
main_program {
	int m,n,x,y,z;
	cin>>m>>n;
	x=n;
	y=m;
	while(m%n !=0) {
		z=n;
		n=m%n;
		m=z;
	}
	int l;
	l=(y*x)/n;
	cout<<l<<endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>

main_program
{
	int num1, num2;
	cin >> num1 >> num2;
	int LCM;
	for (int i = max(num1,num2); ;i++)
	{
		if((i%num1 == 0) && (i%num2 == 0))
		{
			LCM = i;
			break;
		}
	}
	
	cout << LCM << endl;
}

Grading criterion: is LCM function returning value to main function
Rating A: if LCM is returning value correctly to main function
Rating B: if LCM function is not returning value correctly
Rating C: 0
Rating D: 0
Assigned grade: B