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

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

print(chr(int(ord(n)) + 1))

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

Solution (Python):
C = input()

list_abc = 'abcdefghijklmnopqrstuvwxyz'

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

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

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

Solution (Python):
C = input()

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

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

Solution (Python):
a = input()

alpha = "abcdefghijklmnopqrstuvwxyz"

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

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

Solution (Python):
c = input()

num2alpha = lambda x: chr(x+64)
alpha2num = lambda y: ord(y) - ord('A') + 1

print(num2alpha(alpha2num(c) + 1))

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

Solution (Python):
C = input()

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

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

Solution (Python):
C = input()

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

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

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

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

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


main()

Solution (Python):
def main():
	n = str(input())

	l = "abcdefghijklmnopqrstuvwxyz"
	l_l = list(l)

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





 
if __name__ == '__main__':
	main()

Solution (Python):
C = input()

alphabet = 'abcdefghijklmnopqrstuvwxyz'

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

Solution (Python):
from collections import defaultdict
def main():
    dic = defaultdict(int)
    ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
    for i,s in enumerate(ascii_lowercase):
        dic[s] = i
    inp = input()
    idx = dic[inp] + 1
    print(ascii_lowercase[idx])
if __name__ == '__main__':
    main()

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

Solution (Python):
C = input()

CC = chr(ord(C) + 1)

print(CC)

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

Solution (Python):
import sys
from string import ascii_lowercase

INPUT = lambda: sys.stdin.readline().rstrip()

sys.setrecursionlimit(10 ** 9)


def main():
    C = INPUT()

    flag = False
    for s in ascii_lowercase:
        if flag:
            print(s)
            sys.exit()
        if s == C: flag = True


if __name__ == '__main__':
    main()

Solution (Python):
C = input()

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

Solution (Python):
import collections
import itertools as it
import math
import numpy as np








C = input()

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

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

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

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

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

print(list[idx+1])

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

Solution (Python):
import string

arr = [chr(i) for i in range(97, 97+26)]
print(arr[arr.index(input())+1])

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

a = ord(s)

a += 1

ans = chr(a)

print(ans)

Solution (Python):
s=input()

L=[chr(i) for i in range(97, 97+26)]
idx=L.index(s)

print(L[idx+1])

Solution (Python):
C = input()
alph = list("abcdefghijklmnopqrstuvwxyz")
n = alph.index(C)
nn = (n + 1)%26
print(alph[nn])

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

print(a_list[a_index+1])

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

Solution (Python):
import string
alp=string.ascii_lowercase

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

Solution (Python):
C=input()

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

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

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

for i in range(27):
    if S == al[i]:
        print(al[i+1])
        exit()

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

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

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

Solution (Python):
s=input()

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

Solution (Python):
c = input()

alp = "abcdefghijklmnopqrstuvwxyz"
idx = alp.find(c)
print(alp[idx + 1])

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

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

Solution (Python):
C = input()

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


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

Solution (Python):
import sys,queue,copy
sys.setrecursionlimit(10**8)
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
INF = float('inf')

a = input()

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

Solution (Python):
s = input()

l = "abcdefghijklmnopqrstuvwxyz"

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

Solution (Python):
C = input()
ls = list("abcdefghijklmnopqrstuvwxyz")
num = list(range(0,26))
dic = dict(zip(ls,num))
print(ls[dic[C]+1])

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

Solution (Python):

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

Solution (Python):
C = input()

C_a = ord(C)

print(chr(C_a+1))

Solution (Python):
S = input()

S_num = int(ord(S)) + 1
print(chr(S_num))

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

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

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

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

Solution (Python):
import math
import queue
import bisect
import heapq
import time
import itertools

mod = int(1e9+7)

def swap(a,b):
    return (b,a)

def my_round(a,dig=0):
    p = 10 ** dig
    return (a * p * 2 + 1) // 2 / p

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

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

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

def is_prime(a): 
    if a<2:
        return False
    elif a==2:
        return True
    elif a%2==0:
        return False
    sqrt_num = int(a**0.5)
    for i in range(3,sqrt_num+1,2):
        if a%i==0:
            return False
    return True

def prime_num(a): 
    pn = [2]
    for i in range(3,int(a**0.5),2):
        prime = True
        for j in pn:
            if i%j==0:
                prime = False
                break
        if prime:
            pn.append(i)
    return pn

def prime_fact(a): 
    sqrt = math.sqrt(a)
    res = []
    i = 2
    if is_prime(a):
        res.append(a)
    else:
        while a!=1:
            while a%i==0:
                res.append(i)
                a //= i
            i += 1
    return res

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

if __name__=='__main__':
    main()

Solution (Python):
S = input()

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

Solution (Python):
str = input()

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

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

Solution (Python):
c=input()

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

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

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

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

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


