stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
//AC



#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main(){

	char huruf;

	scanf("%c", &huruf);

	

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



int main(){

	char huruf;

	scanf("%c", &huruf);

	

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

	

	return 0;

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

using namespace std;

int main()

{

	char a;

	scanf("%c",&a);

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

}

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



int main(){

	char huruf;

	scanf("%c", &huruf);

	

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

	

	return 0;

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

using namespace std;

int main()

{

    char ch;

    cin >> ch;

    ch=ch+1;

    cout << ch << endl;

    return 0;

}


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



int main(){

	char huruf;

	scanf("%c", &huruf);

	

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

	

	return 0;

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

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main()

{

	char c;

	

	scanf("%c", &c);

	char next = c + 1;

	

	printf("%c", next);

	

	return 0;

}
// Slower C++ solution:
//AC



#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main()

{

	char c;

	

	scanf("%c", &c);

	char next = c + 1;

	

	printf("%c", next);

	

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

	

	scanf("%c", &c);

	char next = c + 1;

	

	printf("%c", next);

	

	return 0;

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

using namespace std;

int main()

{

	char a;

	scanf("%c",&a);

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

}

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



int main()

{

	char c;

	

	scanf("%c", &c);

	char next = c + 1;

	

	printf("%c", next);

	

	return 0;

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

using namespace std;

int main()

{

    char ch;

    cin >> ch;

    ch=ch+1;

    cout << ch << endl;

    return 0;

}


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



int main()

{

	char c;

	

	scanf("%c", &c);

	char next = c + 1;

	

	printf("%c", next);

	

	return 0;

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

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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

int main (){

	char a;

	scanf("%c\n", &a);

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

	return 0;

}
// Slower C++ solution:
//AC



#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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

int main (){

	char a;

	scanf("%c\n", &a);

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

int main (){

	char a;

	scanf("%c\n", &a);

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

	return 0;

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

using namespace std;

int main()

{

	char a;

	scanf("%c",&a);

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

}

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

int main (){

	char a;

	scanf("%c\n", &a);

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

	return 0;

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

using namespace std;

int main()

{

    char ch;

    cin >> ch;

    ch=ch+1;

    cout << ch << endl;

    return 0;

}


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

int main (){

	char a;

	scanf("%c\n", &a);

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

	return 0;

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

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main() {

	char Z, next;

	scanf("%c", &Z);

	next = Z+1;

	printf("%c", next);

	

	return 0;

}
// Slower C++ solution:
//AC



#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main() {

	char Z, next;

	scanf("%c", &Z);

	next = Z+1;

	printf("%c", next);

	

	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 Z, next;

	scanf("%c", &Z);

	next = Z+1;

	printf("%c", next);

	

	return 0;

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

using namespace std;

int main()

{

	char a;

	scanf("%c",&a);

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

}

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



int main() {

	char Z, next;

	scanf("%c", &Z);

	next = Z+1;

	printf("%c", next);

	

	return 0;

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

using namespace std;

int main()

{

    char ch;

    cin >> ch;

    ch=ch+1;

    cout << ch << endl;

    return 0;

}


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



int main() {

	char Z, next;

	scanf("%c", &Z);

	next = Z+1;

	printf("%c", next);

	

	return 0;

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

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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

// Given is a lowercase English letter C that is not z. Print the letter that follows C in alphabetical order

// Print the letter that follows C in alphabetical order.



int main() {

    char letter;



    scanf("%c", &letter);

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

    return 0;

}
// Slower C++ solution:
//AC



#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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

// Given is a lowercase English letter C that is not z. Print the letter that follows C in alphabetical order

// Print the letter that follows C in alphabetical order.



int main() {

    char letter;



    scanf("%c", &letter);

    printf("%c\n", letter + 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>

// Given is a lowercase English letter C that is not z. Print the letter that follows C in alphabetical order

// Print the letter that follows C in alphabetical order.



int main() {

    char letter;



    scanf("%c", &letter);

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

    return 0;

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

using namespace std;

int main()

{

	char a;

	scanf("%c",&a);

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

}

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

// Given is a lowercase English letter C that is not z. Print the letter that follows C in alphabetical order

// Print the letter that follows C in alphabetical order.



int main() {

    char letter;



    scanf("%c", &letter);

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

    return 0;

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

using namespace std;

int main()

{

    char ch;

    cin >> ch;

    ch=ch+1;

    cout << ch << endl;

    return 0;

}


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

// Given is a lowercase English letter C that is not z. Print the letter that follows C in alphabetical order

// Print the letter that follows C in alphabetical order.



int main() {

    char letter;



    scanf("%c", &letter);

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

    return 0;

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

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

// Faster C++ solution for the same problem (measured speedup: 5.342814135030928x):




#include<stdio.h>





int main(){



    char alpha;

	

	scanf("%c", &alpha);

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



    return 0;

}
// Slower C++ solution:
//AC



#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

// Faster C++ solution for the same problem (measured speedup: 5.342814135030928x):




#include<stdio.h>





int main(){



    char alpha;

	

	scanf("%c", &alpha);

	printf("%c", alpha + 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 alpha;

	

	scanf("%c", &alpha);

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



    return 0;

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

using namespace std;

int main()

{

	char a;

	scanf("%c",&a);

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

}

// Faster C++ solution for the same problem (measured speedup: 5.28284857125259x):




#include<stdio.h>





int main(){



    char alpha;

	

	scanf("%c", &alpha);

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



    return 0;

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

using namespace std;

int main()

{

    char ch;

    cin >> ch;

    ch=ch+1;

    cout << ch << endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.340879178077396x):




#include<stdio.h>





int main(){



    char alpha;

	

	scanf("%c", &alpha);

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



    return 0;

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

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main(){

    char x;

    scanf("%c", &x);

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

}
// Slower C++ solution:
//AC



#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main(){

    char x;

    scanf("%c", &x);

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



int main(){

    char x;

    scanf("%c", &x);

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

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

using namespace std;

int main()

{

	char a;

	scanf("%c",&a);

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

}

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



int main(){

    char x;

    scanf("%c", &x);

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

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

using namespace std;

int main()

{

    char ch;

    cin >> ch;

    ch=ch+1;

    cout << ch << endl;

    return 0;

}


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



int main(){

    char x;

    scanf("%c", &x);

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

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

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main() {

  char c;

  scanf("%c", &c);

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



  return 0;

}
// Slower C++ solution:
//AC



#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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

	scanf("%c",&a);

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

}

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

    ch=ch+1;

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

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main() {

    char c;

    if (c == 'z') {

        return 1;

    };

    scanf("%c", &c);

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

    return 0;

};
// Slower C++ solution:
//AC



#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main() {

    char c;

    if (c == 'z') {

        return 1;

    };

    scanf("%c", &c);

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



int main() {

    char c;

    if (c == 'z') {

        return 1;

    };

    scanf("%c", &c);

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

    return 0;

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

using namespace std;

int main()

{

	char a;

	scanf("%c",&a);

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

}

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



int main() {

    char c;

    if (c == 'z') {

        return 1;

    };

    scanf("%c", &c);

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

    return 0;

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

using namespace std;

int main()

{

    char ch;

    cin >> ch;

    ch=ch+1;

    cout << ch << endl;

    return 0;

}


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



int main() {

    char c;

    if (c == 'z') {

        return 1;

    };

    scanf("%c", &c);

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

    return 0;

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

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main() {

  char C1;

  scanf("%c", &C1);



  char C2 = C1 + 1;

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

  return 0;

}
// Slower C++ solution:
//AC



#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main() {

  char C1;

  scanf("%c", &C1);



  char C2 = C1 + 1;

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

  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.305856992198267x):
#include <stdio.h>



int main() {

  char C1;

  scanf("%c", &C1);



  char C2 = C1 + 1;

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

  return 0;

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

using namespace std;

int main()

{

	char a;

	scanf("%c",&a);

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

}

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



int main() {

  char C1;

  scanf("%c", &C1);



  char C2 = C1 + 1;

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

  return 0;

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

using namespace std;

int main()

{

    char ch;

    cin >> ch;

    ch=ch+1;

    cout << ch << endl;

    return 0;

}


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



int main() {

  char C1;

  scanf("%c", &C1);



  char C2 = C1 + 1;

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

  return 0;

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

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main (){

char huruf;

 	

scanf("%c",&huruf);	

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

	

	

	

return 0;

}
// Slower C++ solution:
//AC



#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main (){

char huruf;

 	

scanf("%c",&huruf);	

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



int main (){

char huruf;

 	

scanf("%c",&huruf);	

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

	

	

	

return 0;

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

using namespace std;

int main()

{

	char a;

	scanf("%c",&a);

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

}

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



int main (){

char huruf;

 	

scanf("%c",&huruf);	

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

	

	

	

return 0;

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

using namespace std;

int main()

{

    char ch;

    cin >> ch;

    ch=ch+1;

    cout << ch << endl;

    return 0;

}


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



int main (){

char huruf;

 	

scanf("%c",&huruf);	

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

	

	

	

return 0;

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

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main()

{	char A;

		scanf("%c", &A);

	char B;

		B = A + 1;

		printf("%c", B);

	return 0;

}
// Slower C++ solution:
//AC



#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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



int main()

{	char A;

		scanf("%c", &A);

	char B;

		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;

		scanf("%c", &A);

	char B;

		B = A + 1;

		printf("%c", B);

	return 0;

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

using namespace std;

int main()

{

	char a;

	scanf("%c",&a);

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

}

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



int main()

{	char A;

		scanf("%c", &A);

	char B;

		B = A + 1;

		printf("%c", B);

	return 0;

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

using namespace std;

int main()

{

    char ch;

    cin >> ch;

    ch=ch+1;

    cout << ch << endl;

    return 0;

}


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



int main()

{	char A;

		scanf("%c", &A);

	char B;

		B = A + 1;

		printf("%c", B);

	return 0;

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

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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

int main (){

	

	int maunyeape;

	

	scanf("%c", &maunyeape);

	maunyeape++;

	printf("%c", maunyeape);

	

	

	return 0;

}
// Slower C++ solution:
//AC



#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

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

int main (){

	

	int maunyeape;

	

	scanf("%c", &maunyeape);

	maunyeape++;

	printf("%c", maunyeape);

	

	

	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 (){

	

	int maunyeape;

	

	scanf("%c", &maunyeape);

	maunyeape++;

	printf("%c", maunyeape);

	

	

	return 0;

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

using namespace std;

int main()

{

	char a;

	scanf("%c",&a);

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

}

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

int main (){

	

	int maunyeape;

	

	scanf("%c", &maunyeape);

	maunyeape++;

	printf("%c", maunyeape);

	

	

	return 0;

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

using namespace std;

int main()

{

    char ch;

    cin >> ch;

    ch=ch+1;

    cout << ch << endl;

    return 0;

}


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

int main (){

	

	int maunyeape;

	

	scanf("%c", &maunyeape);

	maunyeape++;

	printf("%c", maunyeape);

	

	

	return 0;

}