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

str = input()
ascii = ord(str)

print(chr(ascii+1))

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

Solution (Python):
chr_list = [chr(ord('a') + i) for i in range(26)]

n = str(input())

for i in range(len(chr_list)):
  if n == chr_list[i]:
    print(chr_list[i+1])

Solution (Python):
def _rot13(c):
    if 'A' <= c and c <= 'Z':
        
        return chr((ord(c) - ord('A') + 1) % 26 + ord('A'))

    if 'a' <= c and c <= 'z':
        
        return chr((ord(c) - ord('a') + 1) % 26 + ord('a'))

    
    return c


def rot13(s):
    
    g = (_rot13(c) for c in s)
    
    return ''.join(g)


a = input()
print(rot13(a))

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

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

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

Solution (Python):

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

Solution (Python):
c = input()
d = [chr(ord('a') + i) for i in range(26)]

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

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

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

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

Solution (Python):
x = str(input())
alf = "abcdefghijklmnopqrstuvwxyz"

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

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

Solution (Python):
A = list('abcdefghijklmnopqrstuvwxyz')
C = input()
for i in range(26):
  if(A[i] == C):
    print(A[i+1])

Solution (Python):
st = input()
L = "abcdefghijklmnopqrstuvwxyz"

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

Solution (Python):
c = input()
i = 'abcdefghijklmnopqrstuvwxyz'
I = {i:j for i, j in zip(i[:-1], i[1:])}
print(I[c])

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

if __name__ == '__main__':
    main()

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

Solution (Python):


c = input()

c_ascii = ord(c)

new_c_ascii = c_ascii + 1

print(chr(new_c_ascii))

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


if __name__ == "__main__":
    main()

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

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

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

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

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

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

Solution (Python):
c = input()

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

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

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

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

Solution (Python):
c=input()

s="abcdefghijklmnopqrstuvwxyz"
sl=list(s)
ind=sl.index(c)
print(sl[ind+1])

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

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

Solution (Python):
c = input()

ascii_code = ord(c)
ascii_code += 1

next_c = chr(ascii_code)

print(next_c)

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

Solution (Python):
import sys
import math
import functools
stdin = sys.stdin
mod = 10**9 + 7

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
sa = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]

c = ns()

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

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

Solution (Python):
from collections import Counter,defaultdict,deque
import sys
import bisect
import math
import itertools
import string
import queue
import copy


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(map(int, input().split())) for _ in range(n)]

def main():
    a = str(input())
    if a == 'z':
        print('a')
        return
    x = ord(a)
    x+=1
    print(chr(x))

if __name__ == "__main__":
    main()

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

Solution (Python):
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
sys.setrecursionlimit(10**9)
def gcd(a,b):return fractions.gcd(a,b) 
def lcm(a,b):return (a*b) // fractions.gcd(a,b) 
def iin(): return int(input()) 
def isn(): return input().split() 
def imn(): return map(int, input().split()) 
def iln(): return list(map(int, input().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) 
def divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i: divisors.append(n//i)
    return divisors
def is_prime(n):
    if n == 1: return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0: return False 
    return True
def primes(n):
    is_prime = [True] * (n+1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5)+1):
        if not is_prime[i]: continue
        for j in range(i * 2, n + 1, i): is_prime[j] = False
    return [i for i in range(n+1) if is_prime[i]]
def sieve_of_e(n):
    is_prime = [True] * (n+1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5)+1):
        if not is_prime[i]: continue
        for j in range(i * 2, n+1, i): is_prime[j] = False
    return is_prime
def run_length_encode(s):
    count = 1
    code = []
    target = s[0]
    for i in range(1, len(s)):
        if target == s[i]: count += 1
        else:
            code.append((target, count))
            target = s[i]
            count = 1
    code.append((target, count))
    return code

C = input()

al = string.ascii_lowercase

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

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

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

Solution (Python):
c = input()

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

Solution (Python):
        
