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):
x = input()
ans = ord(x) + 1
print(chr(ans))

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

Solution (Python):
from sys import stdin

al = stdin.read(1)
print(chr(ord(al) + 1))

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

print(chr(read()[0] + 1))

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

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

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

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

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

Solution (Python):
t  =input()
a = list('abcdefghijklmnopqrstuvwxyz')
t = a.index(t)
print(a[t+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()

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

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

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

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

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

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

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"]
al=input()
for i in  Alphabet :
	if i==al:
		aa=Alphabet.index(al)+1
		print(Alphabet[aa])

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

Solution (Python):
C = input()

L = 'abcdefghijklmnopqrstuvwxyz'
n = L.index(C) + 1
print(L[n])

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

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

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

print(chr(s + 1))

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

Solution (Python):
s = input() 

def next_alpha(t):
    return chr((ord(t)+1 - 97) % 26 + 97)

print(next_alpha(s))

Solution (Python):
c = input()

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

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

Solution (Python):
int_a = 97
num_char = 26

c = input()
asc = ord(c)

if asc >= int_a:
    if asc < int_a + num_char - 1:
        print(chr(asc + 1))
    else:
        print("Please Input from a to y.")
else:
    print("Please Input from a to y.")

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

Solution (Python):
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def S_():
    return input()
def LS():
    return [i for i in input().split()]
def I():
    return int(input())
def MI():
    return map(int,input().split())
def LI():
    return [int(i) for i in input().split()]
def LI_():
    return [int(i)-1 for i in input().split()]
def NI(n):
    return [int(input()) for i in range(n)]
def NI_(n):
    return [int(input())-1 for i in range(n)]
def StoI():
    return [ord(i)-97 for i in input()]
def ItoS(nn):
    return chr(nn+97)
def LtoS(ls):
    return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
    org_inp=[]
    g=[[] for i in range(n)]
    for i in range(E):
        inp=LI()
        org_inp.append(inp)
        if index==0:
            inp[0]-=1
            inp[1]-=1
        if len(inp)==2:
            a,b=inp
            g[a].append(b)
            if not Directed:
                g[b].append(a)
        elif len(inp)==3:
            a,b,c=inp
            aa=(inp[0],inp[2])
            bb=(inp[1],inp[2])
            g[a].append(bb)
            if not Directed:
                g[b].append(aa)
    return g,org_inp
def bit_combination(k,n=2):
    rt=[]
    for tb in range(n**k):
        s=[tb//(n**bt)%n for bt in range(k)]
        rt+=[s]
    return rt
def show(*inp,end='\n'):
    if show_flg:
        print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
sys.setrecursionlimit(10**5)
input=lambda: sys.stdin.readline().rstrip()

def ran_input():
    import random
    n=random.randint(4,16)
    rmin,rmax=1,10
    a=[random.randint(rmin,rmax) for _ in range(n)]
    return n,a

class Comb:
    def __init__(self,n,mo=10**9+7):
        self.fac=[0]*(n+1)
        self.inv=[1]*(n+1)
        self.fac[0]=1
        self.fact(n)
        for i in range(1,n+1):
            self.fac[i]=i*self.fac[i-1]%mo
            self.inv[n]*=i
            self.inv[n]%=mo
        self.inv[n]=pow(self.inv[n],mo-2,mo)
        for i in range(1,n):
            self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
        return
    
    def fact(self,n):
        return self.fac[n]
        
    def invf(self,n):
        return self.inv[n]

    def comb(self,x,y):
        if y<0 or y>x:
            return 0
        return self.fac[x]*self.inv[x-y]*self.inv[y]%mo

show_flg=False
show_flg=True


ans=0

s=input()
l_alp=l_alp*2
ans=l_alp[l_alp.index(s)+1]
print(ans)

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

Solution (Python):
C=input()

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

Solution (Python):
import sys
sys.setrecursionlimit(10000000)

from bisect import *
from collections import *




INF = 500000
mod = 10**9+7

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=str(input())
a=[chr(i) for i in range(97, 97+26)]
print(a[a.index(C)+1])

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
c = read().decode("utf-8").strip()
l = list("abcdefghijklmnopqrstuvwxyz")
 
if c == "z":
    print("a")
    quit()
 
f = False
for a in l:
    if a == c:
        f = True
        continue
    if f:
        ans = a.strip()
        print(ans)
        quit()

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

print(chr(c))

Solution (Python):

import sys
from fractions import gcd
from string import ascii_lowercase as ABC

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

print(ABC[ord(input())-96])

Solution (Python):
s = input()
alphabet = list('abcdefghijklmnopqrstuvwxyz')
print(alphabet[alphabet.index(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']
C = input()
if (C != 'z') and (C in a):
	i = a.index(C)
	print (a[i+1])

Solution (Python):
l = list('abcdefghijklmnopqrstuvwxyz')
s = input()
if s != "z":
    print(l[l.index(s)+1])

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

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

Solution (Python):
C=input()
X=['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(0,25):
  if X[i]==C:
    print (X[i+1])

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

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

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

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

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

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

Solution (Python):
c=input()
if c != 'z':
    print(chr(ord(c)+1))

Solution (Python):
z = 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 b in range(26):
    if a[b]==z:
        c=b+1
print(a[c])

Solution (Python):
a = input() 
if(a!="z") :
  asc=ord(a) 
  asc+=1
  print(chr(asc) )

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

if __name__ == "__main__":
    main()

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

Solution (Python):
c=input()
if c != 'z':
    print(chr(ord(c)+1))

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

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","w","x","y","z"]
xx = 0
for i in A:
  xx = xx + 1
  
  if i == c:
    print(A[xx])

Solution (Python):
inp = input()
alphabets='abcdefghijklmnopqrstuvwxyz'
count = 0
count_max = 25
out = ''
 
while count < count_max :
    if alphabets[count] == inp :
      out = alphabets[count+1]
    count += 1
  
print(out)

Solution (Python):
C = input()

ans = ['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']
ans2 = int(ans.index(C)) + 1
print(ans[ans2])

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

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

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

Solution (Python):
import sys

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

ina = input()

place = alphabet.index(ina)

nn = int(place) + 1

print(alphabet[nn])

Solution (Python):
def main():
    s = input()
    print(chr(ord(s) + 1))
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,w,v,x,y,z'

arr = a.split(",")

idx = 0
count = 0

for i in arr:
  if i == C:
    idx = count
  count += 1
  
print(arr[idx+1])

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

Solution (Python):
import sys

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

ina = input()

place = alphabet.index(ina)

nn = int(place) + 1

print(alphabet[nn])

Solution (Python):

import string

C = input()


alphabet=string.ascii_lowercase

flag=""
for s in alphabet:
  if flag == "True":
    print (s)
    break

  if s == C:
    flag = "True"

Solution (Python):
alpha = list(map(str, input().split()))

C = ord(alpha[0])
print(chr(C + 1))

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

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

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

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

Solution (Python):

alpha = "abcdefghijklmnopqrstuvwxyz"
c = str(input())
ind = alpha.index(c)
print(alpha[ind+1])

Solution (Python):
ch = raw_input()
if(ch.lower() != 'z' and len(ch) == 1):
  output = ord(ch) + 1
  print(chr(output).lower())
else: 
  print("Invalid")

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

Solution (Python):
C = input()
c = ord(C)
print(chr(((c-97)+1)%26 + 97))

Solution (Python):
L=['a','b','c','d','e','f','g','h','i','j','k','l','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
letter=input()
for i in range(len(L)):
    if letter==L[i]:
        print(L[i+1])
        break

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

Solution (Python):
print(chr(ord(input().rstrip())+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']
if c != 'y':
    print(list[list.index(c) + 1])
else:
    print('z')

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

Solution (Python):
C = input() 

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

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

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

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

Solution (Python):
C = input()

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

Solution (Python):
C = input()
al = "abcdefghijklmnopqrstuvwxyz"
ans = 0

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

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

Solution (Python):
import sys
bbn=1000000007
	


		
def main():
	s = input()
	alp='abcdefghijklmnopqrstuvwxyz'
	ii=alp.index(s)
	ret=alp[ii+1]
	print(ret)
	
	

isTest=False

def pa(v):
	if isTest:
		print(v)

if __name__ == "__main__":
	if sys.platform =='ios':
		sys.stdin=open('inputFile.txt')
		isTest=True
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)

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

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

Solution (Python):
s = input()

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

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

Solution (Python):
alpha = 'abcdefghijklmnopqrstuvwxyz'
if __name__=='__main__':
    print(alpha[1+alpha.index(input())])

Solution (Python):
alpha2num=0
A=input()
alpha2num=ord(A)-ord('a')+1
print(chr(alpha2num+97))

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

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

Solution (Python):
alpha2num = lambda c:ord(c) - ord('A') + 1
x = alpha2num(input())

num2alpha = lambda c:chr(c+64)
print(num2alpha(x + 1))

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','w','x','y','z']

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

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

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

Solution (Python):

s = input()

s = chr(ord(s) + 1)

print(s)

Solution (Python):
C = input()
k = ['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(k)):
  if C == k[i]:
    print(k[i+1])

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

Solution (Python):

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

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']
S = input()
j = 0
for i in range(26):
  if S == Alpha[i]:
    j = i + 1
    break
print(Alpha[j])

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"]
count1 = 0
count2 = 0
while count2 <= 26:
  if alp[count1] == c:
     count1 += 1
     count2 += 27
  else:
    count1 += 1
    count2 += 1
print(alp[count1])

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

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

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

Solution (Python):
C = input()

ref = list('abcdefghijklmnopqrstuvwxyz')

i = ref.index(C)

print(ref[i+1])

Solution (Python):
A = input()
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'

for i in range(0,len(ascii_lowercase)):
    if str(ascii_lowercase[i]) == str(A):
        print(ascii_lowercase[i+1])

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

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

Solution (Python):
C = input()
b = bytes(C, 'utf-8')
b =b[0] + 1 
print(chr(b))

Solution (Python):
def main():
    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])
    
if __name__ == '__main__':
    main()

Solution (Python):
import string
A=string.ascii_lowercase 
d=dict()
for i,a in enumerate(A):
    d[a]=i
c=input()
n=d[c]
print(A[n+1])

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

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

Solution (Python):
C=input()

fir=ord(C)
sec=int(fir)+1

print(chr(sec))

Solution (Python):
import sys

input = sys.stdin.readline

ri = lambda: int(input())
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]

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

Solution (Python):
a = input()
b = "abcdegfhijklmnopqrstuvwxyz"
i = 0
for i in range(28):
    if a == b[i]:
        break
print(b[i+1])

Solution (Python):
import math
import sys

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

Solution (Python):
acdz = 'abcdefghijklmnopqrstuvwxyz'
strnotZ = input()
x = 0

x = acdz.find(strnotZ)

print(acdz[x+1])

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

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

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

Solution (Python):
alphabet = "abcdefghijklmnopqrstuvwxyz"

c = input().strip()

for i, char in enumerate(alphabet):
    if char == c:
        print(alphabet[i + 1])

Solution (Python):
C = input()

L = list('abcdefghijklmnopqrstuvwxyz')

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

Solution (Python):
c = input()

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

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

Solution (Python):
c=input()
a="abcdefghijklmnopqrstuvwxyz"
l=[]
for i in a:
	l.append(i)

print(l[l.index(c)+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']
ans=input()

for i in list:
	if i==ans:
		print(list[list.index(i)+1])

Solution (Python):
import string
s = input()
x = string.ascii_lowercase
print(x[x.index(s) + 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']
for i, a in enumerate(alphabet):
  if C == a:
    print(alphabet[i + 1])
    exit()

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

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

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, 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)]
mod = 1000000007
inf = float('INF')


def solve():
    a = input().rstrip()
    print(chr(ord(a)+1))
    return



if __name__ == '__main__':
    solve()

Solution (Python):
X=input()


print(chr(ord(X)+1))

Solution (Python):
import sys
import string

alph = string.ascii_lowercase
i = sys.stdin.readline().strip()
i_idx = alph.index(i)
print(alph[i_idx+1])

Solution (Python):
from sys import stdin
input = stdin.readline().rstrip()
alpha = 'abcdefghijklmnopqrstuvwxyz'

flag = False
for i in alpha:
    if flag:
        print(i)
        flag =False
    if i == input:
        flag = True

Solution (Python):
C = input()

ans = chr(ord(C) + 1)

print(ans)

Solution (Python):
C = input()

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

num2alpha = lambda c: chr(c+64)

ans = num2alpha(now+1)
print(ans)

Solution (Python):

line = ["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()






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

Solution (Python):
x=[chr(i) for i in range(97, 97+26)]
i=0
c=input()
for j in range(26):
    if x[j]==c:
        i=j
        break
print(x[j+1])

Solution (Python):
t = 'abcdefghijklmnopqrstuvwxyz'
a =  input()
if int(t.find(str(a))) > 24:
    num = 0
else:
    num = t.find(str(a)) + 1
print(t[num])

Solution (Python):
C = input()

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

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

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

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

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

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

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

Solution (Python):
c = input()

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

Solution (Python):


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

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

Solution (Python):
a = input()

if(a != 'z'):
  ans = chr(ord(a)+1)
  print(ans)

Solution (Python):
s = input()
alpha2num = lambda c: ord(c) - ord('A') + 2
num2alpha = lambda c: chr(c+64)
print(num2alpha(alpha2num(s)))

Solution (Python):
alph = "abcdefghijklmnopqrstuvwxyz"

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

Solution (Python):
t = input()
A = [chr(ord('a') + i) for i in range(26)]
for i in range(26):
    if A[i] == t:
        print(A[i+1])
        break

Solution (Python):
C = input()

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

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

Solution (Python):
val = str(input())
alphabet_dic = {
    1: "a",
    2: "b",
    3: "c",
    4: "d",
    5: "e",
    6: "f",
    7: "g",
    8: "h",
    9: "i",
    10: "j",
    11: "k",
    12: "l",
    13: "m",
    14: "n",
    15: "o",
    16: "p",
    17: "q",
    18: "r",
    19: "s",
    20: "t",
    21: "u",
    22: "v",
    23: "w",
    24: "x",
    25: "y",
    26: "z"
}

key_num = 0
for k, v in alphabet_dic.items():
    if v == val:
        key_num = k
key_num = key_num + 1
print(alphabet_dic[key_num])

Solution (Python):
c = input()

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

index = 0
for i, a in enumerate(alphas):
    if c == a:
        index = i + 1
        break
        
print(alphas[index])

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

Solution (Python):
alphabet = list('abcdefghijklmnopqrstuvwxyz')
C = str(input())
count = 0

for i in range(len(alphabet)):
    if(alphabet[i] == C):
        count = count + 1
        break
    else:
        count += 1

alphabet_A = alphabet[count]
print(alphabet_A)

Solution (Python):
c = input()

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

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

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

Solution (Python):

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

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

Solution (Python):
dic = {"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9,"j":10,"k":11,"l":12,"m":13,"n":14,"o":15,"p":16,"q":17,"r":18,"s":19,"t":20,"u":21,"v":22,"w":23,"x":24,"y":25,"z":26}
dicB = {1:"a",2:"b",3:"c",4:"d",5:"e",6:"f",7:"g",8:"h",9:"i",10:"j",11:"k",12:"l",13:"m",14:"n",15:"o",16:"p",17:"q",18:"r",19:"s",20:"t",21:"u",22:"v",23:"w",24:"x",25:"y",26:"z"}
A = input()
A = int(dic[A]) + 1
print(dicB[A])

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

Solution (Python):
mojiretu="abcdefghijklmnopqrstuvwxyz"
C=input()
for i in range(25):
    if mojiretu[i]==C:
        print(mojiretu[i+1])

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6)


input = sys.stdin.readline
def INT(): return int(input())
def MAP(): return [int(s) for s in input().split()]

from string import ascii_lowercase as al

def main():
	c = input().rstrip()
	print(al[al.index(c)+1])

if __name__ == '__main__':
	main()

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

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

Solution (Python):
lt=["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(26):
  if c==lt[i]:
    break
print(lt[i+1])

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

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

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

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

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

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

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

C=str(input())

result=""

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


result=Alfa[Alfa.index(C)+1]

print(result)

Solution (Python):
C=input()
al = "abcdefghijklmnopqrstuvwxyz"
for i in range(26) :
  if C==al[i] :
    next = al[i+1]
print(next)

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

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

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

Solution (Python):
target = input().strip()
alp_data = 'abcdefghijklmnopqrstuvwxyz'
alp=list(alp_data)
num = alp.index(target)
print(alp[num + 1])

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

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

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

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

Solution (Python):
a = str(input())
import string
abc = string.ascii_lowercase 

print(abc[abc.find(a) + 1])

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

Solution (Python):
letter = input()

print(chr(ord(letter) + 1))

Solution (Python):
import string


input = input()
alphabets = string.ascii_lowercase


i = alphabets.index(input)
ans = alphabets[i + 1]
  
print(ans)