if __name__=='__main__':
    main()

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

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

Solution (Python):
from sys import stdin 
a = ord(stdin.readline().rstrip()) + 1
print(chr(a))

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return list(map(int, sys.stdin.readline().split()))
def II(): return int(sys.stdin.readline())
def LS(): return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]

def main():
    ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
    s = S()[0]
    for i, t in enumerate(ascii_lowercase):
        
        if t == s:

            print(ascii_lowercase[i+1])


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
C = input()

all_list = 'abcdefghijklmnopqrstuvwxyz'

for i, content in enumerate(all_list):
    if content == C:
        print(all_list[i+1])
        exit()

Solution (Python):
a=ord(str(input())[0])

print(chr(a+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):
X = input()
lst = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
print(lst[lst.index(X)+1])

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

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

Solution (Python):
str = 'abcdefghijklmnopqrstuvwxyz'

s = input()

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

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

Solution (Python):
c = input()

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

Solution (Python):
C = input()

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

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

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

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

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

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

Solution (Python):
alphabet = 'abcdefghijklmnopqrstuvwxyz'

c = input().strip()

for i in range(len(alphabet)):
    c2 = alphabet[i]
    if c == c2:
        break

print(alphabet[i + 1])

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

Solution (Python):
n = input()

al = "abcdefghijklmnopqrstuvwxyz"



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

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

Solution (Python):
s = input()
alp = list("abcdefghijklmnopqrstuvwxyz")
for i in range(0, len(alp)):
    if s == alp[i]:
        print(alp[i+1])

Solution (Python):
C = input()
char = "abcdefghijklmnopqrstuvwxyz"
L = []

for i in range(len(char)):
    L.append(char[i])

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

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

Solution (Python):
C = input()

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

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

Solution (Python):


import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
read = sys.stdin.read




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

Solution (Python):
alphabets = "abcdefghijklmnopqrstuvwxyz"

C = input()

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

Solution (Python):
from sys import stdin

if __name__ == '__main__':
    c = stdin.readline().rstrip()
    charList = 'abcdefghijklmnopqrstuvwxyz'
    for i in range(len(charList) - 1):
        if charList[i] == c:
            print(charList[i+1])

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

alp = "abcdefghijklmnopqrstuvwxyz"

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

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

n = input()

ansnum = ABC_list.index(n)

ans = ABC_list[ansnum + 1]

print(ans)

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

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

Solution (Python):
c = input()

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

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

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

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

alphanum = lambda c: ord(c) - ord("A") + 1
numalpha = lambda c: chr(c + 64)
x = alphanum(C) + 1
ans = numalpha(x)

print(ans)

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

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

Solution (Python):
import sys
s = sys.stdin.readline().rstrip()
a='abcdefghijklmnopqrstuvwxyz'

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

Solution (Python):
c = input()
al_list = [chr(ord('a') + i) for i in range(26)]
for n, al in enumerate(al_list):
    if al == c:
        idx = n
        break

print(al_list[n+1])

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

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

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

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

Solution (Python):
from string import ascii_lowercase as lower


def main():
    C = input()
    for i in range(28):
        if C == lower[i]:
            print(lower[i+1])
            break


if __name__ == '__main__':
    main()

Solution (Python):




def solve(S):
    alp = [chr(i) for i in range(97, 97+26)]
    index = alp.index(S) + 1
    if index == len(alp):
        index = 0
    return alp[index]



S = input()



print(solve(S))

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

Solution (Python):
c = input()

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

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

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

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

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

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

Solution (Python):
N = input()

print(chr(ord(N)+1))

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

Solution (Python):


C = str(input())
ord_C = ord(C)

print(chr(ord_C + 1))

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

Solution (Python):
from bisect import bisect_right, bisect_left
from itertools import groupby, permutations, combinations
from fractions import gcd
import numpy as np
from sys import stdin, stderr


def lcm(x, y):
    return (x * y) // gcd(x, y)


def main():
    str = "abcdefghijklmnopqrstuvwxyz"
    c = input()
    for i in range(len(str)):
        if str[i] == c:
            ret = str[i + 1]
    return ret


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

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

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

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

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

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

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

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

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

Solution (Python):
c = input()

alphabet = 'abcdefghijklmnopqrstuvwxyz'

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

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

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

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys
import bisect

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

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

C = str(input())
alpha = "abcdefghijklmnopqrstuvwxyz"
print(alpha[alpha.find(C) + 1])

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

a=chr(ord(c) + 1)

print(a)

Solution (Python):
def joint(i):
    cnt = 0
    for node in line_dict[i]:
        if cnt_list[node] == -1:
            cnt += joint(node)



if __name__ == '__main__':
    import sys
    input = sys.stdin.readline

    c = input()[0]
    import string
    for i, a in enumerate(string.ascii_lowercase):
        if a == c:
            print(string.ascii_lowercase[i+1])

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

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

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

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

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

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

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

Solution (Python):


def main():
    alphabets = 'abcdecghijklmnopqrstuvwxyz'
    char = input()
    next_index = alphabets.find(char) + 1
    print(alphabets[next_index])

if __name__ == "__main__":
    main()

Solution (Python):



test = ""

"""

"""

test = list(reversed(test.strip().splitlines()))
if test:
    def input2():
        return test.pop()
else:
    def input2():
        return input()


x = input2()
lowers = [chr(i) for i in range(ord("a"), ord("z")+1)]
xi = lowers.index(x)
print(lowers[xi+1])

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

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

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

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

Solution (Python):

import re
import math




c=input()

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

Solution (Python):
before = input()

print(chr(ord(before) + 1))

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

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

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

Solution (Python):
C = input()
english = "abcdefghijklmnopqrstuvwxyz"
for i ,j in enumerate(english):
    if j == C:
        print(english[i+1])

Solution (Python):

MOD = 10 ** 9 + 7

import math

import itertools



import copy


def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default



def main():
    a = input()
    b="abcdefghijklmnopqrstuvwxyz"
    b=list(b)
    print(b[b.index(a)+1])



if __name__ == "__main__":
    main()

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do(): 
    moji=list('abcdefghijklmnopqrstuvwxyz')
    c=STR()
    ct=moji.index(c)
    print(moji[ct+1])
if __name__ == '__main__':
    do()

Solution (Python):
import sys
from string import ascii_lowercase

input = sys.stdin.readline


class Solution:
    def main(self):
        C = input().rstrip()

        for i, _char in enumerate(ascii_lowercase):
            if _char == C:
                print(ascii_lowercase[i + 1])
                exit()



if __name__ == '__main__':
    Solution().main()

Solution (Python):
C = input()

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

Solution (Python):
letter = input()
print(chr(ord(letter) + 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']
for i in range(len(alpha)) :
    if C == alpha[i] :
        print(alpha[i+1])
        break

Solution (Python):

 
import math
import itertools
import sys
import copy
 





C = str(input())

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

Solution (Python):



c = input()

string = "abcdefghijklmnopqrstuvwxyz"

i = string.find(c)

print(string[i+1])

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

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

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


if __name__ == "__main__":
    resolve()

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']
num=alpha.index(c)
print(alpha[num+1])

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

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

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

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

Solution (Python):
import sys
from math import factorial
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
MOD = 10**9 + 7

chars = 'abcdefghijklmnopqrstuvwxyz'
s = input()
i = 0
while True:
    if s == chars[i]:
        break
    i+=1
print(chars[i+1])

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

Solution (Python):
C = 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',
]
i = alf.index(C)

print(alf[i + 1])

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

Solution (Python):
c = input()

k = set('abcdefghijklmnopqrstuvwxyz')

l = list(k)

l.sort()

p = l.index(c)

print(l[p+1])

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

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

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
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 LLI(rows_number): return [LI() for _ in range(rows_number)]

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

Solution (Python):
n = input()
l ='abcdefghijklmnopqrstuvwxyz'

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

Solution (Python):
c = input()

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

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

if __name__ == '__main__':
    main()

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

Solution (Python):

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

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

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

Solution (Python):
p = input()
dic = {}
s = "abcdefghijklmnopqrstuvwxyz"
for i in range(len(s)-1):
    dic[s[i]] = s[i+1]
    
print(dic[p])

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

Solution (Python):
alphabet = {chr(i):chr(i+1) for i in range(97, 123)}
a = input()
print(alphabet[a])

Solution (Python):
input_line = input()

print(chr(ord(input_line)+1))

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

Solution (Python):
s = str(input())
abc = [chr(i) for i in range(97, 97+26)]
for i in range(len(abc)):
    if s == abc[i]:
        print(abc[i+1])
        exit()

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

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

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

Solution (Python):
C = input()

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

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

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

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

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

Solution (Python):
from string import ascii_letters
s = input()
print(ascii_letters[ascii_letters.index(s) + 1])

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

Solution (Python):
from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt
from fractions import gcd

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

def intinput():
    return int(input())

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

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas




S = input()



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

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

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

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

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

Solution (Python):
C = input()

C_ord = ord(C)

ans_ord = C_ord + 1
ans = chr(ans_ord)
print(ans)

Solution (Python):
C = input()

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

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

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

Solution (Python):
C = input()

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

Solution (Python):
import sys

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

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

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

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

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

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

Solution (Python):
import sys


def main():
    n = str(input()).replace(" ", "")
    print(chr(ord(n[0]) + 1))


if __name__ == '__main__':
    input = sys.stdin.readline
    main()

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