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):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

C = ord(read().decode('utf-8').rstrip())
C += 1

print(chr(96 + C % 96))

Solution (Python):

import sys


def solve(C: str):
    ans=ord(C)
    ans+=1
    print(chr(ans))
    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 = input()
a = ord(c)
print(chr(a+1))

Solution (Python):

c = input()

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

Solution (Python):
c = input()
lst = [chr(ord('a') + i) for i in range(26)]
n = lst.index(c)
print(lst[n+1])

Solution (Python):
a = input()


print(chr(ord(a) + 1))

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

Solution (Python):



import sys




def main():
    C = input()
    alpha = 'abcdefghijklmnopqrstuvwxyz'

    for i in range(len(alpha)):
        if C == alpha[i]:
            print(alpha[i+1])
            break



main()

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

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

Solution (Python):
c = input()
chars = ['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']
for index, cc in enumerate(chars):
    if c == 'y':
        print('z')
        exit(0)
    elif c == cc:
        print(chars[index + 1])
        exit(0)

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

Solution (Python):
c = input()

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

Solution (Python):
al = input()

b = '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'
b = b.split()

idx = b.index(al)
ans = b[idx+1]

print(ans)

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

Solution (Python):
s = input().rstrip('\n');
s_num = ord(s);
print(chr(s_num+1));

Solution (Python):
from collections import defaultdict, deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys
import random
import itertools
import math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt


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


def LF(): return list(map(float, input().split()))


def LI_(): return list(map(lambda x: int(x)-1, input().split()))


def II(): return int(input())


def IF(): return float(input())


def LS(): return list(map(list, input().split()))


def S(): return list(input().rstrip())


def IR(n): return [II() for _ in range(n)]


def LIR(n): return [LI() for _ in range(n)]


def FR(n): return [IF() for _ in range(n)]


def LFR(n): return [LI() for _ in range(n)]


def LIR_(n): return [LI_() for _ in range(n)]


def SR(n): return [S() for _ in range(n)]


def LSR(n): return [LS() for _ in range(n)]


def gcd(x, y):
    if y == 0:
        return x
    return gcd(y, x % y)


def my_index_multi(l, x):
    return [i for i, _x in enumerate(l) if _x == x]


def sosu(x):
    for i in range(2, int(sqrt(x)+1)):
        if x % i == 0:
            return False
    return True


mod = 1000000007
inf = float('INF')


def A():
    A = 'abcdefghijklmnopqrstuvwxyz'
    C = input().rstrip()
    p = 0
    for i in A:
        if C == i:
            p = 1
            continue
        if p == 1:
            print(i)
            return

    return




def B():
    N = II()
    X = LI()

    return




def true():
    S = input()
    S = S[:-1]

    tmp = 0
    for x in range(1 << (len(S)-1)):
        func = S[-1]
        for i in range(len(S)-1):
            if(x & (1 << i)):
                tmp += int(func)
                func = S[-2-i]
            else:
                func = S[-2-i]+func
        tmp += int(func)
    print(tmp)

    return


def C():
    N = II()
    L = []
    for i in range(1, N+1):
        A = II()

        for j in range(A):
            x, y = LI()
            L.append([i, x, y])





def D():

    a, b, x = LI()
    BIG = a*a*b/2
    if x > BIG:
        y = 2*b-(2*x/a/a)
        print(math.degrees(math.atan(y/a)))
    else:
        y = 2*x/a/b
        print(math.degrees(math.atan(b/y)))
    return




def E():
    N, K = LI()
    A = LI()
    F = LI()
    A.sort(reverse=True)
    F.sort()
    cost = []
    for i in range(len(N)):
        cost.append(A[i]*F[i])

    a = F[cost.index(max(cost))]

    return




def F():
    N, M = LI()

    value = [0] * M
    power = [0] * M
    for i in range(M):
        a, b = LI()
        value[i] = a
        c = LI()
        L = ['0'] * N
        for k in c:
            L[k - 1] = '1'
        bint = ''.join(L)
        power[i] = int(bint, 2)
    bint = ''.join(list(['1'] * N))
    dp = [inf] * (int(bint, 2)+1)
    t = 0
    cost = 0

    dp[0] = 0
    for s in range(int(bint, 2) + 1):
        for i in range(M):
            t = s | power[i]
            cost = dp[s] + value[i]
            dp[t] = min(dp[t], cost)
    print(-1) if(dp[-1] == inf) else print(dp[-1])

    return

    



def solution(S):
    
    N = len(S)

    pass



if __name__ == '__main__':

    A()

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

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

