criyle/codenet-compile-errors huggingface dataset:
Language: C

#include<stdio.h>

int main(void)
{
	int m,f,r;
	char grade;


	wghile(1){
		scanf("%d %d %d",&m,&f,&r);

		if(m==-1 && f ==-1 && r==-1)break;
			
		if(m + f >= 80)grade='A';
		if(m + f >= 65 && m + f < 80)grade='B';
		if(m + f >= 50 && m + f < 65)grade='C';
		if(m + f >= 30 && m + f < 50){
			if(r >=50){
				grade='C';
			}
			else{			
				grade='D';
			}
		}
		if(m + f < 30)grade='F';

		printf("%s\n",grade);
	}
	return 0;
}
	
	

Compiler output:
main.c: In function 'main':
main.c:9:9: error: implicit declaration of function 'wghile' [-Wimplicit-function-declaration]
    9 |         wghile(1){
      |         ^~~~~~
main.c:9:18: error: expected ';' before '{' token
    9 |         wghile(1){
      |                  ^
      |                  ;
Language: C

#include <stdio.h>
int main(void){
    
    int m, r, f;
    int sum;
    while(1){
        scanf("%d %d %d\n", &m, &r, &f);
        if(m == -1 && r == -1 && f == -1) break;
        if(m == -1 || r == -1){
            printf("F\n");
            continue;
        }
        
        sum = m + r;
        
        else if(80 <= sum) printf("A\n");
        else if(65 <= sum && sum < 80) printf("B\n");
        else if(50 <= sum && sum < 65) printf("C\n");
        else if(30 <= sum && sum < 50 && 50 <= f) printf("C\n");
        else if(30 <= sum && sum < 50 && f < 50) printf("D\n");
        if(sum < 30) printf("F\n");
    }
    
    
    return 0;
    
}

Compiler output:
main.c: In function 'main':
main.c:16:9: error: 'else' without a previous 'if'
   16 |         else if(80 <= sum) printf("A\n");
      |         ^~~~
Language: C

#include <stdio.h>
int main(void) {
	int m, f, r;

	while (true)
	{
		scanf("%d,%d,%d", &m, &f, &r);

		if (m == -1 && f == -1 && r == -1) {
			break;
		}

		if (m == -1 || f == -1) {
			printf("F\n");
		}
		else if (m + f >= 80) {
			printf("A\n");
		}
		else if (m + f < 80 && m + f >= 65) {
			printf("B\n");
		}
		else if (m + f < 65 && m + f >= 50) {
			printf("C\n");
		}
		else if (m + f < 50 && m + f >= 30) {
			if (r >= 50) {
				printf("C\n");
			}
			else{
				printf("D\n");
			}
		}
		else if (m + f < 30 ) {
			printf("F\n");
		}
	}
	return 0;
}

Compiler output:
main.c: In function 'main':
main.c:5:16: error: 'true' undeclared (first use in this function)
    5 |         while (true)
      |                ^~~~
main.c:2:1: note: 'true' is defined in header '<stdbool.h>'; this is probably fixable by adding '#include <stdbool.h>'
    1 | #include <stdio.h>
  +++ |+#include <stdbool.h>
    2 | int main(void) {
main.c:5:16: note: each undeclared identifier is reported only once for each function it appears in
    5 |         while (true)
      |                ^~~~
Language: C

#include <stdio.h>

int main(void)
{
	int m,f,r;
	int cnt=0,i;
	int sum;
	char rank[100];
	while(1){
		scanf("%d %d %d",&m,&f,&r);
		
		if(m==-1&&f==-1&&r==-1)break;
		
		sum=m+f;
		if(sum>=80)rank[cnt]='A';
		else if(sum>=65&&80>sum)rank[cnt]='B';
		else if(sum>=50&&65>sum)rank[cnt]='C';
		else if(sum>=30&&50>sum){
			rank[cnt]='D';
			if(r>=50)rank[cnt]='C';
		if(sum<30||m==-1||f==-1)rank[cnt]='F';
		cnt++;
	}
	printf("\n");
	for(i=0;i<cnt;i++){
		printf("%c\n",rank[i]);
	}
	return 0;
}

/*
50?????????
80?????§A 65??\???B 50??\???C 30??\???D 30??????F
D???????????§50??\?????????C
???????¬??????§F

?¬????????????°???-1

m,f,r?????¨???-1??§??????
		if(m==-1;f==-1;r==-1) break;

*/

Compiler output:
main.c: In function 'main':
main.c:29:1: error: expected declaration or statement at end of input
   29 | }
      | ^
Language: C

#include <stdio.h>
int main (void)
{
	int m, f, r;
	
	while(1){
		scanf("%d %d %d",&m,&f,&r);
		if(m==-1 && f==-1 && r==-1) break;
		
		if(m==-1 || f==-1) printf("F");
		
		if(m+f>=80) printf("A");
		else if(m+f>=65 && m+f<80) printf("B");
		else if(m+f>=50 && m+f<65) printf("C");
		else if(m+f>=30 && m+f<50) 
			if(r>=50) printf("C");
			else	  printf("D");
		else printf("F");
		printf("\n")
	}
	printf("\n");
	return 0;
}

Compiler output:
main.c: In function 'main':
main.c:19:29: error: expected ';' before '}' token
   19 |                 printf("\n")
      |                             ^
      |                             ;
   20 |         }
      |         ~
Language: C

#include<stdio.h>
int main(void)
{
  int m,f,r,i,j;
  i = 0;
  char grade[10000];
  while(1){
    scanf("%d %d %d",&m,&f,&r);
    if(m == -1 && f == -1 && r == -1){
      break;
    }
    if(m == -1 || f == -1 || m + f < 30){
      grade[i] = 'F';
    }else if(m + f >= 80){
      grade[i] = 'A';
    }else if(m + f >= 65 && m + f < 80){
      grade[i] = 'B';
    }else if(m + f >= 50 && m + f < 65){
      grade[i] = 'C';
    }else if(m + f >= 30 && m + f < 50){
      grade[i] = 'D';
      if(r >= 50){
        grade[i] = 'C';
      }
    }
    i++;
  }
  /*for(j = 0;j <= i;j++){
    printf("%c",grade[j]);
    if(j <= i - 1){
      printf("\n");
    }
  */}
  printf("A\nC\nF");
  return 0;
}

Compiler output:
main.c:34:10: error: expected declaration specifiers or '...' before string constant
   34 |   printf("A\nC\nF");
      |          ^~~~~~~~~
main.c:35:3: error: expected identifier or '(' before 'return'
   35 |   return 0;
      |   ^~~~~~
main.c:36:1: error: expected identifier or '(' before '}' token
   36 | }
      | ^
Language: C

