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

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

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

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

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

Solution (Python):
character = input()
ord_character = ord(character)
res = chr(ord_character + 1)
print(res)

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

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

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

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

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

Solution (Python):
s = input()

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

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

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

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

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

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

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

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

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


main()

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

Solution (Python):


c = input()

str = "abcdefghijklmnopqrstuvwxyz"

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

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

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

Solution (Python):
c = input()

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

Solution (Python):
alphabet = 'abcdefghijklnmopqrstuvwxyz'

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

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

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

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

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

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

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

Solution (Python):


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

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

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

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

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

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

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

Solution (Python):

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

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

print(chr(b))

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,pprint,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
mod2 = 998244353
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))

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

Solution (Python):
a = input()
abc = 'abcdefghijklmnopqrstuvwxyz'

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

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

Solution (Python):
N = input()

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

Solution (Python):
C = input()
alphabet = {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"}
keys = [k for k, v in alphabet.items() if v == C][0]
print(alphabet[int(keys) + 1])

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

Solution (Python):
s=input()
ns=int(ord(s) - ord('A') + 2)
res = chr(ns+64)
print(res)

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

C=str(input())
n=a.index(C)
print(a[n+1])

Solution (Python):
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):
S=input()

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

Solution (Python):


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

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

Solution (Python):


c = input().rstrip()
code = ord(c) + 1
ans = chr(code)

print(ans)

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

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

Solution (Python):
C = input()

ans = ''
for i in range(26):
  if chr(ord('a') + i) == C:
    ans = chr(ord('a') + i + 1)
    
print(ans)

Solution (Python):


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

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

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

Solution (Python):

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

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

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

Solution (Python):
a='abcdefghijklmnopqrstuvwxyz'
s=input()
cnt=0
while s!=a[cnt]:
	cnt+=1
print(a[cnt+1])

Solution (Python):

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

Solution (Python):
s = input().split()

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

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

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

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

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

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

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

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

Solution (Python):
chars = [chr(i) for i in range(ord('a'), ord('z')+1)]
C = input()
ind = chars.index(C)
print(chars[ind+1])

Solution (Python):

C = str(input())


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

Solution (Python):

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

Solution (Python):
c = input()

abc = list('abcdefghijklmnopqrstuvwxyz')
idx = abc.index(c)

print(abc[idx+1])

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7 
input=lambda:sys.stdin.readline().rstrip()
def resolve():
    c=input()
    print(chr(ord(c)+1))
resolve()

Solution (Python):
import sys

c = sys.stdin.readline().rstrip()

def main():
    return chr(ord(c) + 1)

if __name__ == '__main__':
    ans = main()
    print(ans)

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

Solution (Python):
import sys

c = sys.stdin.readline().rstrip()

def main():
    return chr(ord(c) + 1)

if __name__ == '__main__':
    ans = main()
    print(ans)

Solution (Python):
c = str(input())
a = list("abcdefghijklmnopqrstuvwxyz")

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

Solution (Python):
"""
author : dokueki
"""
s = input()
t = "abcdefghijklmnopqrstuvwxyz"
for i in range(len(t)):
    if t[i] == s:
        print(t[i+1])
        break

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

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

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

Solution (Python):
from sys import stdin
import sys
import numpy as np
import collections
from functools import cmp_to_key
import heapq


def rsa(sep = ''):
    if sep == '' :
        return input().split() 
    else: return input().split(sep)
def rip(sep = ''):
    if sep == '' :
        return map(int, input().split()) 
    else: return map(int, input().split(sep))
def ria(sep = ''): 
    return list(rip(sep))
def ri(): return int(input())
def rd(): return float(input())
def rs(): return input()

def main():
    s = rs()
    print(chr(ord(s[0])+1))


if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())
def FLIST(n):
    res = [1]
    for i in range(1, n+1): res.append(res[i-1]*i%DVSR)
    return res
def gcd(x, y):
    if x < y: x, y = y, x
    div = x % y
    while div != 0:
        x, y = y, div
        div = x % y
    return y

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import unittest
import string


class TestA(unittest.TestCase):
    def test_1(self):
        self.assertEqual(think('a'), 'b')

    def test_2(self):
        self.assertEqual(think('y'), 'z')


def solve():
    c = read()
    result = think(c)
    write(result)


def read():
    return read_line(n=1)