Solution (Python):
c = input()
a = 'abcdefghijklmnopqrtuvwxyz'
ans = ''
for i in range(len(a)):
    if c == a[i]:
        ans = a[i + 1]
        break
print(ans)

Solution (Python):
input1 = input()
list_A = ["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"]

print(list_A[list_A.index(input1)+1])

Solution (Python):
list=['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']
C = str(input())

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

Solution (Python):
list_alpha = [chr(ord('a') + i) for i in range(26)]
c = input()
index = list_alpha.index(c)
print(list_alpha[index + 1])

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

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

Solution (Python):
C = input()
H = [chr(i) for i in range(97,97+26)]
l = len(H)
for i in range(l):
    if (C==H[i]):
        ans=H[i+1]
print(ans)

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

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

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

Solution (Python):

c = input()
print(c.translate(str.maketrans("abcdefghijklmnopqrstuvwxy", "bcdefghijklmnopqrstuvwxyz")))

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

Solution (Python):




a = input()


ans = chr(ord(a) + 1)


print(ans)

Solution (Python):


x = input()
if x == "a":
    print("b")
if x == "b":
    print("c")
if x == "c":
    print("d")
if x == "d":
    print("e")
if x == "e":
    print("f")
if x == "f":
    print("g")
if x == "g":
    print("h")
if x == "h":
    print("i")
if x == "i":
    print("j")
if x == "j":
    print("k")
if x == "k":
    print("l")
if x == "l":
    print("m")
if x == "m":
    print("n")
if x == "n":
    print("o")
if x == "o":
    print("p")
if x == "p":
    print("q")
if x == "q":
    print("r")
if x == "r":
    print("s")
if x == "s":
    print("t")
if x == "t":
    print("u")
if x == "u":
    print("v")
if x == "v":
    print("w")
if x == "w":
    print("x")
if x == "x":
    print("y")
if x == "y":
    print("z")

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

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

Solution (Python):
S=input()

print(chr(ord(S)+1))

Solution (Python):
N=input()

c=ord(N)

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

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

