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

main(a){for(;~scanf("%c",&c;printf("%c",(c>96&&c<123)?c-32:c);exit(0);}

Compiler output:
main.c:1:1: error: return type defaults to 'int' [-Wimplicit-int]
    1 | main(a){for(;~scanf("%c",&c;printf("%c",(c>96&&c<123)?c-32:c);exit(0);}
      | ^~~~
main.c: In function 'main':
main.c:1:1: error: type of 'a' defaults to 'int' [-Wimplicit-int]
main.c:1:15: error: implicit declaration of function 'scanf' [-Wimplicit-function-declaration]
    1 | main(a){for(;~scanf("%c",&c;printf("%c",(c>96&&c<123)?c-32:c);exit(0);}
      |               ^~~~~
main.c:1:1: note: include '<stdio.h>' or provide a declaration of 'scanf'
  +++ |+#include <stdio.h>
    1 | main(a){for(;~scanf("%c",&c;printf("%c",(c>96&&c<123)?c-32:c);exit(0);}
main.c:1:15: warning: incompatible implicit declaration of built-in function 'scanf' [-Wbuiltin-declaration-mismatch]
    1 | main(a){for(;~scanf("%c",&c;printf("%c",(c>96&&c<123)?c-32:c);exit(0);}
      |               ^~~~~
main.c:1:15: note: include '<stdio.h>' or provide a declaration of 'scanf'
main.c:1:27: error: 'c' undeclared (first use in this function)
    1 | main(a){for(;~scanf("%c",&c;printf("%c",(c>96&&c<123)?c-32:c);exit(0);}
      |                           ^
main.c:1:27: note: each undeclared identifier is reported only once for each function it appears in
main.c:1:28: error: expected ')' before ';' token
    1 | main(a){for(;~scanf("%c",&c;printf("%c",(c>96&&c<123)?c-32:c);exit(0);}
      |                    ~       ^
      |                            )
main.c:1:71: error: expected ';' before '}' token
    1 | main(a){for(;~scanf("%c",&c;printf("%c",(c>96&&c<123)?c-32:c);exit(0);}
      |                                                                       ^
      |                                                                       ;
main.c:1:71: error: expected expression before '}' token
main.c:1:71: error: expected expression before '}' token
Language: C

main(a){for(;~scanf("%c",&a);printf("%c",a>96?a-32:a);}

Compiler output:
main.c:1:1: error: return type defaults to 'int' [-Wimplicit-int]
    1 | main(a){for(;~scanf("%c",&a);printf("%c",a>96?a-32:a);}
      | ^~~~
main.c: In function 'main':
main.c:1:1: error: type of 'a' defaults to 'int' [-Wimplicit-int]
main.c:1:15: error: implicit declaration of function 'scanf' [-Wimplicit-function-declaration]
    1 | main(a){for(;~scanf("%c",&a);printf("%c",a>96?a-32:a);}
      |               ^~~~~
main.c:1:1: note: include '<stdio.h>' or provide a declaration of 'scanf'
  +++ |+#include <stdio.h>
    1 | main(a){for(;~scanf("%c",&a);printf("%c",a>96?a-32:a);}
main.c:1:15: warning: incompatible implicit declaration of built-in function 'scanf' [-Wbuiltin-declaration-mismatch]
    1 | main(a){for(;~scanf("%c",&a);printf("%c",a>96?a-32:a);}
      |               ^~~~~
main.c:1:15: note: include '<stdio.h>' or provide a declaration of 'scanf'
main.c:1:30: error: implicit declaration of function 'printf' [-Wimplicit-function-declaration]
    1 | main(a){for(;~scanf("%c",&a);printf("%c",a>96?a-32:a);}
      |                              ^~~~~~
main.c:1:30: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:1:30: warning: incompatible implicit declaration of built-in function 'printf' [-Wbuiltin-declaration-mismatch]
main.c:1:30: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:1:54: error: expected ')' before ';' token
    1 | main(a){for(;~scanf("%c",&a);printf("%c",a>96?a-32:a);}
      |            ~                                         ^
      |                                                      )
main.c:1:55: error: expected expression before '}' token
    1 | main(a){for(;~scanf("%c",&a);printf("%c",a>96?a-32:a);}
      |                                                       ^
Language: C

main(a){for(;~a=getchar();putchar(a>96?a-32:a));}

Compiler output:
main.c:1:1: error: return type defaults to 'int' [-Wimplicit-int]
    1 | main(a){for(;~a=getchar();putchar(a>96?a-32:a));}
      | ^~~~
main.c: In function 'main':
main.c:1:1: error: type of 'a' defaults to 'int' [-Wimplicit-int]
main.c:1:17: error: implicit declaration of function 'getchar' [-Wimplicit-function-declaration]
    1 | main(a){for(;~a=getchar();putchar(a>96?a-32:a));}
      |                 ^~~~~~~
main.c:1:1: note: 'getchar' is defined in header '<stdio.h>'; this is probably fixable by adding '#include <stdio.h>'
  +++ |+#include <stdio.h>
    1 | main(a){for(;~a=getchar();putchar(a>96?a-32:a));}
main.c:1:16: error: lvalue required as left operand of assignment
    1 | main(a){for(;~a=getchar();putchar(a>96?a-32:a));}
      |                ^
main.c:1:27: error: implicit declaration of function 'putchar' [-Wimplicit-function-declaration]
    1 | main(a){for(;~a=getchar();putchar(a>96?a-32:a));}
      |                           ^~~~~~~
main.c:1:27: note: include '<stdio.h>' or provide a declaration of 'putchar'
Language: C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#define REP(i,a,b) for(i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)

int main(){
  int i;
  char str[1000];

  gets(str);
  rep(i,strlen(str)) if('a' <= str[i] && str[i] <= 'z') str[i] += 'A' - 'a';
  printf("%s",str);

  return 0;
}

Compiler output:
main.c: In function 'main':
main.c:13:3: error: implicit declaration of function 'gets'; did you mean 'fgets'? [-Wimplicit-function-declaration]
   13 |   gets(str);
      |   ^~~~
      |   fgets
Language: C

main(c){for(;~(c=getchar());n=!putchar(isalpha(c)?c^32:c));}

Compiler output:
main.c:1:1: error: return type defaults to 'int' [-Wimplicit-int]
    1 | main(c){for(;~(c=getchar());n=!putchar(isalpha(c)?c^32:c));}
      | ^~~~
main.c: In function 'main':
main.c:1:1: error: type of 'c' defaults to 'int' [-Wimplicit-int]
main.c:1:18: error: implicit declaration of function 'getchar' [-Wimplicit-function-declaration]
    1 | main(c){for(;~(c=getchar());n=!putchar(isalpha(c)?c^32:c));}
      |                  ^~~~~~~
main.c:1:1: note: 'getchar' is defined in header '<stdio.h>'; this is probably fixable by adding '#include <stdio.h>'
  +++ |+#include <stdio.h>
    1 | main(c){for(;~(c=getchar());n=!putchar(isalpha(c)?c^32:c));}
main.c:1:29: error: 'n' undeclared (first use in this function)
    1 | main(c){for(;~(c=getchar());n=!putchar(isalpha(c)?c^32:c));}
      |                             ^
main.c:1:29: note: each undeclared identifier is reported only once for each function it appears in
main.c:1:32: error: implicit declaration of function 'putchar' [-Wimplicit-function-declaration]
    1 | main(c){for(;~(c=getchar());n=!putchar(isalpha(c)?c^32:c));}
      |                                ^~~~~~~
main.c:1:32: note: include '<stdio.h>' or provide a declaration of 'putchar'
main.c:1:40: error: implicit declaration of function 'isalpha' [-Wimplicit-function-declaration]
    1 | main(c){for(;~(c=getchar());n=!putchar(isalpha(c)?c^32:c));}
      |                                        ^~~~~~~
main.c:1:1: note: include '<ctype.h>' or provide a declaration of 'isalpha'
  +++ |+#include <ctype.h>
    1 | main(c){for(;~(c=getchar());n=!putchar(isalpha(c)?c^32:c));}
Language: C

n;main(c){for(;n=~(c=getchar());putchar(toupper(c));}

Compiler output:
main.c:1:1: warning: data definition has no type or storage class
    1 | n;main(c){for(;n=~(c=getchar());putchar(toupper(c));}
      | ^
main.c:1:1: error: type defaults to 'int' in declaration of 'n' [-Wimplicit-int]
main.c:1:3: error: return type defaults to 'int' [-Wimplicit-int]
    1 | n;main(c){for(;n=~(c=getchar());putchar(toupper(c));}
      |   ^~~~
main.c: In function 'main':
main.c:1:3: error: type of 'c' defaults to 'int' [-Wimplicit-int]
main.c:1:22: error: implicit declaration of function 'getchar' [-Wimplicit-function-declaration]
    1 | n;main(c){for(;n=~(c=getchar());putchar(toupper(c));}
      |                      ^~~~~~~
main.c:1:1: note: 'getchar' is defined in header '<stdio.h>'; this is probably fixable by adding '#include <stdio.h>'
  +++ |+#include <stdio.h>
    1 | n;main(c){for(;n=~(c=getchar());putchar(toupper(c));}
main.c:1:33: error: implicit declaration of function 'putchar' [-Wimplicit-function-declaration]
    1 | n;main(c){for(;n=~(c=getchar());putchar(toupper(c));}
      |                                 ^~~~~~~
main.c:1:33: note: include '<stdio.h>' or provide a declaration of 'putchar'
main.c:1:41: error: implicit declaration of function 'toupper' [-Wimplicit-function-declaration]
    1 | n;main(c){for(;n=~(c=getchar());putchar(toupper(c));}
      |                                         ^~~~~~~
main.c:1:1: note: include '<ctype.h>' or provide a declaration of 'toupper'
  +++ |+#include <ctype.h>
    1 | n;main(c){for(;n=~(c=getchar());putchar(toupper(c));}
main.c:1:52: error: expected ')' before ';' token
    1 | n;main(c){for(;n=~(c=getchar());putchar(toupper(c));}
      |              ~                                     ^
      |                                                    )
main.c:1:53: error: expected expression before '}' token
    1 | n;main(c){for(;n=~(c=getchar());putchar(toupper(c));}
      |                                                     ^
Language: C

main(c){for(;c=toupper(getchar()),printf(&c));}

Compiler output:
main.c:1:1: error: return type defaults to 'int' [-Wimplicit-int]
    1 | main(c){for(;c=toupper(getchar()),printf(&c));}
      | ^~~~
main.c: In function 'main':
main.c:1:1: error: type of 'c' defaults to 'int' [-Wimplicit-int]
main.c:1:16: error: implicit declaration of function 'toupper' [-Wimplicit-function-declaration]
    1 | main(c){for(;c=toupper(getchar()),printf(&c));}
      |                ^~~~~~~
main.c:1:1: note: include '<ctype.h>' or provide a declaration of 'toupper'
  +++ |+#include <ctype.h>
    1 | main(c){for(;c=toupper(getchar()),printf(&c));}
main.c:1:24: error: implicit declaration of function 'getchar' [-Wimplicit-function-declaration]
    1 | main(c){for(;c=toupper(getchar()),printf(&c));}
      |                        ^~~~~~~
main.c:1:1: note: 'getchar' is defined in header '<stdio.h>'; this is probably fixable by adding '#include <stdio.h>'
  +++ |+#include <stdio.h>
    1 | main(c){for(;c=toupper(getchar()),printf(&c));}
main.c:1:35: error: implicit declaration of function 'printf' [-Wimplicit-function-declaration]
    1 | main(c){for(;c=toupper(getchar()),printf(&c));}
      |                                   ^~~~~~
main.c:1:35: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:1:35: warning: incompatible implicit declaration of built-in function 'printf' [-Wbuiltin-declaration-mismatch]
main.c:1:35: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:1:42: error: passing argument 1 of 'printf' from incompatible pointer type [-Wincompatible-pointer-types]
    1 | main(c){for(;c=toupper(getchar()),printf(&c));}
      |                                          ^~
      |                                          |
      |                                          int *
main.c:1:42: note: expected 'const char *' but argument is of type 'int *'
main.c:1:45: error: expected ';' before ')' token
    1 | main(c){for(;c=toupper(getchar()),printf(&c));}
      |                                             ^
      |                                             ;
Language: C

import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;
public class Main {
	public static void main(String[] args)
			throws java.io.IOException{
		Scanner scan = new Scanner(System.in);
		String str = scan.nextLine();
		System.out.println(str.toUpperCase());
}
}

Compiler output:
main.c:1:1: error: unknown type name 'import'
    1 | import java.io.*;
      | ^~~~~~
main.c:1:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '.' token
    1 | import java.io.*;
      |            ^
main.c:2:1: error: unknown type name 'import'
    2 | import java.util.*;
      | ^~~~~~
main.c:2:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '.' token
    2 | import java.util.*;
      |            ^
main.c:3:1: error: unknown type name 'import'
    3 | import java.math.*;
      | ^~~~~~
main.c:3:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '.' token
    3 | import java.math.*;
      |            ^
main.c:4:1: error: unknown type name 'import'
    4 | import java.lang.*;
      | ^~~~~~
main.c:4:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '.' token
    4 | import java.lang.*;
      |            ^
main.c:5:1: error: unknown type name 'public'
    5 | public class Main {
      | ^~~~~~
main.c:5:14: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'Main'
    5 | public class Main {
      |              ^~~~
Language: C

#include<stdio.h>
int main(){
	int str[512];
	int count=0;
	int buff=0;
	while((buff=getchar())!='\n'){
		if('a'<=buff&&buff<='z')str[count]=buff-32;
		else str[count]=buff;
		count++;
		printf("%c",str[count-1]);
	}
	printf("\n")
	return 0;
	
}

Compiler output:
main.c: In function 'main':
main.c:12:21: error: expected ';' before 'return'
   12 |         printf("\n")
      |                     ^
      |                     ;
   13 |         return 0;
      |         ~~~~~~
Language: C

#include<stdio.h>
//#include<conio.h>

int main(){
	int str[512];
	int count=0;
	int buff=0;
	setbuf(stdin,NULL);
	setbuf(stdout,NULL);
	while((buff=getch())!='\n'){
		if('a'<=buff&&buff<='z')str[count]=buff-32;
		else str[count]=buff;
		count++;
		printf("%c",str[count-1]);
		//system("cls");
	}
	printf("\n");
	return 0;
	
}

Compiler output:
main.c: In function 'main':
main.c:10:21: error: implicit declaration of function 'getch'; did you mean 'getc'? [-Wimplicit-function-declaration]
   10 |         while((buff=getch())!='\n'){
      |                     ^~~~~
      |                     getc
Language: C

#include <stdio.h>

int main(void) {
	int i;
	char buf[1024];
	gets (buf);
	for (i=0; buf[i] != 0; i++)
		if (buf[i] >= 'a' && buf[i] <= 'z')
			buf[i] -= ('a' - 'A');
	puts (buf);	
	return 0;
}

Compiler output:
main.c: In function 'main':
main.c:6:9: error: implicit declaration of function 'gets'; did you mean 'fgets'? [-Wimplicit-function-declaration]
    6 |         gets (buf);
      |         ^~~~
      |         fgets
Language: C

#include <stdio.h>

int main(void) {
	int i;
	char buf[1024];
	gets (buf);
	for (i=0; buf[i] != 0; i++){
		if (buf[i] >= 'a' && buf[i] <= 'z') buf[i] -= ('a' - 'A');
	}
	puts (buf);	
	return 0;
}

Compiler output:
main.c: In function 'main':
main.c:6:9: error: implicit declaration of function 'gets'; did you mean 'fgets'? [-Wimplicit-function-declaration]
    6 |         gets (buf);
      |         ^~~~
      |         fgets
Language: C

#include <stdio.h>
#include <string.h>

const int N = 1000005;

char text[N];

int main() {
	while (gets(text)) {
		int len = strlen(text);
		for (int i=0; i<len; ++i) {
			if (text[i] >= 'a' && text[i] <= 'z') text[i] = text[i] - 'a' + 'A';
		}
		printf ("%s\n", text);
	}
	return 0;
}

Compiler output:
main.c:6:6: error: variably modified 'text' at file scope
    6 | char text[N];
      |      ^~~~
main.c: In function 'main':
main.c:9:16: error: implicit declaration of function 'gets'; did you mean 'fgets'? [-Wimplicit-function-declaration]
    9 |         while (gets(text)) {
      |                ^~~~
      |                fgets
Language: C

#include <stdio.h>
#include <string.h>

const int N = 1000005;

char text[N];

int main() {
	while (gets(text)) {
		int i, len = strlen(text);
		for (i=0; i<len; ++i) {
			if (text[i] >= 'a' && text[i] <= 'z') text[i] = text[i] - 'a' + 'A';
		}
		printf ("%s\n", text);
	}
	return 0;
}

Compiler output:
main.c:6:6: error: variably modified 'text' at file scope
    6 | char text[N];
      |      ^~~~
main.c: In function 'main':
main.c:9:16: error: implicit declaration of function 'gets'; did you mean 'fgets'? [-Wimplicit-function-declaration]
    9 |         while (gets(text)) {
      |                ^~~~
      |                fgets
Language: C

#include<stdio.h>
#include<string>

int main()
{
	char s;
	while(scanf("%c",&s)!=EOF)
		printf("%c",toupper(s));
	printf("\n");
}

Compiler output:
main.c:2:9: fatal error: string: No such file or directory
    2 | #include<string>
      |         ^~~~~~~~
compilation terminated.
Language: C

#include<stdio.h>
int main(void)
{
	char c;
	printf("英文＝");
	scanf("%s",&c);
	c=(char)getchar();
	if(c >= 'A' && c <= 'Z')
		c += 'a' - 'A';
		else
		c -='a' - 'A';
	else
		c%s'a' - 'A';
	printf("変換後は%s\n",c);
	return 0;
}

Compiler output:
main.c: In function 'main':
main.c:12:9: error: 'else' without a previous 'if'
   12 |         else
      |         ^~~~
main.c:13:19: error: 's' undeclared (first use in this function)
   13 |                 c%s'a' - 'A';
      |                   ^
main.c:13:19: note: each undeclared identifier is reported only once for each function it appears in
main.c:13:20: error: expected ';' before 'a'
   13 |                 c%s'a' - 'A';
      |                    ^~~
      |                    ;
Language: C

void main(n){
char s[999];
gets(s);
for(i=0;s[i];i++)putchar(s[i]>='a'&&s[i]<='z'?s[i]+'A'-'a':s[i]);
puts("");
}

Compiler output:
main.c: In function 'main':
main.c:1:6: error: type of 'n' defaults to 'int' [-Wimplicit-int]
    1 | void main(n){
      |      ^~~~
main.c:3:1: error: implicit declaration of function 'gets' [-Wimplicit-function-declaration]
    3 | gets(s);
      | ^~~~
main.c:4:5: error: 'i' undeclared (first use in this function)
    4 | for(i=0;s[i];i++)putchar(s[i]>='a'&&s[i]<='z'?s[i]+'A'-'a':s[i]);
      |     ^
main.c:4:5: note: each undeclared identifier is reported only once for each function it appears in
main.c:4:18: error: implicit declaration of function 'putchar' [-Wimplicit-function-declaration]
    4 | for(i=0;s[i];i++)putchar(s[i]>='a'&&s[i]<='z'?s[i]+'A'-'a':s[i]);
      |                  ^~~~~~~
main.c:1:1: note: include '<stdio.h>' or provide a declaration of 'putchar'
  +++ |+#include <stdio.h>
    1 | void main(n){
main.c:5:1: error: implicit declaration of function 'puts' [-Wimplicit-function-declaration]
    5 | puts("");
      | ^~~~
main.c:5:1: note: include '<stdio.h>' or provide a declaration of 'puts'
Language: C

int main(n){
char s[999];
gets(s);
for(i=0;s[i];i++)putchar(s[i]>='a'&&s[i]<='z'?s[i]+'A'-'a':s[i]);
puts("");
return 0;
}

Compiler output:
main.c: In function 'main':
main.c:1:5: error: type of 'n' defaults to 'int' [-Wimplicit-int]
    1 | int main(n){
      |     ^~~~
main.c:3:1: error: implicit declaration of function 'gets' [-Wimplicit-function-declaration]
    3 | gets(s);
      | ^~~~
main.c:4:5: error: 'i' undeclared (first use in this function)
    4 | for(i=0;s[i];i++)putchar(s[i]>='a'&&s[i]<='z'?s[i]+'A'-'a':s[i]);
      |     ^
main.c:4:5: note: each undeclared identifier is reported only once for each function it appears in
main.c:4:18: error: implicit declaration of function 'putchar' [-Wimplicit-function-declaration]
    4 | for(i=0;s[i];i++)putchar(s[i]>='a'&&s[i]<='z'?s[i]+'A'-'a':s[i]);
      |                  ^~~~~~~
main.c:1:1: note: include '<stdio.h>' or provide a declaration of 'putchar'
  +++ |+#include <stdio.h>
    1 | int main(n){
main.c:5:1: error: implicit declaration of function 'puts' [-Wimplicit-function-declaration]
    5 | puts("");
      | ^~~~
main.c:5:1: note: include '<stdio.h>' or provide a declaration of 'puts'
Language: C

#include <stdio.h>

int main()
{
	char a[65535];
	int i;
	
	for(i=0;;i++){
                if(scanf("%c",a+i)==EOF){
                      t=i;break;
                }
	for(i=0;i<t;i++){
		if(a[i]>96&&a[i]<123){
			a[i]-=32;
		}
	}
	printf(a);
	printf("\n");
	return 0;
}

		

Compiler output:
main.c: In function 'main':
main.c:10:23: error: 't' undeclared (first use in this function)
   10 |                       t=i;break;
      |                       ^
main.c:10:23: note: each undeclared identifier is reported only once for each function it appears in
main.c:20:1: error: expected declaration or statement at end of input
   20 | }
      | ^
Language: C

#include <stdio.h>

int main()
{
	char a[65535];
	int i,t;
	
	for(i=0;;i++){
                if(scanf("%c",a+i)==EOF){
                      t=i;break;
                }
	for(i=0;i<t;i++){
		if(a[i]>96&&a[i]<123){
			a[i]-=32;
		}
	}
	printf(a);
	printf("\n");
	return 0;
}

		

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

main(){ char s; while(scanf("%c" ,&s)!=EOF)printf("%c",toupper(s));return 0;}

Compiler output:
main.c:1:1: error: return type defaults to 'int' [-Wimplicit-int]
    1 | main(){ char s; while(scanf("%c" ,&s)!=EOF)printf("%c",toupper(s));return 0;}
      | ^~~~
main.c: In function 'main':
main.c:1:23: error: implicit declaration of function 'scanf' [-Wimplicit-function-declaration]
    1 | main(){ char s; while(scanf("%c" ,&s)!=EOF)printf("%c",toupper(s));return 0;}
      |                       ^~~~~
main.c:1:1: note: include '<stdio.h>' or provide a declaration of 'scanf'
  +++ |+#include <stdio.h>
    1 | main(){ char s; while(scanf("%c" ,&s)!=EOF)printf("%c",toupper(s));return 0;}
main.c:1:23: warning: incompatible implicit declaration of built-in function 'scanf' [-Wbuiltin-declaration-mismatch]
    1 | main(){ char s; while(scanf("%c" ,&s)!=EOF)printf("%c",toupper(s));return 0;}
      |                       ^~~~~
main.c:1:23: note: include '<stdio.h>' or provide a declaration of 'scanf'
main.c:1:40: error: 'EOF' undeclared (first use in this function)
    1 | main(){ char s; while(scanf("%c" ,&s)!=EOF)printf("%c",toupper(s));return 0;}
      |                                        ^~~
main.c:1:40: note: 'EOF' is defined in header '<stdio.h>'; this is probably fixable by adding '#include <stdio.h>'
main.c:1:40: note: each undeclared identifier is reported only once for each function it appears in
main.c:1:44: error: implicit declaration of function 'printf' [-Wimplicit-function-declaration]
    1 | main(){ char s; while(scanf("%c" ,&s)!=EOF)printf("%c",toupper(s));return 0;}
      |                                            ^~~~~~
main.c:1:44: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:1:44: warning: incompatible implicit declaration of built-in function 'printf' [-Wbuiltin-declaration-mismatch]
main.c:1:44: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:1:56: error: implicit declaration of function 'toupper' [-Wimplicit-function-declaration]
    1 | main(){ char s; while(scanf("%c" ,&s)!=EOF)printf("%c",toupper(s));return 0;}
      |                                                        ^~~~~~~
main.c:1:1: note: include '<ctype.h>' or provide a declaration of 'toupper'
  +++ |+#include <ctype.h>
    1 | main(){ char s; while(scanf("%c" ,&s)!=EOF)printf("%c",toupper(s));return 0;}
Language: C

#include<stdio.h>
int main(void){
    int a;
    while((a=getchat())!=EOF){
        if(a>='a' && a<='z'){
            putchar(a-'a'+'A');
        }else{
            putchar(a);
        }
    }
    printf ("\n");
    return 0;
}

Compiler output:
main.c: In function 'main':
main.c:4:14: error: implicit declaration of function 'getchat'; did you mean 'getchar'? [-Wimplicit-function-declaration]
    4 |     while((a=getchat())!=EOF){
      |              ^~~~~~~
      |              getchar
Language: C

#include<stdio.h>

int main(){
	int i;
	char str[100]={};
	gets(str);
	for(i=0;i<100;i++){
	if(str[i]>=97 && str[i]<=122){
	str[i]=str[i]-32;
	}
		if(str[i]==0){
			str[i]=32;
		}
	}
	puts(str);
	puts();
	return 0;	
}

Compiler output:
main.c: In function 'main':
main.c:6:9: error: implicit declaration of function 'gets'; did you mean 'fgets'? [-Wimplicit-function-declaration]
    6 |         gets(str);
      |         ^~~~
      |         fgets
main.c:16:9: error: too few arguments to function 'puts'
   16 |         puts();
      |         ^~~~
In file included from main.c:1:
/usr/include/stdio.h:714:12: note: declared here
  714 | extern int puts (const char *__s);
      |            ^~~~
Language: C

int main(){
	
	char a;
	while(scanf("%c",&a)!=EOF)
		if(a<='a'&&a>='z')
			printf("%c",a-'a'+'A');
		else
			printf("%c",a);
	return 0;
}

Compiler output:
main.c: In function 'main':
main.c:4:15: error: implicit declaration of function 'scanf' [-Wimplicit-function-declaration]
    4 |         while(scanf("%c",&a)!=EOF)
      |               ^~~~~
main.c:1:1: note: include '<stdio.h>' or provide a declaration of 'scanf'
  +++ |+#include <stdio.h>
    1 | int main(){
main.c:4:15: warning: incompatible implicit declaration of built-in function 'scanf' [-Wbuiltin-declaration-mismatch]
    4 |         while(scanf("%c",&a)!=EOF)
      |               ^~~~~
main.c:4:15: note: include '<stdio.h>' or provide a declaration of 'scanf'
main.c:4:31: error: 'EOF' undeclared (first use in this function)
    4 |         while(scanf("%c",&a)!=EOF)
      |                               ^~~
main.c:4:31: note: 'EOF' is defined in header '<stdio.h>'; this is probably fixable by adding '#include <stdio.h>'
main.c:4:31: note: each undeclared identifier is reported only once for each function it appears in
main.c:6:25: error: implicit declaration of function 'printf' [-Wimplicit-function-declaration]
    6 |                         printf("%c",a-'a'+'A');
      |                         ^~~~~~
main.c:6:25: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:6:25: warning: incompatible implicit declaration of built-in function 'printf' [-Wbuiltin-declaration-mismatch]
main.c:6:25: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:8:25: warning: incompatible implicit declaration of built-in function 'printf' [-Wbuiltin-declaration-mismatch]
    8 |                         printf("%c",a);
      |                         ^~~~~~
main.c:8:25: note: include '<stdio.h>' or provide a declaration of 'printf'
Language: C

#include <stdio.h>

int main(void)
{
	int a, b;
	char c;
	
	a = 0;
	while (scanf("%c", &c) != EOF){
		scanf("%c", &c);
		str[a] = c;
		if (c >= 'a' && c <= 'z') {
			c -= 0x20;
		}
		printf("%c", c);
	}
	
	printf("\n");
	
	return (0);
}	

Compiler output:
main.c: In function 'main':
main.c:11:17: error: 'str' undeclared (first use in this function)
   11 |                 str[a] = c;
      |                 ^~~
main.c:11:17: note: each undeclared identifier is reported only once for each function it appears in
Language: C

#include <stdio.h>
int main(){
    char c;
    while(scanf("%c") != EOF){
        if('a'<=c && c <= 'z')
            putchar(c -= 32);
    }

    reutnrn 0;
}

Compiler output:
main.c: In function 'main':
main.c:9:5: error: 'reutnrn' undeclared (first use in this function)
    9 |     reutnrn 0;
      |     ^~~~~~~
main.c:9:5: note: each undeclared identifier is reported only once for each function it appears in
main.c:9:12: error: expected ';' before numeric constant
    9 |     reutnrn 0;
      |            ^~
      |            ;
Language: C

main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32);)}

Compiler output:
main.c:1:1: error: return type defaults to 'int' [-Wimplicit-int]
    1 | main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32);)}
      | ^~~~
main.c: In function 'main':
main.c:1:1: error: type of 'c' defaults to 'int' [-Wimplicit-int]
main.c:1:15: error: implicit declaration of function 'scanf' [-Wimplicit-function-declaration]
    1 | main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32);)}
      |               ^~~~~
main.c:1:1: note: include '<stdio.h>' or provide a declaration of 'scanf'
  +++ |+#include <stdio.h>
    1 | main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32);)}
main.c:1:15: warning: incompatible implicit declaration of built-in function 'scanf' [-Wbuiltin-declaration-mismatch]
    1 | main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32);)}
      |               ^~~~~
main.c:1:15: note: include '<stdio.h>' or provide a declaration of 'scanf'
main.c:1:33: error: implicit declaration of function 'printf' [-Wimplicit-function-declaration]
    1 | main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32);)}
      |                                 ^~~~~~
main.c:1:33: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:1:33: warning: incompatible implicit declaration of built-in function 'printf' [-Wbuiltin-declaration-mismatch]
main.c:1:33: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:1:57: error: expected ')' before ';' token
    1 | main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32);)}
      |            ~                                            ^
      |                                                         )
main.c:1:59: error: expected expression before '}' token
    1 | main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32);)}
      |                                                           ^
Language: C

main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32))}

Compiler output:
main.c:1:1: error: return type defaults to 'int' [-Wimplicit-int]
    1 | main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32))}
      | ^~~~
main.c: In function 'main':
main.c:1:1: error: type of 'c' defaults to 'int' [-Wimplicit-int]
main.c:1:15: error: implicit declaration of function 'scanf' [-Wimplicit-function-declaration]
    1 | main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32))}
      |               ^~~~~
main.c:1:1: note: include '<stdio.h>' or provide a declaration of 'scanf'
  +++ |+#include <stdio.h>
    1 | main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32))}
main.c:1:15: warning: incompatible implicit declaration of built-in function 'scanf' [-Wbuiltin-declaration-mismatch]
    1 | main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32))}
      |               ^~~~~
main.c:1:15: note: include '<stdio.h>' or provide a declaration of 'scanf'
main.c:1:33: error: implicit declaration of function 'printf' [-Wimplicit-function-declaration]
    1 | main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32))}
      |                                 ^~~~~~