alpha = [i.lower() for i in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ']
c = input()   

idx = alpha.index(c)   

print(alpha[idx + 1])

Solution (Python):
import sys

def input():
    return sys.stdin.readline()[:-1]

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

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

Solution (Python):
C = input()

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

Solution (Python):
import collections

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

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

Solution (Python):


iim = lambda: map(int, input().rstrip().split())
liim = lambda: list(map(int, input().rstrip().split()))

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

if __name__ == "__main__":
    resolve()

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

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

Solution (Python):
B = input()

alfa = list("abcdefghijklmnopqrstuvwxyz")

aIndex = alfa.index(B)

print(alfa[aIndex+1])

Solution (Python):
C = input()

alphabets="abcdefghijklmnopqrstuvwxyz"

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

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

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

Solution (Python):
def main():
    c = input()
    alp = [chr(i) for i in range(97, 97+26)]
    ind = alp.index(c)
    ans = alp[ind + 1]
    print(ans)

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

Solution (Python):
C = input()
alphabet = "abcdefghijklmnopqrltuvwxyz"

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

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

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

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

Solution (Python):


C = input()

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

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

Solution (Python):
s = input()

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

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

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

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

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

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

Solution (Python):

import sys


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



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

if __name__ == '__main__':
    main()

Solution (Python):
c=input()
d={'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, 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'}
print(d[d[c]+1])

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

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

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

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

Solution (Python):


s = 'abcdefghijklmnopqrstuvwxyz'

a = input()
print(s[s.find(a) + 1])

Solution (Python):

alp = [chr(i) for i in range(97, 97+26)]
c = input()
ind = alp.index(c)
print(alp[ind+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()
for i in range(26):
    if S==A[i]:
        print(A[i+1])

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

Solution (Python):
import sys
c = input()
ls = list("abcdefghijklmnopqrstuvwxyz")
print(ls[ls.index(c) + 1])

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

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

print(next)

Solution (Python):
C = input()

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

Solution (Python):
al="abcdefghijklmnopqrstuvwxyz"

C=input()
print(al[al.index(C)+1])

Solution (Python):


C = input()

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

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

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

Solution (Python):
c = input()

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

Solution (Python):
import math

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



    return 0
if __name__ == '__main__':
    main()

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

Solution (Python):
c=input()

tmp=ord(c)
tmp+=1

print(chr(tmp))

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

Solution (Python):
input = raw_input
chars = "abcdefghijklmnopqrstuvwxyz"

c = input()
i = chars.index(c)
out = chars[i+1]
print(out)

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

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

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

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

Solution (Python):
import math

s = input()


MOD = 10 ** 9 + 7

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

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

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

ind = Alpha.index(c)
ans = Alpha[ind+1]
print(ans)

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

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

Solution (Python):

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

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

Solution (Python):


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


if __name__ == '__main__':
    main()

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

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

idx = temp.index(c)
print(temp[idx+1])

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

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


def MI(): return map(int, input().split())


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


def input(): return sys.stdin.readline().rstrip()


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YN = ['No', 'Yes']
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



def main():
    C = input()
    ans = 0

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

    print(-1)


if __name__ == '__main__':
    main()

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

Solution (Python):
print({c1: c2 for c1, c2 in zip("abcdefghijklmnopqrstuvwxyz", "bcdefghijklmnopqrstuvwxyza")}[input()])

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

Solution (Python):
c = input()


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

Solution (Python):
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
c = input().strip()
w = 'abcdefghijklmnopqrstuvwxyz'
print(w[w.index(c)+1])

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

Solution (Python):
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    C = input()

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


main()

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

Solution (Python):
c = input()

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

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

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

ｔ = 'abcdefghijklmnopqrstuvwxyz'

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

Solution (Python):
C = input()

alphabet = list('abcdefghijklmnopqrstuvwxyz')

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

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

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

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

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

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

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

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

Solution (Python):
c = input()

import string

s = list(string.ascii_lowercase)

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

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

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

Solution (Python):
s = raw_input()


print chr(ord(s) + 1)

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

Solution (Python):

a = input()

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

Solution (Python):
C = input()


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

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

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

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

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

Solution (Python):
c = input()

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

Solution (Python):
import sys

alp = "abcdefghijklmnopqrstuvwxyz"

C = input()

for i in range(30):

    if alp[i] == C:
        print (alp[i+1])
        sys.exit()

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()

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

if __name__ == '__main__':
    main()

Solution (Python):
c = input()

l = list("abcdefghijklmnopqrstuvwxyz")

n = l.index(c)

print(l[n+1])

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

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

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

Solution (Python):



C = input()

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

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

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

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input(): return sys.stdin.readline().rstrip()

def main():
    a=input()
    N=1
    print(chr(ord(a)+N) if ord(a)+N<=122 else chr(ord(a)+N-26))

if __name__ == '__main__':
    main()

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

a = chr(ord(c)+1)

print(a)

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

Solution (Python):
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    ls = [chr(i) for i in range(97, 97 + 26)]
    c = str(readline().rstrip().decode('utf-8'))
    for i in range(1, len(ls)):
        if ls[i-1] == c:
            print(ls[i])
            exit()


if __name__ == '__main__':
    solve()

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

Solution (Python):


s=input()

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

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

Solution (Python):
s = input()
print(chr(ord(s)+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()
for i, a in enumerate(al):
    if a == c: print(al[i+1])

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

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

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

Solution (Python):
C=input()

ABC="abcdefghijklmnopqrstuvwxyz"

idx=ABC.index(C)

print(ABC[idx+1])

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

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
C = input()

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

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

Solution (Python):

import sys

a = input()
az = "abcdefghijklmnopqrstuvwxyz"

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

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

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

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

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False
"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

n = input()

print(chr(ord(n[0])+1))

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

Solution (Python):
arr = "abcdefghijklmnopqrstuvwxyz"
a = input()
for i,c in enumerate(arr):
    if c == a:
        print(arr[i+1])
        break

Solution (Python):
import string

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

Solution (Python):

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

Solution (Python):
import sys
def I(): return int(sys.stdin.readline())
def LI(): return [int(x) for x in sys.stdin.readline().split()]

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

if __name__ == "__main__":
    main()

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    c = S()
    print(chr(ord(c) + 1))

main()

Solution (Python):
from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

def main():
    s = input()
    ss = "abcdefghijklmnopqrstuvwxyz"
    for i in range(25):
        if s == ss[i]:
            print(ss[i+1])
            exit()

    
main()

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

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

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

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

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

Solution (Python):
x=input()
alpha="abcdefghijklmnopqrstuvwxyz"

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

Solution (Python):
c = input()

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

Solution (Python):
a=list("abcdefghijklmnopqrstuvwxyz")
s=input()
n=a.index(s)
if n==25:
    print("a")
else:
    print(a[n+1])

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

Solution (Python):
import sys

sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def solve(inputs):
    c = str(inputs[0])
    c_i = ord(c)
    c_i += 1
    return chr(c_i)


def string_to_int(string):
    return list(map(lambda x: int(x), string.split()))


if __name__ == "__main__":
    ret = solve(inputs(1))
    print(ret)

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

print(chr(ans))

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

c = input()

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

Solution (Python):




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

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

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

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

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

Solution (Python):
s = input()

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

Solution (Python):
C = input()

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

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

print(ans)

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

a = input()
idx = alpha.index(a)

print(alpha[idx+1])

Solution (Python):
import sys
input=sys.stdin.readline
c=input().rstrip()
x=ord(c)
ans=chr(x+1)
print(ans)

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

def solve():
    return chr(ord(input())+1)

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

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

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

ii = lambda: int(input())
mis = lambda: map(int,input().split())
lmis = lambda: list(mis())
INF = float('inf')

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


if __name__ == "__main__":
    main()

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

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

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


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


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
import sys







def main():
    c = input()
    alphabets = "abcdefghijklmnopqrstuvwxyz"

    idx = alphabets.index(c)
    print(alphabets[idx + 1])


if __name__ == '__main__':
    main()

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

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

    c = input().rstrip('\n')
    print(chr(ord(c) + 1))


if __name__ == '__main__':
    main()

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

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

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

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

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

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()
alphs = "abcdefghijklmnopqrstuvwxyz"
print(alphs[alphs.find(C)+1])

Solution (Python):

C = input()

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

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

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

Solution (Python):
Z = list("abcdefghijklmnopqrstuvwxyz")

C = input()

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

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

Solution (Python):
c = input()

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

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

if __name__ == '__main__':
    solve()

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

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

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

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

Solution (Python):
C = input()

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

Solution (Python):

import sys
sys.setrecursionlimit(10**5)
input = sys.stdin.readline

c = input().rstrip()
oc = ord(c)
oc += 1
print(chr(oc))

Solution (Python):
import math
import itertools
import fractions
import heapq
import collections
import bisect
import sys

sys.setrecursionlimit(10**9)
mod = 998244353
inf = 10**20

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()

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

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

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

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

Solution (Python):
c=input()

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

Solution (Python):
C = input()

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

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

print(chr(ord(A) + 1))

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

Solution (Python):
s = input()

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

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

Solution (Python):
def main():
    from string import ascii_lowercase

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


if __name__ == '__main__':
    main()

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

Solution (Python):
c=input()

ans=chr(ord(c)+1)

print(ans)

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

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