Problem:
 Score : 100 points    Problem Statement Given is a lowercase English letter C that is not z . Print the letter that follows C in alphabetical order.      Constraints  C is a lowercase English letter that is not z .         Input Input is given from Standard Input in the following format:  C       Output Print the letter that follows C in alphabetical order.        Sample Input 1 a      Sample Output 1 b  a is followed by b .       Sample Input 2 y      Sample Output 2 z  y is followed by z .

Solution (Python):
s = input()
print(chr(ord(s) + 1))

Solution (Python):

C = input()

ans = chr(ord(C) + 1)

print(ans)

Solution (Python):
s = 'abcdefghijklmnopqrstuvwxyz'
c = input()
for i in range(len(s)):
    if s[i]==c:
        print(s[i+1])

Solution (Python):
c = input()
print(chr(ord(c) + 1))

Solution (Python):
print(chr(ord(input()) + 1))

Solution (Python):
c = input()





print(chr(ord(c) + 1))

Solution (Python):
c = input()
alp = 'abcdefghijklmnopqrstuvwxyz'
ind = alp.index(c)
print(alp[ind+1])

Solution (Python):
a=input()
print(chr(ord(a)+1))

Solution (Python):
c=input()
alpha="abcdefghijklmnopqrstuvwxyz"
print(alpha[alpha.index(c)+1])

Solution (Python):
print(chr(ord(input()) + 1))

Solution (Python):
c = input()
print(chr(ord(c) + 1))

Solution (Python):
C = input()
A = ord(C) + 1
print(chr(A))

Solution (Python):
c = input()
ans = chr(ord(c)+1)
print(ans)

Solution (Python):
def main():
    s=input()
    lst=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
    print(lst[lst.index(s)+1])
    
main()

Solution (Python):

c = input()

alpha2num = lambda c: ord(c) - ord('a') + 1
num2alpha = lambda c: chr(c+96)

a = alpha2num(c) + 1
ans = num2alpha(a)

print(ans)

Solution (Python):
print(chr(ord(input()) + 1))

Solution (Python):
C = input()
print(chr(ord(C) + 1))

Solution (Python):
C = input()
print(chr(ord(C)+1))

Solution (Python):
print(chr(ord(input())+1))

Solution (Python):
import sys
from collections import defaultdict
from collections import deque
import numpy as np
import heapq
from heapq import heappush, heappop



readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)

a = input()
b = ord(a)
b += 1
print(chr(b))

Solution (Python):
C = input()
print(chr(ord(C) + 1))

Solution (Python):
c = input()
print(chr(ord(c)+1))

Solution (Python):
print(chr(ord(input())+1))

Solution (Python):
C = input()

i = ord(C)

print(chr(i+1))

Solution (Python):
s=input()
print(chr(ord(s)+1))

Solution (Python):
print(chr(ord(input()) + 1))

Solution (Python):

c = str(input())

count = ord(c)
print(chr(count + 1))

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))


alpha = 'abcdefghijklmnopqrstuvwxyz'
s = input()
print(alpha[alpha.index(s)+1])

Solution (Python):
import string

S = string.ascii_lowercase
C = input().strip()
i = S.find(C)
print(S[i+1])

Solution (Python):
C = input()

print(chr(ord(C) + 1))

Solution (Python):
import string
letters=string.ascii_lowercase
c=input()
print(letters[letters.index(c)+1])

Solution (Python):
C = input()

print(chr(ord(C)+1))

Solution (Python):
c = input()
al = "abcdefghijklmnopqrstuvwxyz"
print(al[(al.index(c)+1)%len(al)])

Solution (Python):
def examA():
    C = SI()
    ans = chr(ord(C)+1)
    print(ans)
    return

def examB():
    N = I()
    ans = 0
    print(ans)
    return

def examC():
    return

def examE():
    return

def examF():
    return

import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
alphabet = [chr(ord('a') + i) for i in range(26)]

