stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main ()

{

    char ch;

    cin>>ch;



    char c;

    c=ch+1;

    cout<<c<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.341413619408311x):
#include <stdio.h>



int main (){

	

	char k;

	scanf("%c",&k);

	char maipulasi=k+1;

	printf("%c",k +1);

	

	

	return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;



int main() {

char c;

cin>>c;

c+=1;

cout<<c;

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.321630038473499x):
#include <stdio.h>



int main (){

	

	char k;

	scanf("%c",&k);

	char maipulasi=k+1;

	printf("%c",k +1);

	

	

	return 0;

}
// Slower C++ solution:
#include <iostream>



using namespace std;



int main()

{

    char a;

    cin >> a;

    cout << char (a+1);



    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.322288141681136x):
#include <stdio.h>





int main ()

{

char K;



scanf ("%c", &K);



K=K+1;

printf("%c", K);







	return 0;

	}
// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;



int main()

{

    char a;

    scanf("%c",&a);

    printf("%c",a+1);

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.283610569793421x):
#include <stdio.h>





int main ()

{

char K;



scanf ("%c", &K);



K=K+1;

printf("%c", K);







	return 0;

	}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main ()

{

    char ch;

    cin>>ch;



    char c;

    c=ch+1;

    cout<<c<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.34218406537682x):
#include <stdio.h>





int main ()

{

char K;



scanf ("%c", &K);



K=K+1;

printf("%c", K);







	return 0;

	}
// Slower C++ solution:
#include <iostream>

using namespace std;



int main() {

char c;

cin>>c;

c+=1;

cout<<c;

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.32239763085656x):
#include <stdio.h>





int main ()

{

char K;



scanf ("%c", &K);



K=K+1;

printf("%c", K);







	return 0;

	}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main()

{

	char a;

	cin>>a;

	printf("%c",a+1);

} 

// Faster C++ solution for the same problem (measured speedup: 5.32169746543121x):
#include <stdio.h>





int main ()

{

char K;



scanf ("%c", &K);



K=K+1;

printf("%c", K);







	return 0;

	}
// Slower C++ solution:
#include <iostream>



using namespace std;



int main()

{

    char a;

    cin >> a;

    cout << char (a+1);



    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.321520565088524x):
#include<stdio.h>



int main (){

	char huruf;

	

	scanf ("%c", &huruf);

	printf ("%c",huruf+1);

 

 	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;



int main()

{

    char a;

    scanf("%c",&a);

    printf("%c",a+1);

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.28284857125259x):
#include<stdio.h>



int main (){

	char huruf;

	

	scanf ("%c", &huruf);

	printf ("%c",huruf+1);

 

 	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main ()

{

    char ch;

    cin>>ch;



    char c;

    c=ch+1;

    cout<<c<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.341413619408311x):
#include<stdio.h>



int main (){

	char huruf;

	

	scanf ("%c", &huruf);

	printf ("%c",huruf+1);

 

 	return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;



int main() {

char c;

cin>>c;

c+=1;

cout<<c;

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.321630038473499x):
#include<stdio.h>



int main (){

	char huruf;

	

	scanf ("%c", &huruf);

	printf ("%c",huruf+1);

 

 	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main()

{

	char a;

	cin>>a;

	printf("%c",a+1);

} 

// Faster C++ solution for the same problem (measured speedup: 5.320929974025506x):
#include<stdio.h>



int main (){

	char huruf;

	

	scanf ("%c", &huruf);

	printf ("%c",huruf+1);

 

 	return 0;

}
// Slower C++ solution:
#include <iostream>



using namespace std;



int main()

{

    char a;

    cin >> a;

    cout << char (a+1);



    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.321520565088524x):
#include<stdio.h>



int main (){

	char a;

	scanf("%c", &a);

	printf("%c", a + 1);

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;



int main()

{

    char a;

    scanf("%c",&a);

    printf("%c",a+1);

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.28284857125259x):
#include<stdio.h>



int main (){

	char a;

	scanf("%c", &a);

	printf("%c", a + 1);

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main ()

{

    char ch;

    cin>>ch;



    char c;

    c=ch+1;

    cout<<c<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.341413619408311x):
#include<stdio.h>



int main (){

	char a;

	scanf("%c", &a);

	printf("%c", a + 1);

	return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;



int main() {

char c;

cin>>c;

c+=1;

cout<<c;

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.321630038473499x):
#include<stdio.h>



int main (){

	char a;

	scanf("%c", &a);

	printf("%c", a + 1);

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main()

{

	char a;

	cin>>a;

	printf("%c",a+1);

} 

// Faster C++ solution for the same problem (measured speedup: 5.320929974025506x):
#include<stdio.h>



int main (){

	char a;

	scanf("%c", &a);

	printf("%c", a + 1);

	return 0;

}
// Slower C++ solution:
#include <iostream>



using namespace std;



int main()

{

    char a;

    cin >> a;

    cout << char (a+1);



    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.322288141681136x):
#include<stdio.h>

int main()

{

	char a;

	char b;

	scanf("%c",&a);

	b=a+1;

	printf("%c",b);

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;



int main()

{

    char a;

    scanf("%c",&a);

    printf("%c",a+1);

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.283610569793421x):
#include<stdio.h>

int main()

{

	char a;

	char b;

	scanf("%c",&a);

	b=a+1;

	printf("%c",b);

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main ()

{

    char ch;

    cin>>ch;



    char c;

    c=ch+1;

    cout<<c<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.34218406537682x):
#include<stdio.h>

int main()

{

	char a;

	char b;

	scanf("%c",&a);

	b=a+1;

	printf("%c",b);

	return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;



int main() {

char c;

cin>>c;

c+=1;

cout<<c;

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.32239763085656x):
#include<stdio.h>

int main()

{

	char a;

	char b;

	scanf("%c",&a);

	b=a+1;

	printf("%c",b);

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main()

{

	char a;

	cin>>a;

	printf("%c",a+1);

} 

// Faster C++ solution for the same problem (measured speedup: 5.32169746543121x):
#include<stdio.h>

int main()

{

	char a;

	char b;

	scanf("%c",&a);

	b=a+1;

	printf("%c",b);

	return 0;

}
// Slower C++ solution:
#include <iostream>



using namespace std;



int main()

{

    char a;

    cin >> a;

    cout << char (a+1);



    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.321520565088524x):
#include <stdio.h>

int main () 

{

char letter;

scanf("%c", &letter) ;

printf("%c", letter+1) ;

}
// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;



int main()

{

    char a;

    scanf("%c",&a);

    printf("%c",a+1);

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.28284857125259x):
#include <stdio.h>

int main () 

{

char letter;

scanf("%c", &letter) ;

printf("%c", letter+1) ;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main ()

{

    char ch;

    cin>>ch;



    char c;

    c=ch+1;

    cout<<c<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.341413619408311x):
#include <stdio.h>

int main () 

{

char letter;

scanf("%c", &letter) ;

printf("%c", letter+1) ;

}
// Slower C++ solution:
#include <iostream>

using namespace std;



int main() {

char c;

cin>>c;

c+=1;

cout<<c;

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.321630038473499x):
#include <stdio.h>

int main () 

{

char letter;

scanf("%c", &letter) ;

printf("%c", letter+1) ;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main()

{

	char a;

	cin>>a;

	printf("%c",a+1);

} 

// Faster C++ solution for the same problem (measured speedup: 5.320929974025506x):
#include <stdio.h>

int main () 

{

char letter;

scanf("%c", &letter) ;

printf("%c", letter+1) ;

}
// Slower C++ solution:
#include <iostream>



using namespace std;



int main()

{

    char a;

    cin >> a;

    cout << char (a+1);



    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.307415890864957x):
#include<stdio.h>



int main(){

	

	char c;

	scanf("%c", &c);

	printf("%c\n", c + 1);

	

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;



int main()

{

    char a;

    scanf("%c",&a);

    printf("%c",a+1);

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.268846397032163x):
#include<stdio.h>



int main(){

	

	char c;

	scanf("%c", &c);

	printf("%c\n", c + 1);

	

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main ()

{

    char ch;

    cin>>ch;



    char c;

    c=ch+1;

    cout<<c<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.327256218704208x):
#include<stdio.h>



int main(){

	

	char c;

	scanf("%c", &c);

	printf("%c\n", c + 1);

	

	return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;



int main() {

char c;

cin>>c;

c+=1;

cout<<c;

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.307525074091055x):
#include<stdio.h>



int main(){

	

	char c;

	scanf("%c", &c);

	printf("%c\n", c + 1);

	

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main()

{

	char a;

	cin>>a;

	printf("%c",a+1);

} 

// Faster C++ solution for the same problem (measured speedup: 5.306826865161772x):
#include<stdio.h>



int main(){

	

	char c;

	scanf("%c", &c);

	printf("%c\n", c + 1);

	

	return 0;

}
// Slower C++ solution:
#include <iostream>



using namespace std;



int main()

{

    char a;

    cin >> a;

    cout << char (a+1);



    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.323287922301409x):
#include<stdio.h>

int main()

{

	char a[100];

	scanf("%c",&a[0]); 

	printf("%c",(a[0]+1));

}
// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;



int main()

{

    char a;

    scanf("%c",&a);

    printf("%c",a+1);

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.284603084913259x):
#include<stdio.h>

int main()

{

	char a[100];

	scanf("%c",&a[0]); 

	printf("%c",(a[0]+1));

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main ()

{

    char ch;

    cin>>ch;



    char c;

    c=ch+1;

    cout<<c<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.343187583404465x):
#include<stdio.h>

int main()

{

	char a[100];

	scanf("%c",&a[0]); 

	printf("%c",(a[0]+1));

}
// Slower C++ solution:
#include <iostream>

using namespace std;



int main() {

char c;

cin>>c;

c+=1;

cout<<c;

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.323397432044146x):
#include<stdio.h>

int main()

{

	char a[100];

	scanf("%c",&a[0]); 

	printf("%c",(a[0]+1));

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main()

{

	char a;

	cin>>a;

	printf("%c",a+1);

} 

// Faster C++ solution for the same problem (measured speedup: 5.322697135094194x):
#include<stdio.h>

int main()

{

	char a[100];

	scanf("%c",&a[0]); 

	printf("%c",(a[0]+1));

}
// Slower C++ solution:
#include <iostream>



using namespace std;



int main()

{

    char a;

    cin >> a;

    cout << char (a+1);



    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.321520565088524x):
#include <stdio.h>



int main(){

char i ;

scanf("%c",&i);

printf("%c", i + 1);



	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;



int main()

{

    char a;

    scanf("%c",&a);

    printf("%c",a+1);

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.28284857125259x):
#include <stdio.h>



int main(){

char i ;

scanf("%c",&i);

printf("%c", i + 1);



	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main ()

{

    char ch;

    cin>>ch;



    char c;

    c=ch+1;

    cout<<c<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.341413619408311x):
#include <stdio.h>



int main(){

char i ;

scanf("%c",&i);

printf("%c", i + 1);



	return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;



int main() {

char c;

cin>>c;

c+=1;

cout<<c;

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.321630038473499x):
#include <stdio.h>



int main(){

char i ;

scanf("%c",&i);

printf("%c", i + 1);



	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main()

{

	char a;

	cin>>a;

	printf("%c",a+1);

} 

// Faster C++ solution for the same problem (measured speedup: 5.320929974025506x):
#include <stdio.h>



int main(){

char i ;

scanf("%c",&i);

printf("%c", i + 1);



	return 0;

}
// Slower C++ solution:
#include<stdio.h>

#include<map>

#include<string.h>

#include<math.h>

#include<queue>

#include<iostream>

#include<vector>

#include<stack>

using namespace std;

int main()

{

    char s;

    scanf("%c",&s);

    printf("%c\n",s+1);

}


// Faster C++ solution for the same problem (measured speedup: 5.334450873713388x):
#include<stdio.h> 

int main()

{

	char a = getchar();

	putchar(a+1);

}
// Slower C++ solution:
#include<stdio.h>

#include<map>

#include<string.h>

#include<math.h>

#include<queue>

#include<iostream>

#include<vector>

#include<stack>

using namespace std;

int main()

{

    char s;

    scanf("%c",&s);

    printf("%c\n",s+1);

}


// Faster C++ solution for the same problem (measured speedup: 5.334450873713388x):
#include<stdio.h>

int main()

{

	char c1;

	c1=getchar();

	putchar(c1+1);

	putchar('\n');

	return 0;

}
// Slower C++ solution:
#include<stdio.h>

#include<map>

#include<string.h>

#include<math.h>

#include<queue>

#include<iostream>

#include<vector>

#include<stack>

using namespace std;

int main()

{

    char s;

    scanf("%c",&s);

    printf("%c\n",s+1);

}


// Faster C++ solution for the same problem (measured speedup: 5.285013362818165x):
#include <stdio.h>



int main(){

    char a;

    scanf("%c", &a);

    printf("%c", a + 1);



    return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{

          char a;

          cin>>a;

          a=a+1;

          cout<<a<<endl;

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.340879178077396x):
#include <stdio.h>



int main(){

    char a;

    scanf("%c", &a);

    printf("%c", a + 1);



    return 0;

}
// Slower C++ solution:
#include<stdio.h>

#include<map>

#include<string.h>

#include<math.h>

#include<queue>

#include<iostream>

#include<vector>

#include<stack>

using namespace std;

int main()

{

    char s;

    scanf("%c",&s);

    printf("%c\n",s+1);

}


// Faster C++ solution for the same problem (measured speedup: 5.284354458824519x):
#include <stdio.h>



int main (){

	char z;

	

	scanf ("%c", &z);

	printf ("%c", z+1);

	return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{

          char a;

          cin>>a;

          a=a+1;

          cout<<a<<endl;

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.340213309066586x):
#include <stdio.h>



int main (){

	char z;

	

	scanf ("%c", &z);

	printf ("%c", z+1);

	return 0;

}
// Slower C++ solution:
#include<stdio.h>

#include<map>

#include<string.h>

#include<math.h>

#include<queue>

#include<iostream>

#include<vector>

#include<stack>

using namespace std;

int main()

{

    char s;

    scanf("%c",&s);

    printf("%c\n",s+1);

}


// Faster C++ solution for the same problem (measured speedup: 5.285013362818165x):
#include <stdio.h>



int main()

{

	char C;

	

	scanf("%c", &C);

	printf("%c", C + 1);

	

	return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{

          char a;

          cin>>a;

          a=a+1;

          cout<<a<<endl;

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.340879178077396x):
#include <stdio.h>



int main()

{

	char C;

	

	scanf("%c", &C);

	printf("%c", C + 1);

	

	return 0;

}
// Slower C++ solution:
#include<stdio.h>

#include<map>

#include<string.h>

#include<math.h>

#include<queue>

#include<iostream>

#include<vector>

#include<stack>

using namespace std;

int main()

{

    char s;

    scanf("%c",&s);

    printf("%c\n",s+1);

}


// Faster C++ solution for the same problem (measured speedup: 5.271005450824216x):
#include <stdio.h>;



	int main() {

		char a;

	

		scanf("%c", &a);

		printf("%c\n", a+001);

	

		return 0;

	}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{

          char a;

          cin>>a;

          a=a+1;

          cout<<a<<endl;

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.32672319390843x):
#include <stdio.h>;



	int main() {

		char a;

	

		scanf("%c", &a);

		printf("%c\n", a+001);

	

		return 0;

	}
// Slower C++ solution:
#include<stdio.h>

#include<map>

#include<string.h>

#include<math.h>

#include<queue>

#include<iostream>

#include<vector>

#include<stack>

using namespace std;

int main()

{

    char s;

    scanf("%c",&s);

    printf("%c\n",s+1);

}


// Faster C++ solution for the same problem (measured speedup: 5.285775673608722x):
#include <stdio.h>



int main(){

	

	char sebelum;

	scanf("%c", &sebelum);

	sebelum++;

	printf("%c", sebelum);

	

	

	return 0;

	

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{

          char a;

          cin>>a;

          a=a+1;

          cout<<a<<endl;

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.34164954695804x):
#include <stdio.h>



int main(){

	

	char sebelum;

	scanf("%c", &sebelum);

	sebelum++;

	printf("%c", sebelum);

	

	

	return 0;

	

}
// Slower C++ solution:
#include<stdio.h>

#include<map>

#include<string.h>

#include<math.h>

#include<queue>

#include<iostream>

#include<vector>

#include<stack>

using namespace std;

int main()

{

    char s;

    scanf("%c",&s);

    printf("%c\n",s+1);

}


// Faster C++ solution for the same problem (measured speedup: 5.285013362818165x):
#include <stdio.h>



int main() {

	

  char a;

  

  scanf("%c", &a);

  printf("%c", a + 1);

  

  return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{

          char a;

          cin>>a;

          a=a+1;

          cout<<a<<endl;

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.340879178077396x):
#include <stdio.h>



int main() {

	

  char a;

  

  scanf("%c", &a);

  printf("%c", a + 1);

  

  return 0;

}
// Slower C++ solution:
#include<stdio.h>

#include<map>

#include<string.h>

#include<math.h>

#include<queue>

#include<iostream>

#include<vector>

#include<stack>

using namespace std;

int main()

{

    char s;

    scanf("%c",&s);

    printf("%c\n",s+1);

}


// Faster C++ solution for the same problem (measured speedup: 5.284354458824519x):
#include <stdio.h>





int main() {

    char C;

    scanf("%c", &C);

    printf("%c", C+1);

    return 0;



}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{

          char a;

          cin>>a;

          a=a+1;

          cout<<a<<endl;

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.340213309066586x):
#include <stdio.h>





int main() {

    char C;

    scanf("%c", &C);

    printf("%c", C+1);

    return 0;



}
// Slower C++ solution:
#include<stdio.h>

#include<map>

#include<string.h>

#include<math.h>

#include<queue>

#include<iostream>

#include<vector>

#include<stack>

using namespace std;

int main()

{

    char s;

    scanf("%c",&s);

    printf("%c\n",s+1);

}


// Faster C++ solution for the same problem (measured speedup: 5.285013362818165x):
#include<stdio.h>

int main(){

	char x;

	scanf("%c", &x);

	printf("%c", x+1);	

	return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{

          char a;

          cin>>a;

          a=a+1;

          cout<<a<<endl;

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.340879178077396x):
#include<stdio.h>

int main(){

	char x;

	scanf("%c", &x);

	printf("%c", x+1);	

	return 0;

}
// Slower C++ solution:
#include<stdio.h>

#include<map>

#include<string.h>

#include<math.h>

#include<queue>

#include<iostream>

#include<vector>

#include<stack>

using namespace std;

int main()

{

    char s;

    scanf("%c",&s);

    printf("%c\n",s+1);

}


// Faster C++ solution for the same problem (measured speedup: 5.245462759739485x):
#include <stdio.h>



int main() {

	

	char c[2];

	scanf("%s", c);

	c[0]++;

	printf("%s", c);

	

	return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{

          char a;

          cin>>a;

          a=a+1;

          cout<<a<<endl;

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.300910500997138x):
#include <stdio.h>



int main() {

	

	char c[2];

	scanf("%s", c);

	c[0]++;

	printf("%s", c);

	

	return 0;

}
// Slower C++ solution:
#include<stdio.h>

#include<map>

#include<string.h>

#include<math.h>

#include<queue>

#include<iostream>

#include<vector>

#include<stack>

using namespace std;

int main()

{

    char s;

    scanf("%c",&s);

    printf("%c\n",s+1);

}


// Faster C++ solution for the same problem (measured speedup: 5.285013362818165x):
#include <stdio.h>



int main (){

	char a;

	

	scanf ("%c", &a);

	printf ("%c",a+1);

	

	return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{

          char a;

          cin>>a;

          a=a+1;

          cout<<a<<endl;

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.340879178077396x):
#include <stdio.h>



int main (){

	char a;

	

	scanf ("%c", &a);

	printf ("%c",a+1);

	

	return 0;

}
// Slower C++ solution:
#include<stdio.h>

#include<map>

#include<string.h>

#include<math.h>

#include<queue>

#include<iostream>

#include<vector>

#include<stack>

using namespace std;

int main()

{

    char s;

    scanf("%c",&s);

    printf("%c\n",s+1);

}


// Faster C++ solution for the same problem (measured speedup: 5.285013362818165x):
#include<stdio.h>

int main(){

	char a;

	

	scanf("%c", &a);

	printf("%c", a + 1);

	

	return 0;

}