main.c:1:33: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:1:33: warning: incompatible implicit declaration of built-in function 'printf' [-Wbuiltin-declaration-mismatch]
main.c:1:33: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:1:58: error: expected expression before '}' token
    1 | main(c){for(;~scanf("%c",&c);c=!printf("%c",c-(c>96)*32))}
      |                                                          ^
Language: C

#include <stdio.h>
int main()
{
    char a[2114];
    gets(a);
    _mbsupr(a);
    printf("%s\n",a);
    return 0;
}

Compiler output:
main.c: In function 'main':
main.c:5:5: error: implicit declaration of function 'gets'; did you mean 'fgets'? [-Wimplicit-function-declaration]
    5 |     gets(a);
      |     ^~~~
      |     fgets
main.c:6:5: error: implicit declaration of function '_mbsupr' [-Wimplicit-function-declaration]
    6 |     _mbsupr(a);
      |     ^~~~~~~
Language: C

#include <stdio.h>
#include <mbstring.h>
int main()
{
    char a[2114];
    gets(a);
    _mbsupr(a);
    printf("%s\n",a);
    return 0;
}

Compiler output:
main.c:2:10: fatal error: mbstring.h: No such file or directory
    2 | #include <mbstring.h>
      |          ^~~~~~~~~~~~
compilation terminated.
Language: C