if __name__ == '__main__':
    examA()

Solution (Python):
print(chr(ord(input())+1))

Solution (Python):
import sys
readline = sys.stdin.readline

C = ord(readline().strip())
print(chr(C+1))

Solution (Python):
print(chr(ord(input())+1))

Solution (Python):
c = input()
print(chr(ord(c)+1))

Solution (Python):
c=input()
al='abcdefghijklmnopqrstuvwxyz'
print(al[al.index(c)+1])

Solution (Python):
c = input()

print(chr(ord(c)+1))

Solution (Python):
alphabet = list("abcdefghijklmnopqrstuvwxyz")
s = input()
print(alphabet[alphabet.index(s)+1])

Solution (Python):
s=input()
ls = list("abcdefghijklmnopqrstuvwxyz")
for i in range(26):
  if ls[i] == s:
    print(ls[i+1])
    break

Solution (Python):
import sys
input = sys.stdin.readline
c = input()[: -1]
print(chr(ord(c) + 1))

Solution (Python):
C=input()
print(chr(ord(C)+1))

Solution (Python):
words = lambda t : list(map(t, input().split()))
c = input()
print(chr(ord(c)+1))

Solution (Python):
l = input()

print(chr(ord(l)+1))

Solution (Python):
c = input()
ans = chr(ord(c)+1)
print(ans)

Solution (Python):
print(chr(ord(input()) + 1))

Solution (Python):
a = input()
print(chr(ord(a)+1))

Solution (Python):

alp = 'abcdefghijklmnopqrstuvwxyz'
a = input()
idx = alp.index(a)
print(alp[idx+1])

Solution (Python):
c = input()
print(chr(ord(c)+1))

Solution (Python):
c = input()
print(chr(ord(c)+1))

Solution (Python):
C = input()
print(chr(ord(C)+1))

Solution (Python):
a = "abcdefghijklmnopqrstuvwxyz"
C = input()
id = a.index(C)
print(a[id+1])

Solution (Python):

si = lambda: input()
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))
c=si()
t=ord(c)
print(chr(t+1))

Solution (Python):
print(chr(ord(input())+1))

Solution (Python):
alph = "abcdefghijklmnopqrstuvwxyz"

c = input()
for i in range(len(alph)):
    if c == alph[i]:
        print(alph[i+1])
        exit()

Solution (Python):
from heapq import heappush, heappop
from collections import deque
import re
import math
import functools
import itertools
import fractions

def sRaw():
    return input().rstrip("\r")


def iRaw():
    return int(input())


def ssRaw():
    return input().split()


def isRaw():
    return list(map(int, ssRaw()))


INF = 1 << 29


def mk1d(n, val=INF):
    return [val for i in range(n)]

def mk2d(h, w, val=INF):
    return [[val for i in range(w)]for i in range(h)]

DIV = 998244353