def read_int(n):
    return read_type(int, n, sep=' ')


def read_float(n):
    return read_type(float, n, sep=' ')


def read_type(t, n, sep):
    return list(map(lambda x: t(x), read_line().split(sep)))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(c):
    buf = string.ascii_lowercase
    index = buf.index(c)
    return buf[index + 1]


def write(result):
    print(result)


if __name__ == '__main__':
    
    solve()

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

print(chr(ord(read().decode('utf-8').rstrip()) + 1))

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

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

print(ans)

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

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

Solution (Python):
C=input()

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

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

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

Solution (Python):
C = input()

alfa = {'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(alfa[C])

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

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

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

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

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

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
C = input().rstrip()
al = [chr(i) for i in range(97, 97+26)]
alpha2num = lambda c: ord(c) - ord("a")
print(al[alpha2num(C) + 1])

Solution (Python):
l=input()
lis=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
for i in range(len(lis)-1):
    if l==lis[i]:
        print(lis[i+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):
print(chr(ord(input())+1))

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

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

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

Solution (Python):
ip = input()
t = ord(ip)
if t == 90:
  	t = 65
if t == 122:
  	t = 97
print(chr(t+1))

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

INPUT = input()

if INPUT != 'z':
    index = alphabet.index(INPUT)
    print(alphabet[index + 1])

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

Solution (Python):
import sys
import math
import itertools
C=input()
print(chr(ord(C)+1))

Solution (Python):


"""
Created on Sun Jan 12 22:19:09 2020

@author: nanasakiwataru
"""

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

Solution (Python):
c=str(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):
print(chr(ord(input())+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):
s  = input()
L = [chr(ord('a') + i) for i in range(26)]

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

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

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

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

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

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

Solution (Python):
str = input()
alp = "abcdefghijklmnopqrstuvwxyz"
print(alp[ord(str)-96])

Solution (Python):
def solve(c):
    alpha = "abcdefghijklmnopqrstuvwxyz"
    i = alpha.index(c)
    return alpha[i + 1]


def main():
    c = input()
    res = solve(c)
    print(res)


def test():
    assert solve("a") == "b"
    assert solve("y") == "z"


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

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

Solution (Python):
C=input()

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

id=alp.index(C)
print(alp[(id+1)%26])

Solution (Python):
a = 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)):
    
    alphabet = alpha[i]
    if a == alphabet:
        s = i + 1    
        alphabet = alpha[s]
        print(alphabet)
        break

Solution (Python):
def main():
    C = input()
    ans = ord(C) + 1
    print('{}'.format(chr(ans)))

if __name__ == '__main__':
    main()

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

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from copy import deepcopy
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce


sys.setrecursionlimit(2147483647)
INF = float('INF')
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7


print(chr(ord(S()) + 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"]
c=b.index(a)
d=c+1
print(b[d])

Solution (Python):
alpha2num=lambda c:ord(c)-ord('a')+1

result=(alpha2num(input()))

if result==1:
    print('b')
elif result==2:
    print('c')
elif result==3:
    print('d')
elif result==4:
    print('e')
elif result==5:
    print('f')
elif result==6:
    print('g')
elif result==7:
    print('h')
elif result==8:
    print('i')
elif result==9:
    print('j')
elif result==10:
    print('k')
elif result==11:
    print('l')
elif result==12:
    print('m')
elif result==13:
    print('n')
elif result==14:
    print('o')
elif result==15:
    print('p')
elif result==16:
    print('q')
elif result==17:
    print('r')
elif result==18:
    print('s')
elif result==19:
    print('t')
elif result==20:
    print('u')
elif result==21:
    print('v')
elif result==22:
    print('w')
elif result==23:
    print('x')
elif result==24:
    print('y')
elif result==25:
    print('z')

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


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_matrix(H):
    '''
    H is number of rows
    '''
    return [list(map(int, read().split())) for _ in range(H)]


def read_map(H):
    '''
    H is number of rows
    文字列で与えられた盤面を読み取る用
    '''
    return [read()[:-1] for _ in range(H)]


def read_col(H, n_cols):
    '''
    H is number of rows
    n_cols is number of cols

    A列、B列が与えられるようなとき
    '''
    ret = [[] for _ in range(n_cols)]
    for _ in range(H):
        tmp = list(map(int, read().split()))
        for col in range(n_cols):
            ret[col].append(tmp[col])

    return ret




def ord_from_a(char):
    return ord(char) - ord('a')


def chr_from_a(n: int):
    
    return chr(n + ord('a'))


print(chr_from_a(ord_from_a(input()) + 1))

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

Solution (Python):
C=input()

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

for i in range(0,26):
    if C==D[i]:
        print(D[i+1])

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

    alphabet = 'abcdefghijklmnopqrstuvwxyz'
    index = alphabet.find(z)
    print(alphabet[index+1])

if __name__ == '__main__':
    main()

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

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

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

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

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

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

Solution (Python):
C = input()

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

index = alp.index(C)
if C == "z":
    print(alp[0])
else:
    print(alp[index+1])

Solution (Python):
alphabet_chars = 'abcdefghijklmnopqrstuvwxyz'

input_char = input()
index = alphabet_chars.find(input_char)
print(alphabet_chars[index + 1])

Solution (Python):
import sys

args = sys.argv

a = "abcdefghijklmnopqrstuvwxyz"

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

Solution (Python):
s = input()

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

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

for c,i in enumerate(a):
  if i == 'z':
    print('a')
    break
  elif i == b:
    d = 1 + c
    print(a[d])
    break
  else:
    pass

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

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

Solution (Python):
alpha = input()



ald = {'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'}


if alpha in ald:
    print(ald[alpha])

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

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

Solution (Python):

import sys
sys.setrecursionlimit(10000000)
INF = 1<<32


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):
input_ = raw_input()
print(chr(ord(str(input_)) + 1))

Solution (Python):
import string
chrs=string.ascii_lowercase
nx={c:d for c,d in zip(chrs,chrs[1:])}
print(nx[input()])

Solution (Python):


a = str(input())

 

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

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

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

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

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

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

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

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

Solution (Python):
C = input()

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

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

Solution (Python):
A = "abcdefghijklmnopqrstuvwxyz"
z = input()
isZ = False
ans = ""
for i in A:
    if (not isZ) and i == z:
        isZ = True
    elif isZ:
        ans = i
        break
print(ans)

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

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

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

Solution (Python):
c = input()

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

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

Solution (Python):
n = str(input())
a = "abcdefghijklmnopqrstuvwxyz"
i = a.find(n)
print(a[i+1:i+2])

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

Solution (Python):
inputstr = input()
alphabet = "abcdefghijklmnopqrstuvwxyz"
for index, target in enumerate(alphabet):
  if inputstr == target:
    ans = alphabet[index + 1]
    break
print(ans)

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

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

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

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

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

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

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

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

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

Solution (Python):
alph = 'abcdefghijklmnopqrstuvwxyz'

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

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

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

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

Solution (Python):
import string

ch = input()

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

n = lst.index(ch)

print(lst[n+1])

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

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

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

Solution (Python):
txt = input().split()

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 txt[0] == alpha[i]:
    print(alpha[i+1])
    exit

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):
from string import ascii_letters
C = input()
alphabet = ascii_letters
print(alphabet[alphabet.find(C)+1])

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

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

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

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

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

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

Solution (Python):
C=input()
tmp=[]
for i in C:
  tmp.append(chr(ord(i) + 1))
print("".join(tmp))

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

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

Solution (Python):





import numpy as np

s = input()

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

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

Solution (Python):
s = 'abcdefghijklmnopqrstuvwxyz'
C = input(str())

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

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

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

Solution (Python):

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

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

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

if __name__ == '__main__':
    main()

Solution (Python):
s = "abcdefghijklmnopqrstuvwxyz"

C = str(input())

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
N = input()
A =[chr(i) for i in range(97, 97+26)]
for k in range(len(A)):
    if N==A[k]:
        print(A[k+1])

Solution (Python):
import sys


c = input()
l = [chr(ord('a') + i) for i in range(26)]
for i in range(len(l)):
    if l[i] == c:
        print(l[i + 1])
        sys.exit()

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

Solution (Python):


alphabet = 'abcdefghifklmnopqrstuvwxyz'
a = input()
b = alphabet.find(a)
print(alphabet[b+1])

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

Solution (Python):
import string
C=input()
a=string.ascii_lowercase
B=[]
for i in range(26):
    b=a[i]
    B.append(b)
c=B.index(C)
print(B[c+1])

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

Solution (Python):
x = input()

x = chr(ord(x)+1)

print(x)