#include<stdio.h>
int main(void)
{
  int m,f,r,i,j;
  i = 0;
  char grade[10000];
  while(1){
    scanf("%d %d %d",&m,&f,&r);
    if(m == -1 && f == -1 && r == -1){
      break;
    }
    if(m == -1 || f == -1 || m + f < 30){
      grade[i] = 'F';
    }else if(m + f >= 80){
      grade[i] = 'A';
    }else if(m + f >= 65 && m + f < 80){
      grade[i] = 'B';
    }else if(m + f >= 50 && m + f < 65){
      grade[i] = 'C';
    }else if(m + f >= 30 && m + f < 50){
      grade[i] = 'D';
      if(r >= 50){
        grade[i] = 'C';
      }
    }
    i++;
  }
  for(j = 0;j <= i;j++){
    printf("%c\n",grade[j]);
    }
  }
  return 0;
}

Compiler output:
main.c:32:3: error: expected identifier or '(' before 'return'
   32 |   return 0;
      |   ^~~~~~
main.c:33:1: error: expected identifier or '(' before '}' token
   33 | }
      | ^
Language: C

include <stdio.h>
int main () {
  int m, f, r;
  int i;
  while (1) {
    scanf("%d %d %d", &m, &f, &r);
    if (m==-1 && f==-1 && r==-1) {
      break;
    }
    if (f==-1 || m==-1) {
      printf("F\n");
    }
    else if (m+f>=80) {
    printf("A\n");
    }
    else if (m+f>=65 && m+f<80) {
      printf("B\n");
    }
    else if (m+f>=50 && m+f<65) {
      printf("C\n");
    }
    else if (m+f>=30 && m+f<50 && r<50) {
      printf("D\n");
    }
    else if (m+f>=30 && m+f<50 && r>=50) {
      printf("C\n");
    }
    else if (m+f<30) {
      printf("F\n");
    }
  }

  return 0;
}

Compiler output:
main.c:1:9: error: expected '=', ',', ';', 'asm' or '__attribute__' before '<' token
    1 | include <stdio.h>
      |         ^
Language: C

include <stdio.h>
int main () {
  int m, f, r;
  while (1) {
    scanf("%d %d %d", &m, &f, &r);
    if (m==-1 && f==-1 && r==-1) {
      break;
    }
    if (f==-1 || m==-1) {
      printf("F\n");
    }
    else if (m+f>=80) {
    printf("A\n");
    }
    else if (m+f>=65 && m+f<80) {
      printf("B\n");
    }
    else if (m+f>=50 && m+f<65) {
      printf("C\n");
    }
    else if (m+f>=30 && m+f<50 && r<50) {
      printf("D\n");
    }
    else if (m+f>=30 && m+f<50 && r>=50) {
      printf("C\n");
    }
    else if (m+f<30) {
      printf("F\n");
    }
  }

  return 0;
}

Compiler output:
main.c:1:9: error: expected '=', ',', ';', 'asm' or '__attribute__' before '<' token
    1 | include <stdio.h>
      |         ^
Language: C

include <stdio.h>
int main(void) 
{
	int m, f, r;
	m = 1, f = 1, r = 1;
	while ((m != -1) || (f != -1) || (r != -1))
	{
		scanf("%d %d %d", &m, &f, &r);
		if (m == -1 && f == -1 && r == -1)
		{
			break;
		}

		if (m == -1 || f == -1)
		{
			printf("F");
		}
		if (m + f >= 80)
		{
			printf("A");
		}
		if (m + f >= 65 && m + f < 80)
		{
			printf("B");
		}
		if (m + f >= 50 && m + f < 65)
		{
			printf("C");
		}
		if (m + f >= 30 && m + f < 50 && r < 50)
		{
			printf("D");
		}
		if (m + f >= 30 && m + f < 50 && r >= 50)
		{
			printf("C");
		}
		if (m + f < 30)
		{
			printf("F");
		}
	}
	return 0;
}

Compiler output:
main.c:1:9: error: expected '=', ',', ';', 'asm' or '__attribute__' before '<' token
    1 | include <stdio.h>
      |         ^
Language: C

#include <stdio.h>

int main(void){
	int m,f,r;

	m=0;
	f=0;
	r=0;

	while(m!=-1 || f!=-1 || r!=-1){
		scanf("%d %d %d",&f,&m,&r);
	
		if(f==-1 && m==-1 && r==-1){
			break;
		}
		else if(f==-1||m==-1){
			printf("F\n");
		}
		else if(m+f>=80){
			printf("A\n");
		}
		else if(m+f>=65 && m+f<80){
			printf("B\n");
		}
		else if((m+f>=50 && m+f<65)){
				printf("C\n");
			
		}
		else if(m+f>=30 && m+f<50){
			if(r>=50){
				printf("C\n");
			}
			else{
				printf("D\n");
			}
		}
		else if(m+f<30){
			printf("F\n");
		}
	}

	return 0;

Compiler output:
main.c: In function 'main':
main.c:42:9: error: expected declaration or statement at end of input
   42 |         return 0;
      |         ^~~~~~
Language: C

#include  <stdio.h>

int main()
{
	int m,f,r;

	while(1)
	{
		scanf("%d%d%d",&m,&f,&r);
		if(((m==-1)&&(f==-1)&&(r==-1))||m+f>100)
			break;
		if  ((m==-1)||(f==-1)||((m+f)<30))
		{
			printf("F\n");
		}
		else if((m+f)>=80)
		{
			printf("A\n");
		}
		else  if(((m+f)>=65)&&((m+f)<80))
		{
			printf("B\n");
		}
		else  if(((m+f)>=50)&&((m+f)<65)
		if(r>=50)
		{
			printf("C\n");
		}
		else  if((m+f)<50)
		{
			printf("D\n");
		}

	}
	return  0;
}

Compiler output:
main.c: In function 'main':
main.c:24:49: error: expected ')' before 'if'
   24 |                 else  if(((m+f)>=50)&&((m+f)<65)
      |                         ~                       ^
      |                                                 )
   25 |                 if(r>=50)
      |                 ~~                               
main.c:34:9: error: expected expression before '}' token
   34 |         }
      |         ^
Language: C

#include  <stdio.h>

int main()
{
	int m,f,r;

	while(1)
	{
		scanf("%d%d%d",&m,&f,&r);
		if((m==-1)&&(f==-1)&&(r==-1))
			break;
		if  (m==-1||f==-1)||((m+f)<30))
		{
			printf("F\n");
		}
		else if((m+f)>=80)
		{
			printf("A\n");
		}
		else  if((m+f)>=65)
		{
			if((m+f)<80)
			{
			printf("B\n");
			}
		}
		else  if((m+f)>=50)
		{
			if((m+f)<65)
			{
				printf("C\n");
			}
		}
		else if(30<=(m+f))
		{
			if(r>=50)
			{
				printf("C\n");
			}
		}
		else  if((m+f)<50)
		{
			printf("D\n");
		}
	}
	return  0;
}

Compiler output:
main.c: In function 'main':
main.c:12:35: error: expected expression before '||' token
   12 |                 if  (m==-1||f==-1)||((m+f)<30))
      |                                   ^~
