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):
print(chr(ord(input().strip()) + 1))

Solution (Python):
c = input()

c = chr(ord(c)+1)

print(c)

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

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

Solution (Python):
c = input()
s = list('abcdefghijklmnopqrstuvwxyz')

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

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

Solution (Python):
c = input()
s = list('abcdefghijklmnopqrstuvwxyz')

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

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

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

Solution (Python):
n = input()

ord_s = ord(n)

chr_s = chr(ord_s + 1)

print(chr_s)

Solution (Python):
c = input()

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
C = input()
word = 'abcdefghijklmnopqrstuvwxyz'
i = word.find(C)
print(word[i+1])

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

Solution (Python):
C = input()

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

Solution (Python):
C=input()
al=[]
for idx in range(97,123):
  al.append(chr(idx))
idx = al.index(C)
print(al[idx+1])

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

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

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

Solution (Python):
l=list("abcdefghijklmnopqrstuvwxyz")
ans=input()
for i in range(len(l)):
    if l[i]==ans:
        print(l[i+1])
        break

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

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

Solution (Python):



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


def main():
    C = input().strip()
    answer = solve(C)
    print(answer)


if __name__ == "__main__":
    main()

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"]

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

Solution (Python):
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"]

C = input()

kk = al.index(C)

print(al[kk+1])

Solution (Python):
c = input()

a = "abcdefghigklmnopqrstuvwxyz"

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

Solution (Python):
S = input()

X = "abcdefghijklmnopqrstuvwxyz"

M = X.index(S)
print(X[M+1])