def convolve(a, b):
    p, g = 1107296257, 5
    n0, n1 = len(a), len(b)
    n = 1 << (max(n0, n1) - 1).bit_length() + 1
    a = a + [0] * (n-n0)
    b = b + [0] * (n-n1)
    w = pow(g, (p - 1) // n, p)
    invw = pow(w, p-2, p)

    def fft(f):
        d = n // 2
        v = w
        while d >= 1:
            u = 1
            for i in range(d):
                for j in range(i, n, 2*d):
                    f[j], f[j+d] = (f[j] + f[j+d]) % p, u * (f[j] - f[j+d]) % p
                u = u * v % p
            v = v * v % p
            d //= 2

    def ifft(f):
        d = 1
        while d < n:
            v = pow(invw, n // (2 * d), p)
            u = 1
            for i in range(d):
                for j in range(i, n, 2*d):
                    f[j+d] *= u
                    f[j], f[j+d] = (f[j] + f[j+d]) % p, (f[j] - f[j+d]) % p
                u = u * v % p
            d *= 2

    fft(a), fft(b)
    for i in range(n):
        a[i] = a[i] * b[i] % p
    ifft(a)
    invn = pow(n, p - 2, p)
    return [a[i] * invn % p for i in range(n0 + n1 - 1)]


def gcd(a, b):
    if(b == 0):
        return a
    return gcd(b, a % b)

def lcm_base(x, y):
    return (x * y) // fractions.gcd(x, y)


def lcm(*numbers):
    return functools.reduce(lcm_base, numbers, 1)


def lcm_list(numbers):
    return functools.reduce(lcm_base, numbers, 1)

def main():
    C = sRaw()
    
    return chr(ord(C)+1)

if __name__ == "__main__":
    print(main())

Solution (Python):
C = input()
print(chr(ord(C)+1))

Solution (Python):
C = input()
print(chr(ord(C)+1))

Solution (Python):
c = input()

print(chr(ord(c) + 1))

Solution (Python):
import sys
input = sys.stdin.readline


def gcd(a: int, b: int):
    """ https://cocodrips.hateblo.jp/entry/2014/03/05/143623
    """
    while b: a, b = b, a%b
    return a

def lcm(a: int, b: int):
    return a * b // gcd(a, b)


def main():
    
    
    
    
    

    
    
    S = input().rstrip()
    
    print(chr(ord(S)+1))
    
    
    


if __name__ == "__main__":
    main()

Solution (Python):
import sys
input = sys.stdin.readline


def main():
    S = input().strip()
    print(chr(ord(S) + 1))



if __name__ == '__main__':
    main()

Solution (Python):
def num():
    return int(input())
def nums():
    return list(map(int,input().split()))

import itertools as iter
import math
import fractions
from functools import reduce

def lcm_base(x, y):
    return (x * y) // fractions.gcd(x, y)

def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)


from string import ascii_lowercase
print(ascii_lowercase[ascii_lowercase.index(input())+1])

Solution (Python):
C = input()

c = ord(C)

print(chr(c+1))

Solution (Python):
a = input()
print(chr(ord(a)+1))

Solution (Python):
c = input()

print(chr(ord(c) + 1))

Solution (Python):
C = input()
print(chr(ord(C)+1))

Solution (Python):
r = 'abcdefghijklmnopqrstuvwxyza'
c=input()
print(r[r.find(c)+1])

Solution (Python):

PLAIN = input()


KEY = 1


enc = ""

for char in list(PLAIN):
    ASCII = ord(char)
    num = ASCII - 97
    num = (num + KEY) % 26
    ASCII = num + 97
    enc += chr(ASCII)

print(enc)

Solution (Python):
print chr(ord(raw_input())+1)

Solution (Python):
c = input()
print(chr(ord(c) + 1))

Solution (Python):
print(chr(ord(input())+1))

Solution (Python):
c=input()
print(chr(ord(c)+1))

Solution (Python):
c = input()

print(chr(ord(c)+1))

Solution (Python):
S='abcdefghijklmnopqrstuvwxyz'
print(S[S.index(input())+1])

Solution (Python):
c = input()
print(chr(ord(c) + 1))

Solution (Python):
C=input()
D=chr(ord(C)+1)
print(D)

Solution (Python):


def main():
    c = input()
    print(chr(ord(c) + 1))


if __name__ == '__main__':
    main()

Solution (Python):
a = input()
print(chr(ord(a)+1))

Solution (Python):
c = input()
w = "abcdefghijklmnopqrstuvwxyz"
print(w[w.index(c)+1])

Solution (Python):
C = ord(input())

print(chr(C + 1))

Solution (Python):
a = input()
print(chr(ord(a)+1))

Solution (Python):
C = input()

c = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

n = c.index(C)
print(c[n+1])

Solution (Python):
c = input()
print(chr(1 + ord(c)))

Solution (Python):
s=str(input())
l='abcdefghijklmnopqrstuvwxyz'
for i in range(26):
    if l[i]==s:
        print(l[i+1])
        break

Solution (Python):
C = input()

ans = chr(ord(C) + 1)

print(ans)

Solution (Python):
s = "abcdefghijklmnopqrstuvwxyz"
c = input()
print(s[s.index(c)+1])

Solution (Python):
import sys
import math
import bisect

def main():
    c = input()
    c = chr(ord(c)+1)
    print(c)

if __name__ == "__main__":
    main()

Solution (Python):
ch = input().rstrip()
print(chr(ord(ch) + 1))

Solution (Python):



def main():
    c = input()
    print(chr(ord(c) + 1))


if __name__ == "__main__":
    main()

Solution (Python):
s = input()
s = chr(ord(s) + 1)
print(s)

Solution (Python):
print(chr(ord(input()) + 1))

Solution (Python):
c = input()
print (chr(ord(c) + 1))

Solution (Python):
s = input()
a = "abcdefghijklmnopqrstuvwxyz"

print(a[a.index(s) + 1])

Solution (Python):
n=input()
print(chr(ord(n)+1))

Solution (Python):
C=input()
print(chr(ord(C)+1))

Solution (Python):


from collections import defaultdict


def getlist():
	return list(map(int, input().split()))


def main():
	s = input()
	ans = chr(ord(s) + 1)
	print(ans)
	


if __name__ == '__main__':
	main()

Solution (Python):
s = input()
print(chr(ord(s) + 1))

Solution (Python):
c = raw_input()
c = chr(ord(c) + 1)
print c

Solution (Python):
import sys
def fastio():
    from io import StringIO
    from atexit import register
    global input
    sys.stdin = StringIO(sys.stdin.read())
    input = lambda : sys.stdin.readline().rstrip('\r\n')
    sys.stdout = StringIO()
    register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()

def debug(*var, sep = ' ', end = '\n'):
    print(*var, file=sys.stderr, end = end, sep = sep)

INF = 10**20
MOD = 10**9 + 7
I = lambda:list(map(int,input().split()))

from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br

a = input()
print(chr(ord(a[0]) + 1))

Solution (Python):
c=input()
print(chr(ord(c)+1))

Solution (Python):


s = input()

import string
print(chr(ord(s)+1))

Solution (Python):
c = str(input())

print(chr(ord(c) + 1))

Solution (Python):
c = input()

ans = ord(c) + 1
ans = chr(ans)
print(ans)

Solution (Python):
C = input().strip()
print(chr(ord(C)+1))

Solution (Python):
c = input()

print(chr(ord(c) + 1))

Solution (Python):
s=input()
k=ord(s)
print(chr(k+1))

Solution (Python):
C = input()
alp = "abcdefghijklmnopqrstuvwxyz"
print(alp[alp.index(C)+1])

Solution (Python):
c = input()
a = ord(c)
a+=1
a = chr(a)
print(a)

Solution (Python):
n=input()
print(chr(ord(n)+1))

Solution (Python):
c = input()

print(chr(ord(c)+1))

Solution (Python):
s = input()

print(chr(ord(s)+1))

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
from bisect import bisect

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

C = input()

print(ascii_lowercase[ascii_lowercase.index(C)+1])

Solution (Python):
C=input()
print(chr(ord(C)+1))

Solution (Python):
S = input()
print(chr(ord(S)+1))

Solution (Python):
c=input()
print(chr(ord(c)+1))

Solution (Python):
S = input()
print(chr(ord(S)+1))

Solution (Python):

import sys
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = lambda *something : print(*something) if DEBUG else 0
DEBUG = False
def main(given = sys.stdin.readline):
    input = lambda : given().rstrip()
    LMIIS = lambda : list(map(int,input().split()))
    II = lambda : int(input())
    XLMIIS = lambda x : [LMIIS() for _ in range(x)]
    MOD = 10**9 + 7
    YesNo = lambda c : print('Yes') if c else print('No')

    c = input()
    print(chr(ord(c)+1))





if __name__ == '__main__':
    main()

Solution (Python):
C = input()
n = ord(C)+1
print(chr(n))

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

c=input()
s=ord(c)
print(chr(s+1))

Solution (Python):
s = input()

print(chr(ord(s)+1))

Solution (Python):
c = input()

print(chr(ord(c) + 1))

Solution (Python):
C = input()
print(chr(ord(C)+1))

Solution (Python):
c = input()

print(chr(ord(c)+1))

Solution (Python):
c = input()
print(chr(ord(c)+1))

Solution (Python):
C = chr(ord(input())+1)
print(C)

Solution (Python):
c = input()

print(chr(ord(c)+1))

Solution (Python):
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

s = ns()
print(chr(ord(s[0])+1))

Solution (Python):
print(chr(ord(input())+1))

Solution (Python):
c = input()
print(chr(ord(c) + 1))

Solution (Python):


c=input()
print(chr(ord(c)+1))

Solution (Python):
from fractions import gcd

from heapq import*
import math
from collections import defaultdict, Counter, deque
from bisect import *
import itertools
import fractions
import sys
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7


def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors

def main():
    c = input()
    print(chr(ord(c)+1))
    
            
                

        




    


if __name__ == '__main__':
    main()

Solution (Python):
print(chr(ord(input())+1))

Solution (Python):
import math

def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]





