stablegradients/pie-gem5-pairs huggingface dataset:
// 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.271005450824216x):
#include<stdio.h>



int main(){

	char a;

	scanf("%c",&a);

	printf("%c\n",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.32672319390843x):
#include<stdio.h>



int main(){

	char a;

	scanf("%c",&a);

	printf("%c\n",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.2334223425540936x):
#include <stdio.h>



int main() {

	

	char c[2];

	scanf("%s", c);

	c[0]++;

	printf("%s\n", 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.288742809257086x):
#include <stdio.h>



int main() {

	

	char c[2];

	scanf("%s", c);

	c[0]++;

	printf("%s\n", 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 alphabeth;

	scanf("%c", &alphabeth);

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

}
// 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 alphabeth;

	scanf("%c", &alphabeth);

	printf("%c",alphabeth +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.271005450824216x):
#include<stdio.h>



int main(){

char a;

int b;

scanf("%c", &a);

b=a+1;

printf("%c\n", b);

	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;

int b;

scanf("%c", &a);

b=a+1;

printf("%c\n", b);

	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 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;

          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 c;

	

	scanf("%c",&c);

	printf("%c\n",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.285775673608722x):
#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;

          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 a;

	char b;

	scanf("%c", &a);

	b = a + 1;

	printf("%c", b);

return 0;

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



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    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);

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

using namespace std;





int main()

{

    char character;



    cin >> character;



    cout << (char)((int)character + 1) << 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);

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

using namespace std;

int main()

{

    char c;

    cin>>c;

    int a=c;

    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);

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



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    return 0;

}


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

int main(){

	char c;

	scanf("%c",&c);

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

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

using namespace std;





int main()

{

    char character;



    cin >> character;



    cout << (char)((int)character + 1) << endl;





    return 0;

}


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

int main(){

	char c;

	scanf("%c",&c);

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

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

using namespace std;

int main()

{

    char c;

    cin>>c;

    int a=c;

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

}


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

int main(){

	char c;

	scanf("%c",&c);

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

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



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    return 0;

}


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

int main(){

	char a;

	scanf("%c",&a);

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

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

using namespace std;





int main()

{

    char character;



    cin >> character;



    cout << (char)((int)character + 1) << endl;





    return 0;

}


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

int main(){

	char a;

	scanf("%c",&a);

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

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

using namespace std;

int main()

{

    char c;

    cin>>c;

    int a=c;

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

}


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

int main(){

	char a;

	scanf("%c",&a);

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

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



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    return 0;

}


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

int main()

{

	char c1;

	scanf("%c",&c1);

	c1=c1+1;

	printf("%c",c1);

	return 0;

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

using namespace std;





int main()

{

    char character;



    cin >> character;



    cout << (char)((int)character + 1) << endl;





    return 0;

}


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

int main()

{

	char c1;

	scanf("%c",&c1);

	c1=c1+1;

	printf("%c",c1);

	return 0;

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

using namespace std;

int main()

{

    char c;

    cin>>c;

    int a=c;

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

}


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

int main()

{

	char c1;

	scanf("%c",&c1);

	c1=c1+1;

	printf("%c",c1);

	return 0;

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



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    return 0;

}


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



int main(){

int N;

scanf("%c",&N);

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

	return 0;

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

using namespace std;





int main()

{

    char character;



    cin >> character;



    cout << (char)((int)character + 1) << endl;





    return 0;

}


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



int main(){

int N;

scanf("%c",&N);

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

	return 0;

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

using namespace std;

int main()

{

    char c;

    cin>>c;

    int a=c;

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

}


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



int main(){

int N;

scanf("%c",&N);

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

	return 0;

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



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    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<iostream>

using namespace std;





int main()

{

    char character;



    cin >> character;



    cout << (char)((int)character + 1) << 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;

    int a=c;

    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<bits/stdc++.h>



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    return 0;

}


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



int main() {

	char A;

	

	scanf("%c", &A);

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

	

	return 0;

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

using namespace std;





int main()

{

    char character;



    cin >> character;



    cout << (char)((int)character + 1) << endl;





    return 0;

}


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



int main() {

	char A;

	

	scanf("%c", &A);

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

	

	return 0;

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

using namespace std;

int main()

{

    char c;

    cin>>c;

    int a=c;

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

}


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



int main() {

	char A;

	

	scanf("%c", &A);

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

	

	return 0;

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



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    return 0;

}


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



int main(){

	int a;

	scanf("%c", &a);

	

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

return 0;

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

using namespace std;





int main()

{

    char character;



    cin >> character;



    cout << (char)((int)character + 1) << endl;





    return 0;

}


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



int main(){

	int a;

	scanf("%c", &a);

	

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

return 0;

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

using namespace std;

int main()

{

    char c;

    cin>>c;

    int a=c;

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

}


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



int main(){

	int a;

	scanf("%c", &a);

	

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

return 0;

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



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    return 0;

}


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



int main () {

	char alphabet;

	scanf("%c", &alphabet);

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

	

	

	return 0;

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

using namespace std;





int main()

{

    char character;



    cin >> character;



    cout << (char)((int)character + 1) << endl;





    return 0;

}


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



int main () {

	char alphabet;

	scanf("%c", &alphabet);

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

	

	

	return 0;

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

using namespace std;

int main()

{

    char c;

    cin>>c;

    int a=c;

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

}


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



int main () {

	char alphabet;

	scanf("%c", &alphabet);

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

	

	

	return 0;

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



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    return 0;

}


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



int main () {

char naruto;



scanf("%c", &naruto);

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



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

using namespace std;





int main()

{

    char character;



    cin >> character;



    cout << (char)((int)character + 1) << endl;





    return 0;

}


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



int main () {

char naruto;



scanf("%c", &naruto);

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



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

using namespace std;

int main()

{

    char c;

    cin>>c;

    int a=c;

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

}


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



int main () {

char naruto;



scanf("%c", &naruto);

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



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



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    return 0;

}


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



int main(){

	char a;

	scanf("%c", &a);

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

	

	return 0;

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

using namespace std;





int main()

{

    char character;



    cin >> character;



    cout << (char)((int)character + 1) << endl;





    return 0;

}


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



int main(){

	char a;

	scanf("%c", &a);

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

	

	return 0;

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

using namespace std;

int main()

{

    char c;

    cin>>c;

    int a=c;

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

}


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



int main(){

	char a;

	scanf("%c", &a);

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

	

	return 0;

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



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    return 0;

}


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



int main(){

	char x;

	scanf("%c", &x);

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

	return 0;

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

using namespace std;





int main()

{

    char character;



    cin >> character;



    cout << (char)((int)character + 1) << endl;





    return 0;

}


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



int main(){

	char x;

	scanf("%c", &x);

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

	return 0;

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

using namespace std;

int main()

{

    char c;

    cin>>c;

    int a=c;

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

}


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



int main(){

	char x;

	scanf("%c", &x);

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

	return 0;

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



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.321630038473499x):
#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 character;



    cin >> character;



    cout << (char)((int)character + 1) << endl;





    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.341413619408311x):
#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 c;

    cin>>c;

    int a=c;

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

}


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



int main (){

	char c;

	scanf("%c",&c);

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

	

	

	

	

	return 0;

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



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    return 0;

}


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



int main(){

	int a;

	scanf("%c",&a);

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

	return 0;

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

using namespace std;





int main()

{

    char character;



    cin >> character;



    cout << (char)((int)character + 1) << endl;





    return 0;

}


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



int main(){

	int a;

	scanf("%c",&a);

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

	return 0;

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

using namespace std;

int main()

{

    char c;

    cin>>c;

    int a=c;

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

}


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



int main(){

	int a;

	scanf("%c",&a);

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

	return 0;

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



using namespace std;

char f(char ch){

  int d = ch-'a' +1;

  return (char)(d+'a');

}

int main ()

{

  	char ch;cin>>ch;

    cout<<f(ch);

    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);

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

using namespace std;





int main()

{

    char character;



    cin >> character;



    cout << (char)((int)character + 1) << 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);

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

using namespace std;

int main()

{

    char c;

    cin>>c;

    int a=c;

    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);

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

using namespace std;



#define f(i,n) for(auto i=0;i<n;i++)

#define fr(i,n) for(auto i=n-1;i>=0;i--)

#define fs(i,a,b,c) for(auto i=a;i!=b;i+=c)

#define fl(i,x) for(auto i : x)

#define nl cout<<"\n";

#define ll long long int

#define vl vector<ll>

#define mid(a,b) ((a+b)/2)

#define pb push_back



class triplet{ll f, s, t;};



vl in(ll n){vl v;ll x;

    f(i,n)

    cin>>x, v.pb(x);

    return v;}

void out(vl v){fl(i,v)cout<<i;}

void out(vl v, char ch){

    fl(i,v)

    cout<<i<<ch;}



ll attack(ll ar[10000][10000], ll i, ll j, ll k){

    return ((i+2 < k) && (j+1 < k)) + ((i+2 < k) && (j-1 >= 0)) + ((i-2 >= 0) && (j+1 < k)) + ((i-2 >= 0) && (j-1 >= 0));

}



void solve(){

    char ch;

    cin>>ch;

    cout<<(char)(ch+1);

}

int main(){

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    solve();

   return 0;

}

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

	int main(){

		char C;

			

		scanf ("%c", &C);

	 	

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

	}