main.c:12:47: error: expected statement before ')' token
   12 |                 if  (m==-1||f==-1)||((m+f)<30))
      |                                               ^
main.c:16:17: error: 'else' without a previous 'if'
   16 |                 else if((m+f)>=80)
      |                 ^~~~
Language: C

#include  <stdio.h>

int main()
{
	int m,f,r;

	while(1)
	{
		scanf("%d%d%d",&m,&f,&r);
		if((m==-1)&&(f==-1)&&(r==-1))
			break;
		if  ((m==-1||f==-1)||((m+f)<30))
		{
			printf("F\n");
		}
		else if(80<=(m+f))
		{
			printf("A\n");
		}
		else  if(65<=(m+f))
		{
			if((m+f)<80)
			{
				printf("B\n");
			}
		}
		else  if(50<=(m+f))
		{
			if((m+f)<65)
			{
				printf("C\n");
			}
		}
		else if(30<=(m+f))
		{
			if(50<=r)
			{
				printf("C\n");
			}
		}
		else  if((m+f)<50)
		{
			printf("D\n");
		}
	}

Compiler output:
main.c: In function 'main':
main.c:45:9: error: expected declaration or statement at end of input
   45 |         }
      |         ^
Language: C

#include<stdio.h>
main(){
????int m,f,r,p;
????while(1){
????????scanf("%d%d%d",&m,&f,&r);
????????if(m==-1&&f==-1&&r==-1)
????????????break;
????????p=m+f;
????????if(m==-1||f==-1)
????????????printf("F\n");
????????else if(p>=80)
????????????printf("A\n");
????????else if(65<=p&&p<80)
????????????printf("B\n");
????????else if(50<=p&&p<65)
????????????printf("C\n");
????????else if(30<=p&&p<50){
????????????if(50<=r)
????????printf("C\n");
????????????else
????????printf("D\n");
????????}
????????else if(p<30)
????????????printf("F\n");
????}
????return 0;
}