Solution (Python):
C = input()
alpha=['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 = alpha[alpha.index(C)+1]
print(A)

Solution (Python):
r = input()
a = [chr(i) for i in range(97, 97+26)]

for i in range(25):
    if r == a[i]:
        print(a[i+1])

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

C = input()

C = C.replace('\n', '')

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

index_c = alphabets.index(C)

print(alphabets[index_c + 1])

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

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

Solution (Python):
abts = "abcdefghijklmnopqrstuvwxyz"
cin = str(input())
for i in range(len(abts)):
  if cin == abts[i]:
    print(abts[i+1])

Solution (Python):
c = input()
list=["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"]
l = list.index(c) + 1
c = list[l]
print(c)

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

Solution (Python):
N = "abcdefghijklmnopqrstuvwxyz" 

print(N[N.find(input())+1])

Solution (Python):

    
C=input()

alphabet=["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"]

i=alphabet.index(C)

print(alphabet[i+1])

Solution (Python):
C=input()
l=["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"]
for i in range(30):
    if l[i]==C:
        print(l[i+1])
        break

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

Solution (Python):
mozi = input()

hairetu = 'abcdefghijklmnopqrstuvwxyz'

for i in range(len(hairetu)):
  if mozi==hairetu[i]:
    print(hairetu[i+1])

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

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

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

Solution (Python):
C = input()
a = ["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 = a.index(C)
print(a[n+1])

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

Solution (Python):
X = str(input())
alist = ["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"]
for i in range(30):
  if X == alist[i]:
    print(alist[i+1])
    break

Solution (Python):
import string
alphabets = list(string.ascii_lowercase)
inputted = input()
a = alphabets.index(inputted) + 1
answer = alphabets[a]
print(answer)

Solution (Python):


lowercase = 'abcdefghijklmnopqrstuvwxyz'

input_s = input()

for s in lowercase:
    if(s==input_s):
        idx = lowercase.index(s)
        print(lowercase[idx+1])
        break

Solution (Python):
s = input()
S='abcdefghijklmnopqrstuvwxyz'

for i in range(26):
    if s == S[i]:
        ans = S[i+1]

print(ans)

Solution (Python):
import math
import fractions

a = "abcdefghijklmnopqrstuvwxyz"
x = input()
print(a[a.index(x) + 1])

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

Solution (Python):
a=['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']
c=input()
for i in range(len(a)):
    if c is a[i]:
        print(a[i+1])
    else:
        continue

Solution (Python):
C = input()
l=["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"]
print(l[l.index(C)+1])

Solution (Python):
z = 'abcdefghijklmnopqrstuvwxyz'
x = 0
a = input()
print(z[z.index(a)+1])

Solution (Python):
c = input()
a = ["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 = a.index(c) + 1
print(a[n])

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

A()

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

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

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

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

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

Solution (Python):
def solve(ch):
    return chr(ord(ch) + 1)


if __name__ == "__main__":
    raw = input()
    print(solve(raw))

Solution (Python):
alpha = {'a':'b','b':'c','c':'d','d':'e','e':'f','f':'g','g':'h','h':'i','i':'j','j':'k','k':'l','l':'n','n':'m','m':'o','o':'p','p':'q','q':'r','r':'s','s':'t','t':'u','u':'v','v':'w','w':'x','x':'y','y':'z'}
char = input()
print(alpha[char])

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

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

Solution (Python):
a = str(input())
l = ['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']
i = l.index(a)
print(l[i+1])

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

Solution (Python):
A = input()
k = lambda c: ord(c) - ord('A') + 1
l = lambda c: chr(c+64)

print(l(k(A)+1))

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

a = input().strip()
print(chr(ord(a) + 1))

Solution (Python):
c = input()
l = ['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']

print(l[l.index(c)+1])

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

Solution (Python):
N = input()

l = [chr(i) for i in range(97, 97+26)]

print(l[l.index(N) + 1])

Solution (Python):
list = [
    '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'
    ]

s = input()
t = int(list.index(s))
k = t + 1
print(list[k])

Solution (Python):
str = input()

print(chr(ord(str) + 1))

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

num = s.find(c)

print(s[num + 1])

Solution (Python):
a=input()
if a=='z':
    print('a')
else:
    print(chr(ord(a)+1))

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

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

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

alpha = ['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']

for i,a in enumerate(alpha):
    if a == C:
        print(alpha[i+1])

Solution (Python):


import sys
import math


debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        
        
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    c = [e for e in lines[0].split(" ")][0]

    return (c, )


def solve(c):

    a = "abcdefghijklmnopqrstuvwxyz"
    i = a.index(c)

    return a[i+1]


def main():
    
    result = solve(*parse_input())
    if isinstance(result, list):
        for r in result:
            print("%s" % r, sep='')
    else:
        print("%s" % result, sep='')

if __name__ == '__main__':

    main()

Solution (Python):
C = input()
alphas = [chr(ord("a") + i) for i in range(26)]

i = alphas.index(C) + 1
print(alphas[i])

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

Solution (Python):
c = input()

alp = 'abcdefghijklmnopqrstuvwxyz'
i = alp.find(c)

print(alp[i+1])

Solution (Python):
C = input()

char_code = ord(C)
next_char = chr(char_code + 1)

print(next_char)

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

print(chr(C+1))

Solution (Python):
C = input()

li = ["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"]
k = li.index(C)
print(li[k+1])

Solution (Python):
s = str(input())
l = 'abcdefghijklmnopqrstuvwxyz'
l = list(l)
i = l.index(s)
print(l[i+1])

Solution (Python):
X=input()
ABC='abcdefghijklmnopqrstuvwxyza'
Z=ABC.index(X)
print(ABC[Z+1])

Solution (Python):
x = str(input())
alph = 'abcdefghijklmnopqrstuvwxyz'
a = alph.find(x) + 1
b = alph[a]
print(b)

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

Solution (Python):
c = input()
ordc = ord(c)

if ordc != 122:
    print(chr(int(ordc)+1))
else:
    print('a')

Solution (Python):
C = input()

S = 'abcdefghijklmnopqrstuvwxyz'

print(S[1+S.find(C)])

Solution (Python):
c = input()
s = ['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']

num_s = s.index(c)
print(s[num_s+1])

Solution (Python):
C=input()
flag=False

lis=["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"]

for item in lis:
  if flag==True:
    print(item)
    break
  else:
    if item==C:
      flag=True

Solution (Python):
import sys
from pprint import pprint

def solve(c):
    print(chr(ord(c)  + 1))

if __name__ == '__main__':
    c = sys.stdin.readline().strip()
    solve(c)

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline






















def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

def main():
	N = input()
	N = N[:-1]

	ind = [chr(i) for i in range(97,97+26)]

	for i, val in enumerate(ind):
		
		if val == N:
			print(ind[i+1])

if __name__ == "__main__":
	main()

Solution (Python):
word = input()
word_list = [chr(ord('a') + i) for i in range(26)]
print(word_list[word_list.index(word) + 1])

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

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

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

Solution (Python):
c = input().strip()

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

Solution (Python):
C = input()
alphabet_list  = [
    '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'
]
for i, alphabet in enumerate(alphabet_list):
    if C == alphabet:
        print(alphabet_list[i + 1])
        break

Solution (Python):
C = input()
a = ["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"]
for i in range(len(a)-1):
    if C == a[i]:
        print(a[i+1])
        break
    else:
        pass

Solution (Python):
c = input()

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

Solution (Python):
C = input()
l = [chr(i) for i in range(97, 97 + 26)]
print(l[l.index(C)+1])

Solution (Python):
C = input()
ALL = ['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']

for i in range(26):
    if C == ALL[i]:
        print(ALL[i+1])
        break

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

Solution (Python):


Alphabet = "abcdefghijklmnopqrstuvwxyz"
alp = list(Alphabet)
c = input()

print( alp[alp.index(c)+1] )

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

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

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

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

Solution (Python):
c = input()
alp = ["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"]
count = 0
for i in range(len(alp)):
    if c == alp[i]:
        break
    count += 1
print(alp[count+1])

Solution (Python):
def main():
    s = input()
    print(chr((ord(s)+1)))
    return 0

if __name__ == "__main__":
    main()

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

Solution (Python):
c = input()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'

place = ascii_lowercase.index(c)

print(ascii_lowercase[place + 1])

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

import string
lst = string.ascii_lowercase

print(lst[lst.find(input().strip()) + 1])

Solution (Python):
from sys import stdin
c = str(stdin.readline().rstrip())



list = ["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"]
print(list[list.index(c)+1])

Solution (Python):
C = input()
alphabet = ["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"]

count = 0
for i in alphabet:
    count += 1
    if (i.lower() == C):
        break

print(alphabet[count].lower())

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

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

Solution (Python):
s=input()

if s=="a":
    print()

alpha2num = lambda c: ord(c) - ord('A') + 1

n=alpha2num(s)

num2alpha = lambda c: chr(c+64)

print(num2alpha(n+1))

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

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

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

Solution (Python):
s = "abcdefghijklmnopqrstuvwxyz"
C = str(input())
print(s[s.find(C)+1])

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

Solution (Python):
S=input()
Z='abcdefghijklmnopqrstuvwxyz'
for i  in range (len(Z)):
    if Z[i] == S:
        print(Z[(i+27)%26])
        break

Solution (Python):
c = input()

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

Solution (Python):
c_data = input()

if(c_data != 'z'):
	r_data = chr(ord(c_data) + 1)
else:
	r_data = c_data

print(r_data)

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

Solution (Python):
cl=input()
al=['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']
print(al[al.index(cl)+1])

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

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

Solution (Python):
char = input()

char_list = "abcdefghijklmnopqrstuvwxyz"
print(char_list[char_list.index(char) + 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()

num2alpha = lambda c: chr(c+64)
alpha2num = lambda c: ord(c) - ord("A") + 1
print(num2alpha(alpha2num(C)+1))

Solution (Python):
s = "abcdefghijklmnopqrstuvwxyz"
C = str(input())
print(s[(s.index(C)+1)%26])

Solution (Python):
alfabet = 'abcdefghijklmnopqrstuvwxyz'
pos = alfabet.find(input())
print(alfabet[pos+1:pos+2])

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline






















def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

def main():
	N = input()
	N = N[:-1]

	ind = [chr(i) for i in range(97,97+26)]

	for i, val in enumerate(ind):
		
		if val == N:
			print(ind[i+1])

if __name__ == "__main__":
	main()

Solution (Python):
al=[chr(ord('a') + i) for i in range(26)]
C = input()
tmp = al.index(C)
print(al[tmp+1])

Solution (Python):
char = 'abcdefghijklmnopqrstuvwxyz'

c = input()
k = char.index(c)

print(char[k+1])

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

Solution (Python):
import string
store = string.ascii_lowercase
store_map = dict()
reverse_map = dict()
for i in range(26):
    store_map[store[i]] = i
    reverse_map[i] = store[i]
x = input()
print(reverse_map[store_map[x] + 1])

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


if __name__ == '__main__':
    solve()

Solution (Python):


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

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

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

Solution (Python):
c = input()

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

Solution (Python):

import sys
import string

def solve(C: str):
    for i, s in enumerate(string.ascii_lowercase):
        if s == C:
            print(string.ascii_lowercase[i+1])



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):
alf=['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=input()
for i in range(25):
    if A==alf[i]:
        print(alf[i+1])

Solution (Python):
c = str(input())
abc = 'abcdefghijklmnopqrstuvwxyz'
print(abc[abc.find(c)+1])

Solution (Python):
alpha = ["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"]
c = str(input())

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

Solution (Python):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

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

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

chr_s = chr(ord_s+1)
print(chr_s)

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

Solution (Python):
import sys
input = sys.stdin.readline
C = input().strip()
print(chr(ord(C)+1))

Solution (Python):
S = str(input())
L = ['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 = L.index(S)
print(L[n+1])

Solution (Python):
s=input()

li = [chr(i) for i in range(97, 97+26)]
ans = 0

for index, i in enumerate(li):
  if i == s:
    ans = index

print(li[ans + 1])

Solution (Python):
c = input()
s = [chr(i) for i in range(97, 97+26)]

for i in range(len(s)):
  if s[i] == c:
    print(s[i + 1])
    break

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

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

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


if __name__ == "__main__":
    main()

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

Solution (Python):
alphabet = ["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"]
cha = input()
for i,j in enumerate(alphabet):
    if j == cha:
        print(alphabet[i + 1])

Solution (Python):
s = input()
n = ord(s)

print(chr(n+1))

Solution (Python):
c = input()
c_lst = [chr(i) for i in range(97, 97+26)]
print(c_lst[c_lst.index(c)+1])

Solution (Python):
a = input()
m = ['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']

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

Solution (Python):
import string
c = input()

upper = string.ascii_lowercase
ind = upper.index(c)
print(upper[ind+1])

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

Solution (Python):
import sys

f = sys.stdin
C = ord(f.readline()[:-1])
print(chr(C+1))

Solution (Python):
import string
alphabet=string.printable
N = input()
print(alphabet[alphabet.index(N)+1])

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

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

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

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

Solution (Python):
c = input()
A = ["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"]
for i in range(len(A)):
    if A[i] == c:
        print(A[i + 1])
        break

Solution (Python):
def main():
    C = input()

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


if __name__ == "__main__":
    main()

Solution (Python):
C = input()

ans = "abcdefghijklmnopqrstuvwxyz"

print(ans[ans.find(C) + 1])

Solution (Python):

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

Solution (Python):
C=input()

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

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

Solution (Python):

import sys


def solve(C: str):
    a = "abcdefghijklmnopqrstuvwxyz"
    for i in range(len(a)):
        if a[i] == C:
            print(a[i+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 = input()
alphabet = "abcdefghijklmnopqrstuvwxyz"
for i in range(len(alphabet)):
    if alphabet[i] == c:
        print(alphabet[i + 1])
        break

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

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

Solution (Python):
c=input()
alis=["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"]
print(alis[alis.index(c)+1])

Solution (Python):
alp = input()
alpha2num = lambda c: ord(c) - ord('A') + 1
num2alpha = lambda c: chr(c+64)

print(num2alpha(alpha2num(alp)+1))

Solution (Python):
c=input()
list=['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']
for i in range(26):
  if c==list[i]:
    print(list[i+1])

Solution (Python):
C = input()

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

Solution (Python):
a = input()

b = [chr(ord('a') + i) for i in range(26)]

c = b.index(a)

print(b[c+1])

Solution (Python):
C = input()[0]

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

Solution (Python):
a=input()

print(chr(ord(a) + 1))

Solution (Python):


C=input()
myord=1+ord(C)
print(chr(myord))

Solution (Python):
c = input()

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

Solution (Python):
S=input()

print(chr(ord(S)+1))

Solution (Python):
a=["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"]
s=input()
q=a.index(s)
print(a[q+1])

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

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
import math
from fractions import gcd
from itertools import count, permutations
from functools import lru_cache
from collections import defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok


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




main()

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

Solution (Python):
c = input()

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

Solution (Python):
xx = input()
if xx == 'a':
  print('b')
elif xx == 'b':
  print('c')
elif xx == 'c':
  print('d')
elif xx == 'd':
  print('e')
elif xx == 'e':
  print('f')
elif xx == 'f':
  print('g')
elif xx == 'g':
  print('h')
elif xx == 'h':
  print('i')
elif xx == 'i':
  print('j')
elif xx == 'j':
  print('k')
elif xx == 'k':
  print('l')
elif xx == 'l':
  print('m')
elif xx == 'm':
  print('n')
elif xx == 'n':
  print('o')
elif xx == 'o':
  print('p')
elif xx == 'p':
  print('q')
elif xx == 'q':
  print('r')
elif xx == 'r':
  print('s')
elif xx == 's':
  print('t')
elif xx == 't':
  print('u')
elif xx == 'u':
  print('v')
elif xx == 'v':
  print('w')
elif xx == 'w':
  print('x')
elif xx == 'x':
  print('y')
else:
  print('z')
exit()

Solution (Python):
C = input()

alphabet = 'abcdefghijklmnopqrstuvwxyz'

pos = alphabet.find(C)
pos += 1

print(alphabet[pos])