CodeGraderBench/CodeGraderBench huggingface dataset:
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	double x1,x2;
	cin>>x1>>x2;
	double i=x1;
	double b;
	while(i<=x2){
		b=(i*i*i)-(6.0*i*i)+(11.0*i)-6.0;
		if(b==0.000){
			cout<<fixed;
			cout.precision(3);
			cout<<i<<endl;
			break;
		}
		else i++;

	}
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: C
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include <simplecpp>

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: C
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>

	
	double equation (float x) {
		double value = pow(x, 3) - 6*pow(x,2) + 11*x - 6;
		return value;
	}

	main_program {
	float x1, x2; 
	cin >> x1; cin >> x2;
	float x0 = 0;
	do
       	{
		x0 = (x1 + x2)/2;
	 if (equation(x1)*equation(x0) <= 0) {x2 = x0;}
	 else  {x1 = x0;};
 	} while (equation(x0) !=0);
	
	cout << fixed; cout.precision(3);
	cout << x0;
 }

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program
{
	double x1,x2;

	cin>>x1>>x2;

	double  xm;

	while(x2-x1 > 0.000001){
		bool x1chk = (pow(x1,3) - 6*pow(x1,2) + (11*x1) - 6) < 0;
		
		xm = (x1 + x2) / 2.0;
		
		bool xmchk = (pow(xm,3) - 6*pow(xm,2) + (11*xm) - 6) < 0 ;
		
		
		if(x1chk  == xmchk)

		{
		
			x1 = xm;
		}

		else
		{
			x2 = xm;
		}
	}

	
	cout<<fixed;
	cout.precision(3);

	cout<<xm;
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	float x1,x2,x3;
	cout<<"x1:";
	cin>>x1;
	cout<<"x2:";
	cin>>x2;

	
	while(x2-x1<=0.001){
		x3=(x1+x2)/2;
		float c=pow(x1,3) -(6*pow(x1,2))+(11*x1)-6;
		float d=pow(x2,3)-(6*pow(x2,2))+(11*x2)-6;
	        float e=pow(x3,3)-6*pow(x3,2)+(11*x3)-6;
		if((c>0 && e<0) || (c<0 && e>0)){
			    
			x2=x3;
		}
		else if ((d>0 && e<0 ) ||(d<0 && e>0) ) {
		x1=x3;
		
		}
		
		}
		cout<<x3<<endl;
		}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: C
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	double x1 , x2;
	cin >> x1 >> x2 ;
	if(x1 <1 && x2 >1) cout << "1.000" << endl;
	else if(x1 <2 && x2 >2 ) cout << "2.000" << endl;
	else if(x1 <3 && x2 >2) cout << "3.000" << endl;
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: C
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program {
	double xL,xR;cin>>xL>>xR;
	double xM=(xL+xR)/2;
        int m=xM;
	cout<<m+1;
	cout.precision(3);
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: C
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	float x1, x2;
	cin>>x1>>x2;
	float epsilon=0.00001;
	float xm;
	bool sign_x1,sign_xm;
	sign_x1= (((pow(x1,3)-(6)*pow(x1,2)+11*x1 -6)) >=0);
	while((x2-x1)>epsilon){
		xm=(x1+x2)/2;
		sign_xm=(((pow(xm,3)-(6)*pow(xm,2)+11*xm -6)) >=0);
	if(sign_x1 == sign_xm)
		x1=xm;
	else
		x2=xm;
	}
	cout<<fixed;
	cout.precision(3);
	cout<<xm<<endl;
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: A
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include <simplecpp>
bool ispositive(float a){
	return a*a*a - 6*a*a+11*a-6>=0;}
main_program{
	double x1,x2,xm;
	cin >>x1 >>x2;
	while((x2-x1)>=0.1){
		xm= (x1+x2)/2;
		if(ispositive(xm)) {
			if(ispositive(x1))
				x1=xm;
			else if(ispositive(x2))
				x2=xm;
		}
		if(!ispositive(x2)){
			if(!ispositive(x1))
			x1=xm;
			else if(!ispositive(x2))
				x2=xm;
		}
	}
	cout << x1 <<endl;
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	//x3-6x2+11x-6
	float x1,x2;
	cin>>x1>>x2;
	float f1=pow(x1,3)-6*x1*x1+11*x1-6;
	float f2=pow(x2,3)-6*x2*x2+11*x2-6;
	if( (x1>x2)||(x1<-100)||(x2>100)||(f1*f2>0)) cout<<"Invalid input";
	else {
		while((x2-x1)>0.0001){
			float xm=(x1+x2)/2;
			float fm=pow(xm,3)-6*xm*xm+11*xm-6;
			if (fm==0){
				x1=xm;
				break;
			}
			else if (fm*f1>0){
				x1=xm;
				f1=pow(x1,3)-6*x1*x1+11*x1-6;
			}
			else{
				x2=xm;
				f2=pow(x2,3)-6*x2*x2+11*x2-6;
			}
		}
		cout<<fixed;
		cout.precision(3);
		cout<<x1;
	}
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: A
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	double x1,x2;
	cin>>x1>>x2;
	double a=1.000,b=2.000,c=3.000;
	cout<<fixed;
	cout.precision(3);
	if (x1<a&&x2<b&&x2>a) cout<<1.000;
	else if (x1>a&&x2<c) cout<<2.000;
	else if (x2>c) cout<<3.000;
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: C
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
double x1,x2;
cin>>x1>>x2;
float xm,epsilon;
epsilon=0.89001;
bool x1_is_positive,xm_is_positive;
x1_is_positive==(x1*x1*x1-6*x1*x1+11*x1-6)>0;
while((x2-x1)>=epsilon){
	xm=(x1+x2)/2;
	xm_is_positive==(xm*xm*xm-6*xm*xm+11*xm-6)>0;
	if(x1_is_positive==xm_is_positive)
		x1=xm;
	else x2=xm;
}
cout<<fixed;
cout.precision(3);
cout<<x1;
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: A
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
float x1, x2;
cin>>x1>>x2;
float xm = (x1 + x2)/2;
if (xm>

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: C
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include <simplecpp>
main_program{
	double x1, x2;
	cin >> x1 >> x2;
	double n = (x1+x2)/2;
	while(x1 >= -100 && x2 <= 100){
		for(int i=1; i>0; i++){
			if(((x1*x1*x1 - 6*x1*x1 + 11*x1 - 6)>0 && (n*n*n - 6*n*n + 11*n - 6>0)) || ((x1*x1*x1 - 6*x1*x1 + 11*x1 -6)<0 && (n*n*n - 6*n*n + 11*n - 6)<0))
				x1=n;
			else x2=n;
		}
		cout << fixed;
		cout.precision(3);
		cout << n << endl;
		break;
	}
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program
{
	double x1,x2;
	cin>>x1>>x2;
	bool fx1_is_positive=(pow(x1,3)-6*pow(x1,2)+11*x1-6)>0;
	bool fmid_is_positive;
	double mid;
	while(abs(pow(mid,3)-6*pow(mid,2)+11*mid-6)>1e-20)
	{
		mid=(x1+x2)/2;
		fmid_is_positive=(pow(mid,3)-6*pow(mid,2)+11*mid-6)>0;
		if(fmid_is_positive==fx1_is_positive) x1=mid;
		else x2=mid;
	}
	cout.precision(3);
	cout<<fixed<<mid;
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: A
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	double x1,x2;
	x1 < x2;




	cout<<fixed;
	cout.precision(3);
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: C
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>

double fx(double x1){
	double fx;
	fx = pow(x1,3)-6*pow(x1,2)+11*x1-6;
	return fx;
}
main_program {
	
	double x1,x2,m;
	cin >> x1 >> x2;
	
	m=(x1+x2)/2;
	while(fx(m)>0.001){
		m=(x1+x2)/2;
		if(fx(m)*fx(x2)>0)
			x2=m;
		else
			x1=m;
	}
	
	cout << fixed;
	cout.precision(3);
	cout << m<<endl;


}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program
{
	float a,b;
	cin>>a>>b;

	while(a>=-100&&a<=100&&b>=-100&&b<=100)
	{
		if(b<2)
			cout<<"1.000";
		else if(b>=2&&b<3)
			cout<<"2.000";
		else if(a<=3&&b>=3)
			cout<<"3.000";
		break;
	}
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: C
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
 main_program{
      int 
      float = x1;
      float = x2;
            repeat ( );
      cin << " 1 110 " ;
      cout << " 1.75  " ;
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: C
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
float fxn(double x)
{
	float sum = x*x*x - 6*x*x + 11*x - 6;
	return sum;
}

main_program 
{
	double x1, x2;
	cin >> x1 >> x2;

        repeat(1000)
	{
		float f1 = fxn(x1), f2 = fxn(x2);
		float fmid = fxn((x1+x2)/2);
		if((f1*fmid < 0)&&(f2*fmid > 0))
			x2 = (x1+x2)/2;
		else if((f1*fmid > 0)&&(f2*fmid < 0))
			x1 = (x1+x2)/2;
	}

	cout << (float)(x1+x2)/2 << ".000" << endl;
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	float x1,x2;
	cin>>x1>>x2;
	bool x1pos=((x1-1)*(x1-2)*(x1-3)>0);
	while(x2-x1>0.000001){
		float xm=(x1+x2)/2;
		bool xmpos=((xm-1)*(xm-2)*(xm-3)>0);
		if(x1pos==xmpos){
			x1=xm;
		}
		else{x2=xm;}
	}
	cout << fixed; // uses fixed floating point representation
	cout.precision(3); // print three digits after the decimal point
	cout<<double(x1);
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program
{
	double x1, x2, xM ;
	cin >> x1 >> x2 ;
	xM = (x1 + x2)/2 ;

	while(x1 >= -100 && x2 <= 100 && x1 < x2){
		while ((xM*xM*xM - 6*xM*xM + 11*xM - 6) == 0){
			bool x1_is_positive, xM_is_positive ;

			x1_is_positive = x1*x1*x1 - 6*x1*x1 + 11*x1 - 6 > 0 ;
			xM_is_positive = xM*xM*xM - 6*xM*xM + 11*xM - 6 > 0 ;

			if (x1_is_positive){
				if (xM_is_positive)
					x1 = xM ;
				else x2 = xM ;
			}
			else {
				if (xM_is_positive)
					x2 = xM ;
				else x1 = xM ;
			}
		}
	}

	cout << fixed ;
	cout.precision(3) ;
	cout << xM ;
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: A
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include <simplecpp>
main_program{

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: C
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
double fx(double x)
{
	double fx = x*x*x -6*x*x +11*x - 6;
	return fx;
}
main_program
{
	double x1, x2;
	cin >> x1 >> x2;
	double xm;
	cout<<fixed;
	cout.precision(3);
	repeat(100)
	{
		 xm = (x1+x2)/2;
		if (fx(xm) == 0){cout<<xm;}
		if(fx(x1) == 0){cout << x1;}
		if(fx(x2)==0){cout<<x2;}
		if (fx(x1) *fx(xm) < 0)
		{
			x2=xm;
		}
		else if(fx(x2) * fx(xm) <0)
		{
			x1=xm;
		}
	}
	cout<<xm;
}

Grading criterion: Quality of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B