Compiler output:
main.c:2:1: error: return type defaults to 'int' [-Wimplicit-int]
    2 | main(){
      | ^~~~
main.c: In function 'main':
main.c:3:1: error: expected expression before '?' token
    3 | ????int m,f,r,p;
      | ^
main.c:4:1: error: expected expression before '?' token
    4 | ????while(1){
      | ^
Language: C

#include<stdio.h>
int main(){
????int m,f,r,p;
????while(1){
????????scanf("%d%d%d",&m,&f,&r);
????????if(m==-1&&f==-1&&r==-1)
????????????break;
????????p=m+f;
????????if(m==-1||f==-1)
????????????printf("F\n");
????????else if(p>=80)
????????????printf("A\n");
????????else if(65<=p&&p<80)
????????????printf("B\n");
????????else if(50<=p&&p<65)
????????????printf("C\n");
????????else if(30<=p&&p<50){
????????????if(50<=r)
????????printf("C\n");
????????????else
????????printf("D\n");
????????}
????????else if(p<30)
????????????printf("F\n");
????}
????return 0;
}

Compiler output:
main.c: In function 'main':
main.c:3:1: error: expected expression before '?' token
    3 | ????int m,f,r,p;
      | ^
main.c:4:1: error: expected expression before '?' token
    4 | ????while(1){
      | ^
Language: C

#include<stdio.h>
int main(){
????int m,f,r,p;
????while(1){
????????scanf("%d%d%d",&m,&f,&r);
????????if(m==-1&&f==-1&&r==-1)
????????????break;
????????p=m+f;
????????if(m==-1||f==-1)
????????????printf("F\n");
????????if(p>=80)
????????????printf("A\n");
????????if(65<=p&&p<80)
????????????printf("B\n");
????????if(50<=p&&p<65)
????????????printf("C\n");
????????if(30<=p&&p<50){
????????????if(50<=r)
????????printf("C\n");
????????????else
????????printf("D\n");
????????}
???????? if(p<30)
????????????printf("F\n");
????}
????return 0;
}

Compiler output:
main.c: In function 'main':
main.c:3:1: error: expected expression before '?' token
    3 | ????int m,f,r,p;
      | ^
main.c:4:1: error: expected expression before '?' token
    4 | ????while(1){
      | ^
Language: C

#include <stdio.h>
????
int main(void) {
????????int i,j,k;
????????int m,f,r;
??????????
????????while(1){
????????????????scanf("%d %d %d", &m,&f,&r);
????????????????if(m==-1&&f==-1&&r==-1) break;
??????????????????
????????????????if(m==-1||f==-1) printf("F\n");
????????????????else if(m+f>=80) printf("A\n");
????????????????else if(m+f>=65 && m+f<80) printf("B\n");
????????????????else if(m+f>=50 && m+f<65) printf("C\n");
????????????????else if(m+f>=30 && m+f<50) {
????????????????????????if(r>=50) printf("C\n");
????????????????????????else?? printf("D\n");
????????????????}
????????????????else printf("F\n");
????????}
??????????????????
????????return 0;
}

Compiler output:
main.c:2:1: error: expected identifier or '(' before '?' token
    2 | ????
      | ^
Language: C

#include <stdio.h>
int main(void)
{
	int i, f, r;
	while (1)
	{
		scanf("%d %d %d", &m, &f, &r);
		if (i==-1 && f==-1 && r==-1)
		{
			break;
		}
	
		if (i==-1 || f==-1)
		{
			printf("F\n");
		}
		else if (i+f>=80)
		{
			printf("A\n");
		}
		else if (65<=i+f && i+f<80)
		{
			printf("B\n");
		}
		else if (50<=i+f && i+f<65)
		{
			printf("C\n");
		}
		else if (30<=i+f && i+f<50 && r<50)
		{
			printf("D\n");
		}
		else if (30<=i+f && i+f<50 && 50<=r)
		{
			printf("C\n");
		}
		else if (i+f<30)
		{
			printf("F\n");
		}
	}
	return 0;
}

Compiler output:
main.c: In function 'main':
main.c:7:36: error: 'm' undeclared (first use in this function)
    7 |                 scanf("%d %d %d", &m, &f, &r);
      |                                    ^
main.c:7:36: note: each undeclared identifier is reported only once for each function it appears in
Language: C

#include <stdio.h>

int main(){
int m,f,r;
while(1){
scanf("%d %d %d",&m,&f,&r);
if(m==-1&&f==-1&&r==-1)break;
else if((m+f)>=80) printf("A\n");
else if(65<=(m+f)&&(m+f)<80) printf("B\n");
else if(50<=(m+f)&&(m+f)<65) printf("C\n");
else if(30<=(m+f)&&(m+f)<50) if(r>=50) printf("C\n");else printf("D\n");
else printf("F\n")
}
return 0;
}

Compiler output:
main.c: In function 'main':
main.c:12:19: error: expected ';' before '}' token
   12 | else printf("F\n")
      |                   ^
      |                   ;
   13 | }
      | ~
Language: C

#include <stdio.h>

int main(){
int m,f,r;
while(1){
scanf("%d %d %d",&m,&f,&r);
if(m==-1&&f==-1&&r==-1)break;
else if(m==-1&&f==-1&&r!=-1) printf("F\n")
else if((m+f)>=80) printf("A\n");
else if(65<=(m+f)&&(m+f)<80) printf("B\n");
else if(50<=(m+f)&&(m+f)<65) printf("C\n");
else if(30<=(m+f)&&(m+f)<50) {if(r>=50) printf("C\n");else printf("D\n");}
else printf("F\n");
}
return 0;
}

Compiler output:
main.c: In function 'main':
main.c:8:43: error: expected ';' before 'else'
    8 | else if(m==-1&&f==-1&&r!=-1) printf("F\n")
      |                                           ^
      |                                           ;
    9 | else if((m+f)>=80) printf("A\n");
      | ~~~~
Language: C

#include<stdio.h>
int main()
{
    int m,f,r,sum=0;
    scanf("%d%d%d",&m,&f,&r);
    { sum=m+f;
        if(m==0 || f==0 || m+f<30)
        printf("F\n");
        else if(sum>=80)
        printf("A\n");
        else if(sum>=65 && sum<80)
        printf("B\n");
        else if(sum>=50 && sum<65)
        printf("C\n");
        else if(sum>=30 && sum<50)
        printf("D\n");
        else if(r>=50)
        printf("C\n");
else if(m==-1 && f==-1 && r==-1)
               break;}
    return 0; }


Compiler output:
main.c: In function 'main':
main.c:20:16: error: break statement not within loop or switch
   20 |                break;}
      |                ^~~~~
Language: C

#include <stdio.h>

int main(void)
{
	int   m, f, r, sum;


	for (; ; ) {
		scanf_s("%d %d %d", &m, &f, &r);
		if (m == -1 && f == -1 && r == -1) {
			break;
		}
		sum = m + f;
		
		if (sum >= 80){
			printf("A\n");
		}
		if (sum >= 65 && sum < 80) {
			printf("B\n");
		}
		if (sum >= 50 && sum < 65) {
			printf("C\n");
		}
		if (sum >= 30 && sum < 50) {
			if (r >= 50) {
				printf("C\n");
			}
			printf("D\n");
		}
		if ( sum < 30 ) {
			printf("F");
		}
	}	
	return 0;
}


Compiler output:
main.c: In function 'main':
main.c:9:17: error: implicit declaration of function 'scanf_s'; did you mean 'scanf'? [-Wimplicit-function-declaration]
    9 |                 scanf_s("%d %d %d", &m, &f, &r);
      |                 ^~~~~~~
      |                 scanf
Language: C

#include <stdio.h>

int main(void)
{
	int m, f, r;

	for (;;) {
		scanf("%d %d %d", &m, &f, &r);
		if (m == -1 && f == -1 && r == -1) break;
		t =  (m == -1) ? 0: m;
		t += (f == -1) ? 0: n;

		if (t >= 80) {
			puts("A");
			continue;
		}
		if (t >= 65 && t < 80) {
			puts("B");
			continue;
		}
		if (t >= 50 && t < 65) {
			puts("C");
			continue;
		}
		if (t >= 30 && t < 50) {
			if (r >= 50) puts("C");
			else puts("D");
			continue;
		}
		if (t < 30) {
			puts("F");
			contrinue;
		}
	}
	return 0;
}



Compiler output:
main.c: In function 'main':
main.c:10:17: error: 't' undeclared (first use in this function)
   10 |                 t =  (m == -1) ? 0: m;
      |                 ^
main.c:10:17: note: each undeclared identifier is reported only once for each function it appears in
main.c:11:37: error: 'n' undeclared (first use in this function)
   11 |                 t += (f == -1) ? 0: n;
      |                                     ^
main.c:32:25: error: 'contrinue' undeclared (first use in this function)
   32 |                         contrinue;
      |                         ^~~~~~~~~
Language: C

#include <stdio.h>

int main(void)
{
	int m, f, r, t;

	for (;;) {
		scanf("%d %d %d", &m, &f, &r);
		if (m == -1 && f == -1 && r == -1) break;
		t =  (m == -1) ? 0: m;
		t += (f == -1) ? 0: n;

		if (t >= 80) {
			puts("A");
			continue;
		}
		if (t >= 65 && t < 80) {
			puts("B");
			continue;
		}
		if (t >= 50 && t < 65) {
			puts("C");
			continue;
		}
		if (t >= 30 && t < 50) {
			if (r >= 50) puts("C");
			else puts("D");
			continue;
		}
		if (t < 30) {
			puts("F");
			contrinue;
		}
	}
	return 0;
}



Compiler output:
main.c: In function 'main':
main.c:11:37: error: 'n' undeclared (first use in this function)
   11 |                 t += (f == -1) ? 0: n;
      |                                     ^
main.c:11:37: note: each undeclared identifier is reported only once for each function it appears in
main.c:32:25: error: 'contrinue' undeclared (first use in this function)
   32 |                         contrinue;
      |                         ^~~~~~~~~
Language: C

#include <stdio.h>

int main(void)
{
	int m, f, r, t;

	for (;;) {
		scanf("%d %d %d", &m, &f, &r);
		if (m == -1 && f == -1 && r == -1) break;
		t =  (m == -1) ? 0: m;
		t += (f == -1) ? 0: f;

		if (t >= 80) {
			puts("A");
			continue;
		}
		if (t >= 65 && t < 80) {
			puts("B");
			continue;
		}
		if (t >= 50 && t < 65) {
			puts("C");
			continue;
		}
		if (t >= 30 && t < 50) {
			if (r >= 50) puts("C");
			else puts("D");
			continue;
		}
		if (t < 30) {
			puts("F");
			contrinue;
		}
	}
	return 0;
}



Compiler output:
main.c: In function 'main':
main.c:32:25: error: 'contrinue' undeclared (first use in this function)
   32 |                         contrinue;
      |                         ^~~~~~~~~
main.c:32:25: note: each undeclared identifier is reported only once for each function it appears in
Language: C

#include<stdio.h>

struct test{
    int mid;
    int fin;
    int re;
    char eval;
};

int main(){
    test test[50]
    int i;
    int count = 0;
    for(i = 0;i < 50;i++){
        scanf("%d %d %d", &test[i].mid, &test[i].fin, &test[i].re);
        if(test[i].mid == -1 && test[i].fin == -1 && test[i].re == -1){
            break;
        }
        test[i].eval = evaluate(test[i].mid, test[i].fin);
        count++;
    }
    for(i = 0;i < count;i++){
        printf("%c\n", text[i].eval);
    }
    return 0;
}

char evaluate(int mid, int fin, int re){
    if(mid == -1 || fin == -1){
        return 'F';
    }
    if(mid + fin >= 80){
        return 'A';
    }
    else if(mid + fin >= 65){
        return 'B';
    }
    else if(mid + fin >= 50){
        return 'C';
    }
    else if(mid + fin >= 30){
        if(re >= 50){
            return 'C';
        }
        else{
            return 'D';
        }
    }
    else{
        return 'F';
    }
}


Compiler output:
main.c: In function 'main':
main.c:11:5: error: unknown type name 'test'; use 'struct' keyword to refer to the type
   11 |     test test[50]
      |     ^~~~
      |     struct 
main.c:12:5: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'int'
   12 |     int i;
      |     ^~~
main.c:14:9: error: 'i' undeclared (first use in this function)
   14 |     for(i = 0;i < 50;i++){
      |         ^
main.c:14:9: note: each undeclared identifier is reported only once for each function it appears in
main.c:15:28: error: 'test' undeclared (first use in this function)
   15 |         scanf("%d %d %d", &test[i].mid, &test[i].fin, &test[i].re);
      |                            ^~~~
main.c:19:24: error: implicit declaration of function 'evaluate' [-Wimplicit-function-declaration]
   19 |         test[i].eval = evaluate(test[i].mid, test[i].fin);
      |                        ^~~~~~~~
main.c:23:24: error: 'text' undeclared (first use in this function); did you mean 'test'?
   23 |         printf("%c\n", text[i].eval);
      |                        ^~~~
      |                        test
main.c: At top level:
main.c:28:6: error: conflicting types for 'evaluate'; have 'char(int,  int,  int)'
   28 | char evaluate(int mid, int fin, int re){
      |      ^~~~~~~~
main.c:19:24: note: previous implicit declaration of 'evaluate' with type 'int()'
   19 |         test[i].eval = evaluate(test[i].mid, test[i].fin);
      |                        ^~~~~~~~
Language: C

#include<stdio.h>

struct test{
    int mid;
    int fin;
    int re;
    char eval;
};

int main(){
    struct test test[50]
    int i;
    int count = 0;
    for(i = 0;i < 50;i++){
        scanf("%d %d %d", &test[i].mid, &test[i].fin, &test[i].re);
        if(test[i].mid == -1 && test[i].fin == -1 && test[i].re == -1){
            break;
        }
        test[i].eval = evaluate(test[i].mid, test[i].fin);
        count++;
    }
    for(i = 0;i < count;i++){
        printf("%c\n", text[i].eval);
    }
    return 0;
}

char evaluate(int mid, int fin, int re){
    if(mid == -1 || fin == -1){
        return 'F';
    }
    if(mid + fin >= 80){
        return 'A';
    }
    else if(mid + fin >= 65){
        return 'B';
    }
    else if(mid + fin >= 50){
        return 'C';
    }
    else if(mid + fin >= 30){
        if(re >= 50){
            return 'C';
        }
        else{
            return 'D';
        }
    }
    else{
        return 'F';
    }
}


Compiler output:
main.c: In function 'main':
main.c:11:25: error: expected ';' before 'int'
   11 |     struct test test[50]
      |                         ^
      |                         ;
   12 |     int i;
      |     ~~~                  
main.c:15:28: error: 'test' undeclared (first use in this function)
   15 |         scanf("%d %d %d", &test[i].mid, &test[i].fin, &test[i].re);
      |                            ^~~~
main.c:15:28: note: each undeclared identifier is reported only once for each function it appears in
main.c:19:24: error: implicit declaration of function 'evaluate' [-Wimplicit-function-declaration]
   19 |         test[i].eval = evaluate(test[i].mid, test[i].fin);
      |                        ^~~~~~~~
main.c:23:24: error: 'text' undeclared (first use in this function); did you mean 'test'?
   23 |         printf("%c\n", text[i].eval);
      |                        ^~~~
      |                        test
main.c: At top level:
main.c:28:6: error: conflicting types for 'evaluate'; have 'char(int,  int,  int)'
   28 | char evaluate(int mid, int fin, int re){
      |      ^~~~~~~~
main.c:19:24: note: previous implicit declaration of 'evaluate' with type 'int()'
   19 |         test[i].eval = evaluate(test[i].mid, test[i].fin);
      |                        ^~~~~~~~
Language: C

#include<stdio.h>

struct test{
    int mid;
    int fin;
    int re;
    char eval;
};

int main(){
    struct test test[50];
    int i;
    int count = 0;
    for(i = 0;i < 50;i++){
        scanf("%d %d %d", &test[i].mid, &test[i].fin, &test[i].re);
        if(test[i].mid == -1 && test[i].fin == -1 && test[i].re == -1){
            break;
        }
        test[i].eval = evaluate(test[i].mid, test[i].fin);
        count++;
    }
    for(i = 0;i < count;i++){
        printf("%c\n", text[i].eval);
    }
    return 0;
}

char evaluate(int mid, int fin, int re){
    if(mid == -1 || fin == -1){
        return 'F';
    }
    if(mid + fin >= 80){
        return 'A';
    }
    else if(mid + fin >= 65){
        return 'B';
    }
    else if(mid + fin >= 50){
        return 'C';
    }
    else if(mid + fin >= 30){
        if(re >= 50){
            return 'C';
        }
        else{
            return 'D';
        }
    }
    else{
        return 'F';
    }
}


Compiler output:
main.c: In function 'main':
main.c:19:24: error: implicit declaration of function 'evaluate' [-Wimplicit-function-declaration]
   19 |         test[i].eval = evaluate(test[i].mid, test[i].fin);
      |                        ^~~~~~~~
main.c:23:24: error: 'text' undeclared (first use in this function); did you mean 'test'?
   23 |         printf("%c\n", text[i].eval);
      |                        ^~~~
      |                        test
main.c:23:24: note: each undeclared identifier is reported only once for each function it appears in
main.c: At top level:
main.c:28:6: error: conflicting types for 'evaluate'; have 'char(int,  int,  int)'
   28 | char evaluate(int mid, int fin, int re){
      |      ^~~~~~~~
main.c:19:24: note: previous implicit declaration of 'evaluate' with type 'int()'
   19 |         test[i].eval = evaluate(test[i].mid, test[i].fin);
      |                        ^~~~~~~~
Language: C

#include<stdio.h>

struct test{
    int mid;
    int fin;
    int re;
    char eval;
};

int main(){
    struct test test[50];
    int i;
    int count = 0;
    for(i = 0;i < 50;i++){
        scanf("%d %d %d", &test[i].mid, &test[i].fin, &test[i].re);
        if(test[i].mid == -1 && test[i].fin == -1 && test[i].re == -1){
            break;
        }
        test[i].eval = evaluate(test[i].mid, test[i].fin);
        count++;
    }
    for(i = 0;i < count;i++){
        printf("%c\n", test[i].eval);
    }
    return 0;
}

char evaluate(int mid, int fin, int re){
    if(mid == -1 || fin == -1){
        return 'F';
    }
    if(mid + fin >= 80){
        return 'A';
    }
    else if(mid + fin >= 65){
        return 'B';
    }
    else if(mid + fin >= 50){
        return 'C';
    }
    else if(mid + fin >= 30){
        if(re >= 50){
            return 'C';
        }
        else{
            return 'D';
        }
    }
    else{
        return 'F';
    }
}


Compiler output:
main.c: In function 'main':
main.c:19:24: error: implicit declaration of function 'evaluate' [-Wimplicit-function-declaration]
   19 |         test[i].eval = evaluate(test[i].mid, test[i].fin);
      |                        ^~~~~~~~
main.c: At top level:
main.c:28:6: error: conflicting types for 'evaluate'; have 'char(int,  int,  int)'
   28 | char evaluate(int mid, int fin, int re){
      |      ^~~~~~~~
main.c:19:24: note: previous implicit declaration of 'evaluate' with type 'int()'
   19 |         test[i].eval = evaluate(test[i].mid, test[i].fin);
      |                        ^~~~~~~~
Language: C

#include<stdio.h>

struct test{
    int mid;
    int fin;
    int re;
    char eval;
};

int main(){
    struct test test[50];
    int i;
    int count = 0;
    for(i = 0;i < 50;i++){
        scanf("%d %d %d", &test[i].mid, &test[i].fin, &test[i].re);
        if(test[i].mid == -1 && test[i].fin == -1 && test[i].re == -1){
            break;
        }
        test[i].eval = evaluate(test[i].mid, test[i].fin, test[i].re);
        count++;
    }
    for(i = 0;i < count;i++){
        printf("%c\n", test[i].eval);
    }
    return 0;
}

char evaluate(int mid, int fin, int re){
    if(mid == -1 || fin == -1){
        return 'F';
    }
    if(mid + fin >= 80){
        return 'A';
    }
    else if(mid + fin >= 65){
        return 'B';
    }
    else if(mid + fin >= 50){
        return 'C';
    }
    else if(mid + fin >= 30){
        if(re >= 50){
            return 'C';
        }
        else{
            return 'D';
        }
    }
    else{
        return 'F';
    }
}


Compiler output:
main.c: In function 'main':
main.c:19:24: error: implicit declaration of function 'evaluate' [-Wimplicit-function-declaration]
   19 |         test[i].eval = evaluate(test[i].mid, test[i].fin, test[i].re);
      |                        ^~~~~~~~
main.c: At top level:
main.c:28:6: error: conflicting types for 'evaluate'; have 'char(int,  int,  int)'
   28 | char evaluate(int mid, int fin, int re){
      |      ^~~~~~~~
main.c:19:24: note: previous implicit declaration of 'evaluate' with type 'int()'
   19 |         test[i].eval = evaluate(test[i].mid, test[i].fin, test[i].re);
      |                        ^~~~~~~~
Language: C

#include<stdio.h>

struct test{
    signed short mid;
    sigmed short fin;
    signed short re;
    char eval;
};char evaluate(int mid, int fin, int re);
int main(){
    struct test test[50];
    int i;
    int count = 0;
    for(i = 0;i < 50;i++){
        scanf("%d %d %d", &test[i].mid, &test[i].fin, &test[i].re);
        if(test[i].mid == -1 && test[i].fin == -1 && test[i].re == -1){
            break;
        }
        test[i].eval = evaluate(test[i].mid, test[i].fin, test[i].re);
        count++;
    }
    for(i = 0;i < count;i++){
        printf("%c\n", test[i].eval);
    }
    return 0;
}

char evaluate(int mid, int fin, int re){
    if(mid == -1 || fin == -1){
        return 'F';
    }
    if(mid + fin >= 80){
        return 'A';
    }
    else if(mid + fin >= 65){
        return 'B';
    }
    else if(mid + fin >= 50){
        return 'C';
    }
    else if(mid + fin >= 30){
        if(re >= 50){
            return 'C';
        }
        else{
            return 'D';
        }
    }
    else{
        return 'F';
    }
}


Compiler output:
main.c:5:5: error: expected specifier-qualifier-list before 'sigmed'
    5 |     sigmed short fin;
      |     ^~~~~~
main.c: In function 'main':
main.c:14:49: error: 'struct test' has no member named 'fin'
   14 |         scanf("%d %d %d", &test[i].mid, &test[i].fin, &test[i].re);
      |                                                 ^
main.c:14:63: error: 'struct test' has no member named 're'
   14 |         scanf("%d %d %d", &test[i].mid, &test[i].fin, &test[i].re);
      |                                                               ^
main.c:15:40: error: 'struct test' has no member named 'fin'
   15 |         if(test[i].mid == -1 && test[i].fin == -1 && test[i].re == -1){
      |                                        ^
main.c:15:61: error: 'struct test' has no member named 're'
   15 |         if(test[i].mid == -1 && test[i].fin == -1 && test[i].re == -1){
      |                                                             ^
main.c:18:16: error: 'struct test' has no member named 'eval'
   18 |         test[i].eval = evaluate(test[i].mid, test[i].fin, test[i].re);
      |                ^
main.c:18:53: error: 'struct test' has no member named 'fin'
   18 |         test[i].eval = evaluate(test[i].mid, test[i].fin, test[i].re);
      |                                                     ^
main.c:18:66: error: 'struct test' has no member named 're'
   18 |         test[i].eval = evaluate(test[i].mid, test[i].fin, test[i].re);
      |                                                                  ^
main.c:22:31: error: 'struct test' has no member named 'eval'
   22 |         printf("%c\n", test[i].eval);
      |                               ^
Language: C

#include<stdio.h>

struct test{
    signed short mid;
    signed short fin;
    signed short re;
    unsigned char eval;
};
unsigned char evaluate(signed short mid, signed short fin, unsigned short re);
int main(){
    struct test test[50];
    unsigned i;
    short unsigned count = 0;
    for(i = 0;i < 50;i++){
        scanf("%d %d %d", &test[i].mid, &test[i].fin, &test[i].re);
        if(test[i].mid == -1 && test[i].fin == -1 && test[i].re == -1){
            break;
        }
        test[i].eval = evaluate(test[i].mid, test[i].fin, test[i].re);
        count++;
    }
    for(i = 0;i < count;i++){
        printf("%c\n", test[i].eval);
    }
    return 0;
}

char evaluate(int mid, int fin, int re){
    if(mid == -1 || fin == -1){
        return 'F';
    }
    if(mid + fin >= 80){
        return 'A';
    }
    else if(mid + fin >= 65){
        return 'B';
    }
    else if(mid + fin >= 50){
        return 'C';
    }
    else if(mid + fin >= 30){
        if(re >= 50){
            return 'C';
        }
        else{
            return 'D';
        }
    }
    else{
        return 'F';
    }
}


Compiler output:
main.c:28:6: error: conflicting types for 'evaluate'; have 'char(int,  int,  int)'
   28 | char evaluate(int mid, int fin, int re){
      |      ^~~~~~~~
main.c:9:15: note: previous declaration of 'evaluate' with type 'unsigned char(short int,  short int,  short unsigned int)'
    9 | unsigned char evaluate(signed short mid, signed short fin, unsigned short re);
      |               ^~~~~~~~
Language: C

#include<stdio.h>

struct test{
    signed short mid;
    signed short fin;
    signed short re;
    unsigned char eval;
};
unsigned char evaluate(signed short mid, signed short fin, unsigned short re);
int main(){
    struct test test[50];
    unsigned i;
    short unsigned count = 0;
    for(i = 0;i < 50;i++){
        scanf("%d %d %d", &test[i].mid, &test[i].fin, &test[i].re);
        if(test[i].mid == -1 && test[i].fin == -1 && test[i].re == -1){
            break;
        }
        test[i].eval = evaluate(test[i].mid, test[i].fin, test[i].re);
        count++;
    }
    for(i = 0;i < count;i++){
        printf("%c\n", test[i].eval);
    }
    return 0;
}

char evaluate(signed short mid, signed short fin, unsigned short re){
    if(mid == -1 || fin == -1){
        return 'F';
    }
    if(mid + fin >= 80){
        return 'A';
    }
    else if(mid + fin >= 65){
        return 'B';
    }
    else if(mid + fin >= 50){
        return 'C';
    }
    else if(mid + fin >= 30){
        if(re >= 50){
            return 'C';
        }
        else{
            return 'D';
        }
    }
    else{
        return 'F';
    }
}


Compiler output:
main.c:28:6: error: conflicting types for 'evaluate'; have 'char(short int,  short int,  short unsigned int)'
   28 | char evaluate(signed short mid, signed short fin, unsigned short re){
      |      ^~~~~~~~
main.c:9:15: note: previous declaration of 'evaluate' with type 'unsigned char(short int,  short int,  short unsigned int)'
    9 | unsigned char evaluate(signed short mid, signed short fin, unsigned short re);
      |               ^~~~~~~~
Language: C

#include<stdio.h>

struct test{
    signed short mid;
    signed short fin;
    signed short re;
    unsigned char eval;
};
unsigned char evaluate(signed short mid, signed short fin, signed short re);
int main(){
    struct test test[50];
    unsigned short i;
    short unsigned count = 0;
    for(i = 0;i < 50;i++){
        scanf("%d %d %d", &test[i].mid, &test[i].fin, &test[i].re);
        if(test[i].mid == -1 && test[i].fin == -1 && test[i].re == -1){
            break;
        }
        test[i].eval = evaluate(test[i].mid, test[i].fin, test[i].re);
        count++;
    }
    for(i = 0;i < count;i++){
        printf("%c\n", test[i].eval);
    }
    return 0;
}

unsigned char evaluate(signed short mid, signed short fin, signed short re){
    singned short sum;
    unsigned char result;
    sum = mid + fin;
    if(mid == -1 || fin == -1){
        result = 'F';
    }
    else if(sum >= 80){
        result = 'A';
    }
    else if(sum >= 65){
        result = 'B';
    }
    else if(sum >= 50){
        result = 'C';
    }
    else if(sum >= 30){
        if(re >= 50){
            result = 'C';
        }
        else{
            result = 'D';
        }
    }
    else{
        result = 'F';
    }
    return result;
}


Compiler output:
main.c: In function 'evaluate':
main.c:29:5: error: 'singned' undeclared (first use in this function)
   29 |     singned short sum;
      |     ^~~~~~~
main.c:29:5: note: each undeclared identifier is reported only once for each function it appears in
main.c:29:12: error: expected ';' before 'short'
   29 |     singned short sum;
      |            ^~~~~~
      |            ;
main.c:31:5: error: 'sum' undeclared (first use in this function)
   31 |     sum = mid + fin;
      |     ^~~
Language: C

#include<stdio.h>

struct test{
    signed short mid;
    signed short fin;
    signed short re;
    unsigned char eval;
};

unsigned char evaluate(signed short mid, signed short fin, signed short re);

int main(){
    struct test test[50];
    unsigned short i;
    unsigned short count = 0;

    for(i = 0;i < 50;i++){
        scanf("%d %d %d", &test[i].mid, &test[i].fin, &test[i].re);
        if(test[i].mid == -1 && test[i].fin == -1 && test[i].re == -1){
            break;
        }
        test[i].eval = evaluate(test[i].mid, test[i].fin, test[i].re);
        count++;
    }

    for(i = 0;i < count;i++){
        printf("%c\n", test[i].eval);
    }

    return 0;
}

unsigned char evaluate(signed short mid, signed short fin, signed short re){
    signed short ssW_D_sum;
    unsigned char ubW_D_result;

    ssW_D_sum = mid + fin;

    if(mid == -1 || fin == -1){
        result = 'F';
    }
    else if(ssW_D_sum >= 80){
        ubW_D_result = 'A';
    }
    else if(ssW_D_sum >= 65){
        ubW_D_result = 'B';
    }
    else if(ssW_D_sum >= 50){
        ubW_D_result = 'C';
    }
    else if(ssW_D_sum >= 30){
        if(re >= 50){
            ubW_D_result = 'C';
        }
        else{
            ubW_D_result = 'D';
        }
    }
    else{
        ubW_D_result = 'F';
    }

    return ubW_D_result;
}


Compiler output:
main.c: In function 'evaluate':
main.c:40:9: error: 'result' undeclared (first use in this function)
   40 |         result = 'F';
      |         ^~~~~~
main.c:40:9: note: each undeclared identifier is reported only once for each function it appears in
Language: C

#include<stdio.h>

struct test_result{
    signed short ssW_D_mid;
    signed short ssW_D_fin;
    signed short ssW_D_re;
    unsigned char ubW_D_eval;
};

unsigned char evaluate(signed short ssW_D_mid, signed short ssW_D_fin, signed short ssW_D_re);

int main(){
    struct test_result test[50];
    unsigned short usW_C_i;
    unsigned short usW_C_count = 0;

    for(usW_C_i = 0;usW_C_i < 50;usW_C_i++){
        scanf("%d %d %d", &test[usW_C_i].ssW_D_mid, &test[usW_C_i].ssW_D_fin, &test[usW_C_i].ssW_D_re);
        if(test[usW_C_i].ssW_D_mid == -1 && test[usW_C_i].ssW_D_fin == -1 && test[usW_C_i].ssW_D_re == -1){
            break;
        }
        test[usW_C_i].ubW_D_eval = evaluate(test[usW_C_i].ssW_D_mid, test[usW_C_i].ssW_D_fin, test[usW_C_i].ssW_D_re);
        usW_C_count++;
    }

    for(usW_C_i = 0;usW_C_i < usW_C_count;usW_C_i++){
        printf("%c\n", test[usW_C_i].ubW_D_eval);
    }

    return 0;
}

unsigned char evaluate(signed short ssW_D_mid, signed short ssW_D_fin, signed short ssW_D_re){
    signed short ssW_D_sum;
    unsigned char ubW_D_result;

    ssW_D_sum = ssW_D_mid + ssW_D_fin;

    if(ssW_D_mid == -1 || ssW_D_fin == -1){
        ubW_D_result = 'F';
    }
    else if(ssW_D_sum >= 80){
        ubW_D_result = 'A';
    }
    else if(ssW_D_sum >= 65){
        ubW_D_result = 'B';
    }
    else if(ssW_D_sum >= 50){
        ubW_D_result = 'C';
    }
    else if(ssW_D_sum >= 30){
        if(re >= 50){
            ubW_D_result = 'C';
        }
        else{
            ubW_D_result = 'D';
        }
    }
    else{
        ubW_D_result = 'F';
    }

    return ubW_D_result;
}


Compiler output:
main.c: In function 'evaluate':
main.c:52:12: error: 're' undeclared (first use in this function)
   52 |         if(re >= 50){
      |            ^~
main.c:52:12: note: each undeclared identifier is reported only once for each function it appears in
Language: C

#include<stdio.h>
#define ARRAY_MAX 50
#define COUNT_RESET 0
#define RETURN 0
#define ARRAY_END -1
#define TEST_ABSENT -1
#define BORDER_A 80
#define BORDER_B 65
#define BORDER_C 50
#define BORDER_D 30

struct test_result{
    signed short ssW_D_mid;
    signed short ssW_D_fin;
    signed short ssW_D_re;
    unsigned char ubW_D_eval;
};

unsigned char s_EVALUATE(signed short ssW_D_mid, signed short ssW_D_fin, signed short ssW_D_re);

int main(){
    struct test_result test[50];
    unsigned short usW_C_i;
    unsigned short usW_C_count = 0;

    for(usW_C_i = 0;usW_C_i < 50;usW_C_i++){
        scanf("%d %d %d", &test[usW_C_i].ssW_D_mid, &test[usW_C_i].ssW_D_fin, &test[usW_C_i].ssW_D_re);
        if(test[usW_C_i].ssW_D_mid == -1 && test[usW_C_i].ssW_D_fin == -1 && test[usW_C_i].ssW_D_re == -1){
            break;
        }
        test[usW_C_i].ubW_D_eval = s_EVALUATE(test[usW_C_i].ssW_D_mid, test[usW_C_i].ssW_D_fin, test[usW_C_i].ssW_D_re);
        usW_C_count++;
    }

    for(usW_C_i = 0;usW_C_i < usW_C_count;usW_C_i++){
        printf("%c\n", test[usW_C_i].ubW_D_eval);
    }

    return 0;
}

unsigned char s_EVALUATE(signed short ssW_D_mid, signed short ssW_D_fin, signed short ssW_D_re){
    signed short ssW_D_sum;
    unsigned char ubW_D_result;

    ssW_D_sum = ssW_D_mid + ssW_D_fin;

    if(ssW_D_mid == -1 || ssW_D_fin == -1){
        ubW_D_result = 'F';
    }
    else if(ssW_D_sum >= 80){
        ubW_D_result = 'A';
    }
    else if(ssW_D_sum >= 65){
        ubW_D_result = 'B';
    }
    else if(ssW_D_sum >= 50){
        ubW_D_result = 'C';
    }
    else if(ssW_D_sum >= 30){
        if(re >= 50){
            ubW_D_result = 'C';
        }
        else{
            ubW_D_result = 'D';
        }
    }
    else{
        ubW_D_result = 'F';
    }

    return ubW_D_result;
}


Compiler output:
main.c: In function 's_EVALUATE':
main.c:61:12: error: 're' undeclared (first use in this function)
   61 |         if(re >= 50){
      |            ^~
main.c:61:12: note: each undeclared identifier is reported only once for each function it appears in
Language: C

#include<stdio.h>
#define ARRAY_MAX 50
#define COUNT_RESET 0
#define RETURN 0
#define ARRAY_END -1
#define TEST_ABSENT -1
#define BORDER_A 80
#define BORDER_B 65
#define BORDER_C 50
#define BORDER_D 30

struct test_result{
    signed short ssW_D_mid;
    signed short ssW_D_fin;
    signed short ssW_D_re;
    unsigned char ubW_D_eval;
};

unsigned char s_EVALUATE(struct test_result test);

int main(){
    struct test_result test[ARRAY_MAX];
    unsigned short usW_C_i;
    unsigned short usW_C_count = COUNT_RESET;

    for(usW_C_i = 0;usW_C_i < ARRAY_MAX;usW_C_i++){
        scanf("%d %d %d", &test[usW_C_i].ssW_D_mid, &test[usW_C_i].ssW_D_fin, &test[usW_C_i].ssW_D_re);
        if(test[usW_C_i].ssW_D_mid == -1 && test[usW_C_i].ssW_D_fin == -1 && test[usW_C_i].ssW_D_re == -1){
            break;
        }
        test[usW_C_i].ubW_D_eval = s_EVALUATE(test[i]);
        usW_C_count++;
    }

    for(usW_C_i = 0;usW_C_i < usW_C_count;usW_C_i++){
        printf("%c\n", test[usW_C_i].ubW_D_eval);
    }

    return 0;
}

unsigned char s_EVALUATE(struct test_result test){
    signed short ssW_D_sum;
    unsigned char ubW_D_result;

    ssW_D_sum = test.ssW_D_mid + test.ssW_D_fin;

    if(ssW_D_mid == -1 || ssW_D_fin == -1){
        ubW_D_result = 'F';
    }
    else if(ssW_D_sum >= 80){
        ubW_D_result = 'A';
    }
    else if(ssW_D_sum >= 65){
        ubW_D_result = 'B';
    }
    else if(ssW_D_sum >= 50){
        ubW_D_result = 'C';
    }
    else if(ssW_D_sum >= 30){
        if(test.ssW_D_re >= 50){
            ubW_D_result = 'C';
        }
        else{
            ubW_D_result = 'D';
        }
    }
    else{
        ubW_D_result = 'F';
    }

    return ubW_D_result;
}


Compiler output:
main.c: In function 'main':
main.c:31:52: error: 'i' undeclared (first use in this function)
   31 |         test[usW_C_i].ubW_D_eval = s_EVALUATE(test[i]);
      |                                                    ^
main.c:31:52: note: each undeclared identifier is reported only once for each function it appears in
main.c: In function 's_EVALUATE':
main.c:48:8: error: 'ssW_D_mid' undeclared (first use in this function); did you mean 'ssW_D_sum'?
   48 |     if(ssW_D_mid == -1 || ssW_D_fin == -1){
      |        ^~~~~~~~~
      |        ssW_D_sum
main.c:48:27: error: 'ssW_D_fin' undeclared (first use in this function); did you mean 'ssW_D_sum'?
   48 |     if(ssW_D_mid == -1 || ssW_D_fin == -1){
      |                           ^~~~~~~~~
      |                           ssW_D_sum