stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <iostream>

using namespace std;



int main()

{

	char c;

	cin>>c;

	cout<<++c;

}

// 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 c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



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

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

using namespace std;

int main(){

    char a;

    cin >> a;

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

}

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

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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

	cout<<++c;

}

// 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 c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


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



int main(){

    char alphabet;

    scanf("%c", &alphabet);

    char after = alphabet + 1;

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



    return 0;

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

using namespace std;

int main(){

    char a;

    cin >> a;

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

}

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



int main(){

    char alphabet;

    scanf("%c", &alphabet);

    char after = alphabet + 1;

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



    return 0;

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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



int main(){

    char alphabet;

    scanf("%c", &alphabet);

    char after = alphabet + 1;

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



    return 0;

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

using namespace std;



int main()

{

	char c;

	cin>>c;

	cout<<++c;

}

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



int main(){

    char alphabet;

    scanf("%c", &alphabet);

    char after = alphabet + 1;

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



    return 0;

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

using namespace std;



int main() {

	char c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


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



int main()

{

	char str;

	

	scanf("%c", &str);

	

	

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

		

	return 0;

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

using namespace std;

int main(){

    char a;

    cin >> a;

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

}

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



int main()

{

	char str;

	

	scanf("%c", &str);

	

	

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

		

	return 0;

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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



int main()

{

	char str;

	

	scanf("%c", &str);

	

	

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

		

	return 0;

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

using namespace std;



int main()

{

	char c;

	cin>>c;

	cout<<++c;

}

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



int main()

{

	char str;

	

	scanf("%c", &str);

	

	

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

		

	return 0;

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

using namespace std;



int main() {

	char c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


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

int main()

{

	char huruf;

	

	scanf("%c",&huruf);

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



	return 0;



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

using namespace std;

int main(){

    char a;

    cin >> a;

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

}

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

int main()

{

	char huruf;

	

	scanf("%c",&huruf);

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



	return 0;



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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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

int main()

{

	char huruf;

	

	scanf("%c",&huruf);

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



	return 0;



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

using namespace std;



int main()

{

	char c;

	cin>>c;

	cout<<++c;

}

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

int main()

{

	char huruf;

	

	scanf("%c",&huruf);

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



	return 0;



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

using namespace std;



int main() {

	char c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



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

using namespace std;

int main(){

    char a;

    cin >> a;

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

}

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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

	cout<<++c;

}

// 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 c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


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

    cin >> a;

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

}

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



int main(){

	char x;

	scanf("%c",&x);

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

	

	

	return 0;

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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

	cout<<++c;

}

// 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 c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


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

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

}

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



int main() {

    char c;

    scanf("%c", &c);

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

    return 0;

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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

	cout<<++c;

}

// 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 c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


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

int main(){

	char alpha;

	char n;



	

	scanf("%c", &alpha);

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

	

	

	return 0;

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

using namespace std;

int main(){

    char a;

    cin >> a;

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

}

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

int main(){

	char alpha;

	char n;



	

	scanf("%c", &alpha);

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

	

	

	return 0;

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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

int main(){

	char alpha;

	char n;



	

	scanf("%c", &alpha);

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

	

	

	return 0;

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

using namespace std;



int main()

{

	char c;

	cin>>c;

	cout<<++c;

}

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

int main(){

	char alpha;

	char n;



	

	scanf("%c", &alpha);

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

	

	

	return 0;

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

using namespace std;



int main() {

	char c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


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

int main(){

    char letter;

    scanf("%c",&letter);

    char next = letter + 1;

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

    return 0;

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

using namespace std;

int main(){

    char a;

    cin >> a;

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

}

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

int main(){

    char letter;

    scanf("%c",&letter);

    char next = letter + 1;

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

    return 0;

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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

int main(){

    char letter;

    scanf("%c",&letter);

    char next = letter + 1;

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

    return 0;

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

using namespace std;



int main()

{

	char c;

	cin>>c;

	cout<<++c;

}

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

int main(){

    char letter;

    scanf("%c",&letter);

    char next = letter + 1;

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

    return 0;

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

using namespace std;



int main() {

	char c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


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



int main(){

	

	char bfr ;

	char aft ;

	

	scanf("%c", &bfr) ;

	

	aft = bfr+1 ;

	

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

	

	return 0;

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

using namespace std;

int main(){

    char a;

    cin >> a;

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

}

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



int main(){

	

	char bfr ;

	char aft ;

	

	scanf("%c", &bfr) ;

	

	aft = bfr+1 ;

	

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

	

	return 0;

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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



int main(){

	

	char bfr ;

	char aft ;

	

	scanf("%c", &bfr) ;

	

	aft = bfr+1 ;

	

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

	

	return 0;

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

using namespace std;



int main()

{

	char c;

	cin>>c;

	cout<<++c;

}

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



int main(){

	

	char bfr ;

	char aft ;

	

	scanf("%c", &bfr) ;

	

	aft = bfr+1 ;

	

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

	

	return 0;

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

using namespace std;



int main() {

	char c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


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



int main () {

	char str, nextstr;

	scanf("%c", &str);

	nextstr = str + 1;

	printf("%c", nextstr);

	return 0; 

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

using namespace std;

int main(){

    char a;

    cin >> a;

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

}

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



int main () {

	char str, nextstr;

	scanf("%c", &str);

	nextstr = str + 1;

	printf("%c", nextstr);

	return 0; 

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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



int main () {

	char str, nextstr;

	scanf("%c", &str);

	nextstr = str + 1;

	printf("%c", nextstr);

	return 0; 

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

using namespace std;



int main()

{

	char c;

	cin>>c;

	cout<<++c;

}

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



int main () {

	char str, nextstr;

	scanf("%c", &str);

	nextstr = str + 1;

	printf("%c", nextstr);

	return 0; 

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

using namespace std;



int main() {

	char c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


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



int main() {

  char karakter;

  scanf ("%c",&karakter);

  char manipulasi = karakter + 1;

  printf ("%c",manipulasi);

 

  

  return 0;

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

using namespace std;

int main(){

    char a;

    cin >> a;

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

}

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



int main() {

  char karakter;

  scanf ("%c",&karakter);

  char manipulasi = karakter + 1;

  printf ("%c",manipulasi);

 

  

  return 0;

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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



int main() {

  char karakter;

  scanf ("%c",&karakter);

  char manipulasi = karakter + 1;

  printf ("%c",manipulasi);

 

  

  return 0;

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

using namespace std;



int main()

{

	char c;

	cin>>c;

	cout<<++c;

}

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



int main() {

  char karakter;

  scanf ("%c",&karakter);

  char manipulasi = karakter + 1;

  printf ("%c",manipulasi);

 

  

  return 0;

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

using namespace std;



int main() {

	char c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



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

using namespace std;

int main(){

    char a;

    cin >> a;

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

}

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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

	cout<<++c;

}

// 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 c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


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



int main(){

	

	char grade;

	

	scanf("%c", &grade);

	

	char manipulate = grade + 1;

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

	

	return 0;

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

using namespace std;

int main(){

    char a;

    cin >> a;

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

}

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



int main(){

	

	char grade;

	

	scanf("%c", &grade);

	

	char manipulate = grade + 1;

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

	

	return 0;

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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



int main(){

	

	char grade;

	

	scanf("%c", &grade);

	

	char manipulate = grade + 1;

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

	

	return 0;

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

using namespace std;



int main()

{

	char c;

	cin>>c;

	cout<<++c;

}

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



int main(){

	

	char grade;

	

	scanf("%c", &grade);

	

	char manipulate = grade + 1;

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

	

	return 0;

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

using namespace std;



int main() {

	char c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


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

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

}

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

int main ()

{

	char x;

	scanf("%c",&x);

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

	

	

	return 0;

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






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

int main ()

{

	char x;

	scanf("%c",&x);

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

	

	

	return 0;

}