#include <stdio.h>
#include <mbstring.h>
int main()
{
    char a[2114];
    int i = 0;
    scanf("%s",a);
    while(1){
        if(a[i] == '\0')break;
        a[i] = a[i] - 32;
        i++;
    }
    printf("%s\n",a);
    return 0;
}

Compiler output:
main.c:2:10: fatal error: mbstring.h: No such file or directory
    2 | #include <mbstring.h>
      |          ^~~~~~~~~~~~
compilation terminated.
Language: C

#include <stdio.h>
int main()
{
    char a[2114];
    int i = 0;
    scanf("%s",a);
    while(1){
        if(a[i] == '\0')break;
        a[i] = a[i] - 32;
        i++;
    }
    printf("%s\n",a);
    return 0;
}
]

Compiler output:
main.c:15:1: error: expected identifier or '(' before ']' token
   15 | ]
      | ^
Language: C++

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main() {
	string a;
	getline(cin, a);
	transform(a.begin(), a.end(), a.begin(), toupper);
	cout << a;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:8:18: error: no matching function for call to 'transform(std::__cxx11::basic_string<char>::iterator, std::__cxx11::basic_string<char>::iterator, std::__cxx11::basic_string<char>::iterator, <unresolved overloaded function type>)'
    8 |         transform(a.begin(), a.end(), a.begin(), toupper);
      |         ~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:61,
                 from a.cc:3:
/usr/include/c++/14/bits/stl_algo.h:4209:5: note: candidate: 'template<class _IIter, class _OIter, class _UnaryOperation> _OIter std::transform(_IIter, _IIter, _OIter, _UnaryOperation)'
 4209 |     transform(_InputIterator __first, _InputIterator __last,
      |     ^~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4209:5: note:   template argument deduction/substitution failed:
a.cc:8:18: note:   couldn't deduce template parameter '_UnaryOperation'
    8 |         transform(a.begin(), a.end(), a.begin(), toupper);
      |         ~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4247:5: note: candidate: 'template<class _IIter1, class _IIter2, class _OIter, class _BinaryOperation> _OIter std::transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation)'
 4247 |     transform(_InputIterator1 __first1, _InputIterator1 __last1,
      |     ^~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4247:5: note:   candidate expects 5 arguments, 4 provided
In file included from /usr/include/c++/14/algorithm:86:
/usr/include/c++/14/pstl/glue_algorithm_defs.h:156:1: note: candidate: 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> std::transform(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _UnaryOperation)'
  156 | transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
      | ^~~~~~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:156:1: note:   candidate expects 5 arguments, 4 provided
/usr/include/c++/14/pstl/glue_algorithm_defs.h:162:1: note: candidate: 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator, class _BinaryOperation> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> std::transform(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator, _BinaryOperation)'
  162 | transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      | ^~~~~~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:162:1: note:   candidate expects 6 arguments, 4 provided
Language: C++

//↓template↓

#include "bits/stdc++.h"
using namespace std;
#define Would
#define you
#define all(n)  n.begin(),n.end()
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
const double pi = acos(-1);
const int SIZE = 1 << 17;
int dx[] = { 1,0,-1,0 }, dy[] = { 0,1,0,-1 }, alp[30];
long long fac[200005], finv[200005], inv[200005];
vector<long long>dij;
struct edge { long long to, cost; };
vector<vector<edge> >G;

long long mod_pow(long long a, long long b) {
	long long res = 1, mul = a;
	for (int i = 0; i < 31; ++i) {
		if (b >> i & 1) {
			res *= mul;
			res %= MOD;
		}
		mul = (mul * mul) % MOD;
	}

	return res;
}

void addedge(int from, int to, int cost) {
	G[from].push_back({ to,cost });
	G[to].push_back({ from,cost });
}

//↑template↑

int main() {
	string h;
	getline(cin, s);
	transform(all(h), h.begin(), ::toupper);
	cout << h << endl;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:40:22: error: 's' was not declared in this scope
   40 |         getline(cin, s);
      |                      ^
Language: C++

#include <iostream>
#include <strign>
#include <cctype>
using namespace std;

int main(){
    string s;
    cin>>s;
    for(char c:s){
        cout << toupper(c);
    }
    cout<<endl;
}

Compiler output:
a.cc:2:10: fatal error: strign: No such file or directory
    2 | #include <strign>
      |          ^~~~~~~~
compilation terminated.
Language: C++

#include<iostream>
#include<string>
#include<algorithm>


using namespace std;


int main(){
	string str;

	getline(cin, str);
	transform(str.begin(), str.end(), str.begin(),toupper);
	cout << str << endl;


}

Compiler output:
a.cc: In function 'int main()':
a.cc:13:18: error: no matching function for call to 'transform(std::__cxx11::basic_string<char>::iterator, std::__cxx11::basic_string<char>::iterator, std::__cxx11::basic_string<char>::iterator, <unresolved overloaded function type>)'
   13 |         transform(str.begin(), str.end(), str.begin(),toupper);
      |         ~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:61,
                 from a.cc:3:
/usr/include/c++/14/bits/stl_algo.h:4209:5: note: candidate: 'template<class _IIter, class _OIter, class _UnaryOperation> _OIter std::transform(_IIter, _IIter, _OIter, _UnaryOperation)'
 4209 |     transform(_InputIterator __first, _InputIterator __last,
      |     ^~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4209:5: note:   template argument deduction/substitution failed:
a.cc:13:18: note:   couldn't deduce template parameter '_UnaryOperation'
   13 |         transform(str.begin(), str.end(), str.begin(),toupper);
      |         ~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4247:5: note: candidate: 'template<class _IIter1, class _IIter2, class _OIter, class _BinaryOperation> _OIter std::transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation)'
 4247 |     transform(_InputIterator1 __first1, _InputIterator1 __last1,
      |     ^~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4247:5: note:   candidate expects 5 arguments, 4 provided
In file included from /usr/include/c++/14/algorithm:86:
/usr/include/c++/14/pstl/glue_algorithm_defs.h:156:1: note: candidate: 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> std::transform(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _UnaryOperation)'
  156 | transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
      | ^~~~~~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:156:1: note:   candidate expects 5 arguments, 4 provided
/usr/include/c++/14/pstl/glue_algorithm_defs.h:162:1: note: candidate: 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator, class _BinaryOperation> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> std::transform(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator, _BinaryOperation)'
  162 | transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      | ^~~~~~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:162:1: note:   candidate expects 6 arguments, 4 provided
Language: C++

#include<iostream>
#include<string>
#include<algorithm>


using namespace std;


int main(){
	string str;

	getline(cin, str);
	transform(str.begin(), str.end(), str.begin(), toupper);
	cout << str << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:13:18: error: no matching function for call to 'transform(std::__cxx11::basic_string<char>::iterator, std::__cxx11::basic_string<char>::iterator, std::__cxx11::basic_string<char>::iterator, <unresolved overloaded function type>)'
   13 |         transform(str.begin(), str.end(), str.begin(), toupper);
      |         ~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:61,
                 from a.cc:3:
/usr/include/c++/14/bits/stl_algo.h:4209:5: note: candidate: 'template<class _IIter, class _OIter, class _UnaryOperation> _OIter std::transform(_IIter, _IIter, _OIter, _UnaryOperation)'
 4209 |     transform(_InputIterator __first, _InputIterator __last,
      |     ^~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4209:5: note:   template argument deduction/substitution failed:
a.cc:13:18: note:   couldn't deduce template parameter '_UnaryOperation'
   13 |         transform(str.begin(), str.end(), str.begin(), toupper);
      |         ~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4247:5: note: candidate: 'template<class _IIter1, class _IIter2, class _OIter, class _BinaryOperation> _OIter std::transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation)'
 4247 |     transform(_InputIterator1 __first1, _InputIterator1 __last1,
      |     ^~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4247:5: note:   candidate expects 5 arguments, 4 provided
In file included from /usr/include/c++/14/algorithm:86:
/usr/include/c++/14/pstl/glue_algorithm_defs.h:156:1: note: candidate: 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> std::transform(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _UnaryOperation)'
  156 | transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
      | ^~~~~~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:156:1: note:   candidate expects 5 arguments, 4 provided
/usr/include/c++/14/pstl/glue_algorithm_defs.h:162:1: note: candidate: 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator, class _BinaryOperation> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> std::transform(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator, _BinaryOperation)'
  162 | transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      | ^~~~~~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:162:1: note:   candidate expects 6 arguments, 4 provided
Language: C++

#include<iostream>
#include<string>
#include<algorithm>
#include<cctype>


using namespace std;


int main(){
	string str;

	getline(cin, str);
	transform(str.begin(), str.end(), str.begin(), toupper);
	cout << str << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:14:18: error: no matching function for call to 'transform(std::__cxx11::basic_string<char>::iterator, std::__cxx11::basic_string<char>::iterator, std::__cxx11::basic_string<char>::iterator, <unresolved overloaded function type>)'
   14 |         transform(str.begin(), str.end(), str.begin(), toupper);
      |         ~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:61,
                 from a.cc:3:
/usr/include/c++/14/bits/stl_algo.h:4209:5: note: candidate: 'template<class _IIter, class _OIter, class _UnaryOperation> _OIter std::transform(_IIter, _IIter, _OIter, _UnaryOperation)'
 4209 |     transform(_InputIterator __first, _InputIterator __last,
      |     ^~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4209:5: note:   template argument deduction/substitution failed:
a.cc:14:18: note:   couldn't deduce template parameter '_UnaryOperation'
   14 |         transform(str.begin(), str.end(), str.begin(), toupper);
      |         ~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4247:5: note: candidate: 'template<class _IIter1, class _IIter2, class _OIter, class _BinaryOperation> _OIter std::transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation)'
 4247 |     transform(_InputIterator1 __first1, _InputIterator1 __last1,
      |     ^~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4247:5: note:   candidate expects 5 arguments, 4 provided
In file included from /usr/include/c++/14/algorithm:86:
/usr/include/c++/14/pstl/glue_algorithm_defs.h:156:1: note: candidate: 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> std::transform(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _UnaryOperation)'
  156 | transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
      | ^~~~~~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:156:1: note:   candidate expects 5 arguments, 4 provided
/usr/include/c++/14/pstl/glue_algorithm_defs.h:162:1: note: candidate: 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator, class _BinaryOperation> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> std::transform(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator, _BinaryOperation)'
  162 | transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      | ^~~~~~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:162:1: note:   candidate expects 6 arguments, 4 provided
Language: C++

#include<stdio.h>
#include<string.h>
#include<ctype.h>

int mian(void){
	int len,cut_i;
	char str[1000];

	scanf("%[a-z .]",str);

	len = strlen(str);

	for(cut_i=0; cut_i<len; cut_i++){
		str[cut_i] = tolower(str[cut_i]);
	}
	
	puts(str);

	return 0;
}

Compiler output:
/usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/Scrt1.o: in function `_start':
(.text+0x17): undefined reference to `main'
collect2: error: ld returned 1 exit status