Solution (Python):
c = ord(input())
print(chr(c + 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"]

a1=A.index(C)+1

print(A[a1])

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

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

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

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

Solution (Python):
C = input()
 


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

Solution (Python):
C = input()

l = list('abcdefghijklmnopqrstuvwxyz')
print(l[l.index(C)+1])

Solution (Python):
s = input()
print(chr(ord(s)+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 = input()

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

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

Solution (Python):
C = input()

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

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

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

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

Solution (Python):

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

if __name__ == "__main__":
    main()

Solution (Python):
from sys import exit
import math
import collections
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

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

Solution (Python):
S = 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"]
x = alphabet.index(S)
print(alphabet[x+1])

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

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

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

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

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

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

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

Solution (Python):
c = input()
c_chr = ord(c)
print("{0}".format(chr(c_chr + 1)))

Solution (Python):
c=input()
num=ord(c)
if num!=122:
    print(chr(num+1))
else:
    print('a')

Solution (Python):
C = input()
alpha = list('abcdefghijklmnopqrstuvwxyz')

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

Solution (Python):
ri = lambda S: [int(v) for v in S.split()]
def rii(): return ri(input())
 
C = input()
print(chr(ord(C)+1))

Solution (Python):
C = input()

if C == 'z':
    print('z')
else:
    print(chr(ord(C) + 1))

Solution (Python):
alp = 'abcdefghijklmnopqrstuvwxyz'

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

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

j = 0
for i in alpha:
    if i == C:
        print(alpha[j+1])
    j += 1

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

Solution (Python):
C = input()



ord_s = ord(C)
chr_s = chr(ord_s + 1)

print(chr_s)

Solution (Python):


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

Solution (Python):
print('abcdefghijklmnopqrstuvwxyz'['abcdefghijklmnopqrstuvwxyz'.find(input())+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):
S = ord(input())
print(chr(S+1))

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


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


if __name__ == '__main__':
    main()

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

Solution (Python):
import sys

c = next(sys.stdin).strip()
i = ord(c)
c1 = chr(i + 1)
print(c1)

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

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

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

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

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

Solution (Python):
c = str(input())
alp = "abcdefghijklmnopqrstuvwxyz"
i = 0
while True:
  if(alp[i]==c):
    print(alp[i+1])
    break
  i+=1

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

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

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

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

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

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

print(alf[(alf.index(n))+1])

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

Solution (Python):

from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b


def sum_of_arithmetic_progression(s, d, n):
    return n * (2 * s + (n - 1) * d) // 2


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


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


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


def main():
    solve()


if __name__ == '__main__':
    main()

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

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

Solution (Python):
c = str(input())
print(chr((ord(c)) + 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):
c=input()
x="abcdefghijklmnopqrstuvwxyz"
for i in range(25):
    if x[i]==c:
        print(x[i+1])
        break

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

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

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

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

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

Solution (Python):
S = 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 (25):
  if S == L[i]:
    print (L[i+1])

Solution (Python):
str = input()
letters = list("abcdefghijklmnopqrstuvwxyz")
idx = 1 + letters.index(str)
print(letters[idx])

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

Solution (Python):
import string
ab = string.ascii_lowercase
bc = ab[1:] + 'a'
c = input()
for a, b in zip(ab, bc):
    if a == c:
        print(b)

Solution (Python):
A = input()

B = chr(ord(A) + 1)

print(B)

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

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(100000)
input = sys.stdin.readline
def main():
    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']

    c = input().strip()

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


main()

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

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

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

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

Solution (Python):
C = input()

tmp = ord(C)

print(chr(tmp + 1))

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

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

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

Solution (Python):
C = input()

次の英単語 = ord(C)+1

print(chr(次の英単語))

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

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

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

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

Solution (Python):
import string
C = input()
l = string.ascii_lowercase
i = l.index(C)
print(l[i+1])

Solution (Python):
import string

c = input()
x = string.ascii_lowercase.index(c)+1
print(string.ascii_lowercase[x])

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

Solution (Python):
alp = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','w','v','x','y','z']
c = str(input())
print(alp[alp.index(c)+1])

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy








def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

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

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):
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()
l = [chr(ord("a")+i) for i in range(26)]
for i in range(26):
    if l[i] == c:
        print(l[i+1])
        break

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

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

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

main()

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

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

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

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

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

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

Solution (Python):


from typing import *
import collections
import functools
import itertools
import math
import sys

INF = float('inf')


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


def main():

    sys.setrecursionlimit(10 ** 6)

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    C = next(tokens)  
    print(f'{solve(C)}')


if __name__ == '__main__':
    main()

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush

sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

c = input()

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7) 
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque, defaultdict


from collections import Counter

from itertools import accumulate,combinations,permutations,product

from heapq import heapify,heappop,heappush

from functools import reduce,lru_cache

from decimal import Decimal

def input(): 
    x=sys.stdin.readline()
    return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def binr(x): return bin(x)[2:]
def bitcount(x): 
    x= x - ((x >> 1) & 0x5555555555555555)
    x= (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x= (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f 
    x+= (x >> 8); x+= (x >> 16); x+= (x >> 32) 
    return x & 0x7f

def main():
    mod = 1000000007
    

    
    
    
    
    


    s=input()
    print(num2alp(alp2num(s)+1))



if __name__ == "__main__":
    main()

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
sys.setrecursionlimit(10**7)

def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())

def main():
    C = S()
    print(str(chr(ord(C)+1)))

main()

Solution (Python):
letters="abcdefghijklmnopqrstuvwxyz"
print(letters[letters.rfind(input())+1])

Solution (Python):
c=input()

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

Solution (Python):
N=input()
def alpha2num(alpha):
    num=0
    for index, item in enumerate(list(alpha)):
        num += pow(26,len(alpha)-index-1)*(ord(item)-ord('A')+1)
    return num
S=alpha2num(N)+1
num2alpha = lambda c: chr(c+64)

print(num2alpha(S))

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

Solution (Python):

c = input()

abc_list = 'abcdefghijklmnopqrstuvwxyz'

print(abc_list[abc_list.find(c) + 1])

Solution (Python):
a = str(input())
alpha2num = lambda c: ord(c) - ord('A') + 1
b = alpha2num(a)
c = int(b) + 1
num2alpha = lambda c: chr(c+64)
print(num2alpha(c))

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

Solution (Python):

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


if __name__ == "__main__":
    main()

Solution (Python):
s = input()
list_s = list(range(97, 97+26))
for i in range(26):
    if ord(s) == list_s[i]:
        print(chr(list_s[i+1]))

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

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

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):
a=input()
if a=='z':
  print('a')
else: 
  res=ord(a)+1
  print(chr(res))

Solution (Python):
import sys
from string import ascii_lowercase as a2z

input = sys.stdin.readline


def main():
    C = input().rstrip()

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


if __name__ == "__main__":
    main()

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

Solution (Python):
C = input()

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

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

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

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

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

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

Solution (Python):

C = input()

from string import ascii_lowercase as alp
ans = alp[alp.index(C) + 1]
print(ans)

Solution (Python):
C = input()

alp = list('abcdefghijklmnopqrstuvwxyz')
i = alp.index(C)
print(alp[i+1])

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

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

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

Solution (Python):
c = str(input())
a = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y', 'z']
print(a[a.index(c) + 1])

Solution (Python):
c = input()

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

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

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

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

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

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

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

if __name__ == '__main__':
    main()

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

Solution (Python):
C = input()
chars = "abcdefghijklmnopqrstuvwxyz"
ls = list(chars) + list(chars)
dic = {ls[i]:ls[i+1] for i in range(26)}
print(dic[C])

Solution (Python):
print(chr(ord(input())+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):
C = input()
alphabet = 'abcdefghijklmnopqrstuvwxyz'
print(alphabet[(alphabet.index(C) + 1) % len(alphabet)])

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

Solution (Python):
import os, sys, re, math

C = input()

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

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

Solution (Python):
a = 'abcdefghijklmnopqrstuvwxyz'
hoge = input()
print(a[a.find(hoge) + 1])

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

if '__main__' == __name__:
    resolve()

Solution (Python):
s = 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', 'a']
for i in range(26):
  if s == l[i]:
    print(l[i+1])
    break

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

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

Solution (Python):
C = input()

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

Solution (Python):
A = input()
B = "abcdefghijklmnopqrstuvwxyz"
print(B[B.find(A)+1])

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

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

Solution (Python):
C=str(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()
a=ord(c)
print(chr(a+1))

Solution (Python):
if __name__ == "__main__":
  char = input()
  data = ord(char)
  data += 1
  print(chr(data))

Solution (Python):
def main():
    from string import ascii_lowercase
    c = input()
    ind = ascii_lowercase.index(c)
    ind += 1
    print(ascii_lowercase[ind])


if __name__ == '__main__':
    main()

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

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

if __name__ == "__main__":
    solve()

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

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

Solution (Python):
def next_alphabet():
    
    C = input()
    return chr(ord(C)+1)

result = next_alphabet()
print(result)

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

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

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

Solution (Python):


def main():

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

    for i, name in enumerate(listAlphabet):
        if name == C:
            ans = listAlphabet[i + 1]
            break

    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
c = input()

l = [chr(i) for i in range(97, 123)]
print(l[l.index(c) + 1])

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

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

Solution (Python):
C = input()

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

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

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

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

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']

n=input()

print(alphabet[alphabet.index(n)+1])

Solution (Python):






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

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

Solution (Python):





































global FLAG_LOG
FLAG_LOG = False


def log(value):
    
    
    if FLAG_LOG:
        print(str(value))


def calculation(lines):
    C = lines[0]
    
    
    
    
    
    
    
    
    
    
    alp = 'abcdefghijklmnopqrstuvwxyz'

    for i in range(25):
        if alp[i] == C:
            result = alp[i+1]

    return [result]



def get_input_lines(lines_count):
    lines = list()
    for _ in range(lines_count):
        lines.append(input())
    return lines



def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['a']
        lines_export = ['b']
    if pattern == 2:
        lines_input = ['y']
        lines_export = ['z']
    return lines_input, lines_export



def get_mode():
    import sys
    args = sys.argv
    global FLAG_LOG
    if len(args) == 1:
        mode = 0
        FLAG_LOG = False
    else:
        mode = int(args[1])
        FLAG_LOG = True
    return mode



def main():
    import time
    started = time.time()
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines(1)
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    
    
    
    
    
    
    
    
    
    
    



if __name__ == '__main__':
    main()

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

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

Solution (Python):

import collections as cl
import sys


def II():
    return int(sys.stdin.readline())


def MI():
    return map(int, sys.stdin.readline().split())


def LI():
    return list(map(int, sys.stdin.readline().split()))


def main():

    c = input()

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


main()

Solution (Python):

import math

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



c = input()
ans = 0


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

Solution (Python):
C = input()

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

Solution (Python):
C =input()
L =[]
for i in range(97, 123):
    L.append(chr(i)) 
print(L[ord(C)-96])

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

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

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

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

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

Solution (Python):
S=input()
I="abcdefghijklmnopqrstuvwxyz"
for i in range(26):
    if S==I[i]:
        print(I[i+1])
        exit()

Solution (Python):
S=input()
I="abcdefghijklmnopqrstuvwxyz"
for i in range(26):
    if S==I[i]:
        print(I[i+1])
        exit()

Solution (Python):
import string
C = input()
R = string.ascii_lowercase

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

Solution (Python):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

c=v()
aa = "abcdefghijklmnopqrstuvwxyz"
print(aa[aa.index(c)+1])

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import numpy as np
import sys
sys.setrecursionlimit(10**7)

def _S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())

C =_S()






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

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

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