s = input()
ans = chr(ord(s)+1)
print(ans)

Solution (Python):
C = input()
print(chr(ord(C)+1))

Solution (Python):
def main():
    C = input()
    print( chr( ord(C)+1))
if __name__ == '__main__':
    main()

Solution (Python):
c=input()
t="abcdefghijklmnopqrstuvwxyza"
print(t[t.index(c)+1])

Solution (Python):
c=input()

print(chr(ord(c)+1))

Solution (Python):
print(chr(ord(input()) + 1))

Solution (Python):
def main():

    C = input()
    return chr(ord(C)+1)

if __name__ == '__main__':
    print(main())

Solution (Python):
print(chr(ord(str(input()))+1))

Solution (Python):
S = input()
print(chr(ord(S) + 1))

Solution (Python):

import sys
INF = float("inf")


def solve(C: str):
    print(chr(ord(C)+1))
    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    C = next(tokens)  
    solve(C)


if __name__ == '__main__':
    main()

Solution (Python):
c = str(input())
print(chr(ord(c) + 1))

Solution (Python):
a = input()
print(chr(ord(a)+1))

Solution (Python):
C = input()
print(chr(ord(C) + 1))

Solution (Python):
print(chr(ord(input())+1))

Solution (Python):
import sys
import math
from collections import defaultdict

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def II(): return map(int, input().split())
def III(): return list(map(int, input().split()))
def Line(N,num):
    if N<=0:
        return [[] for _ in range(num)]
    elif num==1:
        return [I() for _ in range(N)]
    else:
        read_all = [tuple(II()) for _ in range(N)]
        return map(list, zip(*read_all))



C = str(input())

print(chr(ord(C)+1))

Solution (Python):
s = input()
print(chr(ord(s) + 1))

Solution (Python):


import sys
sys.setrecursionlimit(300000)


def solve(C: str):
    ret = chr(ord(C) + 1)
    print(ret)
    return

def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    C = next(tokens)  
    solve(C)

if __name__ == '__main__':
    main()

Solution (Python):











import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,hypot,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    S=ST()
    print(chr(ord(S)+1))
if __name__ == '__main__':
    main()

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    s = input()
    print(chr(ord(s)+1))
    return


if __name__ == "__main__":
    solve()

Solution (Python):
c=input()
print(chr(ord(c)+1))

Solution (Python):
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7



c = sys.stdin.buffer.readline().decode().rstrip()
a =     chr(ord(c) + 1)
print(a)