stablegradients/pie-gem5-pairs huggingface dataset:
// 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);

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

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

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

int main(){

	char x,y;

	scanf("%c",&x);

	y = x + 1;

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

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

int main(){

	char x,y;

	scanf("%c",&x);

	y = x + 1;

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

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

int main()

{

	char c1;

	c1=getchar();

	putchar(c1+1);

	putchar('\n');

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

int main()

{

	char c1;

	c1=getchar();

	putchar(c1+1);

	putchar('\n');

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

	scanf("%c", &n);

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

	scanf("%c", &n);

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

	scanf("%c", &n);

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



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

	scanf("%c", &x);

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



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

	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;



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



    return 0;

}


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

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



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

scanf("%c", &alpha);

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

	scanf("%c", &a);

	a++;

	printf ("%c", a);

	

	

	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;

	scanf("%c", &a);

	a++;

	printf ("%c", a);

	

	

	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;

	scanf("%c", &a);

	a++;

	printf ("%c", a);

	

	

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

    scanf("%c", &p);

    p++;

    printf ("%c", p);





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

    scanf("%c", &p);

    p++;

    printf ("%c", p);





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

    scanf("%c", &p);

    p++;

    printf ("%c", p);





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

	scanf("%c", &g);

	g++;

	printf ("%c", g);

	

	

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

	scanf("%c", &g);

	g++;

	printf ("%c", g);

	

	

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

	scanf("%c", &g);

	g++;

	printf ("%c", g);

	

	

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

  scanf("%c", &alphabet);

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

  scanf("%c", &alphabet);

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

  scanf("%c", &alphabet);

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



int main(){



    char inputan;

    char penambah;



    scanf("%c", &inputan);

    penambah=inputan + 1;

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



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



int main(){



    char inputan;

    char penambah;



    scanf("%c", &inputan);

    penambah=inputan + 1;

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



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



int main(){



    char inputan;

    char penambah;



    scanf("%c", &inputan);

    penambah=inputan + 1;

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



    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.307415890864957x):
#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;

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



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

	scanf("%c", &huruf);

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



int main() {

	char C, rumus;

	scanf("%c", &C);

	rumus = C+1;

	printf("%c", rumus);

	

	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 C, rumus;

	scanf("%c", &C);

	rumus = C+1;

	printf("%c", rumus);

	

	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 C, rumus;

	scanf("%c", &C);

	rumus = C+1;

	printf("%c", rumus);

	

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

	scanf("%c", &chr);

	

	char ans = chr+1;

	

	printf("%c", ans);

	

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

	scanf("%c", &chr);

	

	char ans = chr+1;

	

	printf("%c", ans);

	

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

	scanf("%c", &chr);

	

	char ans = chr+1;

	

	printf("%c", ans);

	

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

	

	scanf("%c", &Z);

	

	Z++;

	

	printf("%c", Z);

	

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

	

	scanf("%c", &Z);

	

	Z++;

	

	printf("%c", Z);

	

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

	

	scanf("%c", &Z);

	

	Z++;

	

	printf("%c", Z);

	

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

int main ()

{

	char huruf;

	scanf("%c", &huruf);

	char baru=huruf+1;

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

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

int main ()

{

	char huruf;

	scanf("%c", &huruf);

	char baru=huruf+1;

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

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

int main ()

{

	char huruf;

	scanf("%c", &huruf);

	char baru=huruf+1;

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

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



int main() {

  char alfabet;

   scanf("%c", &alfabet);  

  char baru = alfabet + 1;

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

 

     

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



int main() {

  char alfabet;

   scanf("%c", &alfabet);  

  char baru = alfabet + 1;

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

 

     

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



int main() {

  char alfabet;

   scanf("%c", &alfabet);  

  char baru = alfabet + 1;

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

 

     

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

	scanf("%c", &character1);

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

	scanf("%c", &character1);

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

	scanf("%c", &character1);

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

	scanf("%c", &character1);

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

 	scanf("%c",&c);

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

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

 	scanf("%c",&c);

 	printf("%c",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.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 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 k;

	scanf("%c",&k);

	char maipulasi=k+1;

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

	scanf("%c",&k);

	char maipulasi=k+1;

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

	

	

	return 0;

}