Problem:
 Score : 200 points    Problem Statement You are given a string S consisting of lowercase English letters.
Find the lexicographically (alphabetically) smallest lowercase English letter that does not occur in S .
If every lowercase English letter occurs in S , print None instead.      Constraints  1 \leq |S| \leq 10^5 ( |S| is the length of string S .)  S consists of lowercase English letters.         Input Input is given from Standard Input in the following format:  S       Output Print the lexicographically smallest lowercase English letter that does not occur in S .
If every lowercase English letter occurs in S , print None instead.        Sample Input 1 atcoderregularcontest      Sample Output 1 b  The string atcoderregularcontest contains a , but does not contain b .       Sample Input 2 abcdefghijklmnopqrstuvwxyz      Sample Output 2 None  This string contains every lowercase English letter.       Sample Input 3 fajsonlslfepbjtsaayxbymeskptcumtwrmkkinjxnnucagfrg      Sample Output 3 d

Solution (Python):
import sys

def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))

def DD2(d1,d2,init=0): return [[init]*d2 for _ in range(d1)]
def DD3(d1,d2,d3,init=0): return [DD2(d2,d3,init) for _ in range(d1)]

def to_bin(x: int) -> str: return format(x, 'b') 
def to_oct(x: int) -> str: return format(x, 'o') 
def to_hex(x: int) -> str: return format(x, 'x') 
MOD=10**9+7
def divc(x,y) -> int: return -(-x//y)
def divf(x,y) -> int: return x//y
def gcd(x,y):
    while y: x,y = y,x%y
    return x
def lcm(x,y): return x*y//gcd(x,y)
def enumerate_divs(n):
    """Return a tuple list of divisor of n"""
    return [(i,n//i) for i in range(1,int(n**0.5)+1) if n%i==0]
def get_primes(MAX_NUM=10**3):
    """Return a list of prime numbers n or less"""
    is_prime = [True]*(MAX_NUM+1)
    is_prime[0] = is_prime[1] = False
    for i in range(2, int(MAX_NUM**0.5)+1):
        if not is_prime[i]: continue
        for j in range(i*2, MAX_NUM+1, i):
            is_prime[j] = False
    return [i for i in range(MAX_NUM+1) if is_prime[i]]

from itertools import accumulate as acc
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left


def main():
    s = set(IS())
    t = 'abcdefghijklmnopqrstuvwxyz'
    for ti in t:
        if not ti in s:
            print(ti)
            return None
    print('None')

if __name__ == '__main__':
    main()

Solution (Python):
s = set(input())
li = [chr(i) for i in range(97, 97+26)]
cnt = 0
for i in li:
    if i not in s:
        print(i)
        break
    else:
        cnt+=1
if cnt == 26:
    print("None")

Solution (Python):
s = set(list(input()))
if len(s)==26:
  print('None')
  exit()

for i in range(26):
  c = chr(ord('a')+i)
  if c not in s:
    print(c)
    break

Solution (Python):
s = [i for i in input()]
abc = [chr(i) for i in range(97,97+26)]
for p in s:
  try:
    abc.remove(p)
  except:
    pass
try:
  print(abc[0])
except:
  print("None")

Solution (Python):
S = list(input())
S_uniq = list(set(S))

a_z_list = list('abcdefghijklmnopqrstuvwxyz')
not_holding_sorted = sorted(list(set(a_z_list) - set(S)))

if len(not_holding_sorted) == 0:
    ans = 'None'
else:
    ans = not_holding_sorted[0]
    
print(ans)

Solution (Python):


s=list(input())
s.sort()
for i in range(97,123):
    if s.count(chr(i))==0:
        print(chr(i))
        break
else:
    print("None")

Solution (Python):
S=input()
line="abcdefghijklmnopqrstuvwxyz"
ans="None"
for i in line:
    if i not in S:
        ans=i
        break
print(ans)

Solution (Python):
s = input()
sw = [0]*26
for t in s:
    sw[ord(t)-97] = 1
for i in range(26):
    if sw[i] == 0:
        print(chr(97+i))
        break
    if i == 25:
        print(None)

Solution (Python):
import numpy as np
import sys

input = sys.stdin.readline

S = list(input())

alp = list("abcdefghijklmnopqrstuvwxyz")

for a in alp:
    if a not in S:
        print(a)
        exit()

print("None")

Solution (Python):
import numpy as np
import sys

input = sys.stdin.readline

S = input()

S = sorted(list(set(S[:-1])))


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


j = 0
for i in range(len(alpha)):
    if  S[j]== alpha[i] :
        if len(S)-1 != j:j+=1
    else:
        print(alpha[i])
        exit()


print("None")

Solution (Python):
s=list(input())
alp=list("abcdefghijklmnopqrstuvwxyz")
ans="None"
for w in alp:
    if w not in s:
        ans=w
        break
    else:
      pass
print(ans)

Solution (Python):
import collections
s = list(input())
c = collections.Counter(s)
p = list(c.items())
p.sort()
i=0
for k,v in p:
    if k == chr(ord("a")+i):
        i += 1
    else:
        print(chr(ord("a")+i))
        exit()
if i == 26:
    print("None")
else:
    print(chr(ord("a")+i))

Solution (Python):
s=list(input())
alp=list("abcdefghijklmnopqrstuvwxyz")
ans="None"
for w in alp:
    if w not in s:
        ans=w
        break
print(ans)

Solution (Python):
s = set(input())
a = 'abcdefghijklmnopqrstuvwxyz'
for i in range(26):
  if a[i] not in s:
    print(a[i])
    break
else:
  print('None')

Solution (Python):
w = str(input())
w =sorted(w)
import string
alp = str(string.ascii_lowercase)
c = []
for i in range(len(alp)): 
  c.append(0)
for i in range(len(alp)):
  W = alp[i]
  for j in range(len(w)):
    if W == w[j]:
      c[i] += 1
if c.count(0) == 0:
  print('None')
else:
  for i in range(len(c)):
    if c[i] == 0:
      print(alp[i])
      break

Solution (Python):
import numpy as np
S=input()
a_list = "abcdefghijklmnopqrstuvwxyz"
c_list = np.zeros(26)

for i in range(len(S)):
  c_list[a_list.index(S[i])] = c_list[a_list.index(S[i])] + 1

if not 0 in c_list: print('None')
else:
  c_list = c_list.tolist()
  print(a_list[c_list.index(0)])

Solution (Python):
s="qwertyuiopasdfghjklzxcvbnm"
l = sorted(list(s))
t = list(set(input()))
for i in l:
    if not i in t:
        print(i)
        break
else:
    print("None")

Solution (Python):
S = input()
S = set([s for s in S])
l_list = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
ans = 'None'
for l in l_list:
  if l in S:
    continue
  else:
    ans = l
    break
print(ans)

Solution (Python):
import sys
s = input()
alphabet = 'abcdefghijklmnopqrstuvwxyz'
for a in alphabet:
    if a not in s:
        print(a)
        sys.exit()
print('None')

Solution (Python):
s = input()
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ans = 'None'
for c in ascii_lowercase:
    if c not in s:
        ans = c
        break
print(ans)

Solution (Python):
S = set(input())
allWord = set('abcdefghijklmnopqrstuvwxyz')

if len(S) == 26:
    print("None")
else:
    print(sorted(allWord - S)[0])

Solution (Python):
S = input()
wordNum = [0 for i in range(26)]
for wordOne in S:
    idx = ord(wordOne) - ord('a')
    wordNum[idx] += 1

ans = "None"
for i in range(26):
    if wordNum[i] == 0:
        ans = chr(ord('a') + i)
        break;

print(ans)

Solution (Python):


s = input()
population = {chr(i) for i in range(ord('a'), ord('z')+1)}
ans = sorted(population - set(s))
if len(ans) == 0:
    print('None')
else:
    print(ans[0])

Solution (Python):
s = str(input())
l = [chr(ord('a') + i) for i in range(26)]
for i in l:
    if i not in s:
        print(i)
        break
else:
     print("None")

Solution (Python):
s=input()
l=[chr(ord('a') + i) for i in range(26)]
for i in l:
    if i not in s:
        print(i)
        break
else:
    print("None")

Solution (Python):
a = sorted(set('abcdefghijklmnopqrstuvwxyz')-set(input()))
print(a[0] if a else "None")

Solution (Python):
s=input()
S=list(set(s))
A=[]
cnt=124
for i in range(97,123):
  A.append(S.count(chr(i)))

if sum(A)==26:
  print('None')
else:
  print(chr(A.index(0)+97))

Solution (Python):
import string
s = input()
for a in string.ascii_lowercase:
    if a not in s:
        print(a)
        break
    if a =="z":
        print("None")
        break

Solution (Python):
S = input()
flag = True
for i in range(26):
    if not chr(ord('a') + i) in S:
        print(chr(ord('a') + i))
        flag = False
        break
if flag:
    print('None')

Solution (Python):

S = set(input()) 
lists = set([chr(i) for i in range(ord('a'), ord('z')+1)])
ans = lists^S
print(min(ans) if len(list(ans)) != 0 else 'None')

Solution (Python):
S = list(map(str, input()))
S = set(S)
a = set(list('abcdefghijklmnopqrstuvwxyz'))
if len(list(a-S)) == 0:
  print('None')
else:
  print(sorted(list(a-S))[0])

Solution (Python):
S = set(input())
lists = set([chr(i) for i in range(ord('a'), ord('z')+1)])
ans = lists-S
print(min(ans) if len(list(ans)) != 0 else 'None')

Solution (Python):
alphabet = "abcdefghijklmnopqrstuvwxyz"
inputs = dict.fromkeys(set(input()))
chars = alphabet.translate(str.maketrans(inputs))
print(chars[0] if len(chars) > 0 else "None")

Solution (Python):
S = input()
list = []
for i in range(len(S)):
    list.append(S[i])
list = set(list)
lists = set([chr(i) for i in range(ord('a'), ord('z')+1)])
ans = lists-list
print('None' if len(ans)==0 else min(ans))

Solution (Python):
def resolve():
    B = input()
    b = set(B)
    for c in "abcdefghijklmnopqrstuvwxyz":
        if not c in b:
            print(c)
            return
    print("None")
            

if '__main__' == __name__:
    resolve()

Solution (Python):
S =input()

A = set(list('abcdefghijklmnopqrstuvwxyz'))
S = set(S)

if len(list(A-S)) == 0:
    print("None")
else:
    print (sorted(list(A-S))[0])

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    s = set(input())
    for i in [chr(i) for i in range(97, 97 + 26)]:
        if i not in s:
            print(i)
            break
    else:
        print("None")


if __name__ == '__main__':
    resolve()

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

S = input()

flag = True
for di in d:
    if di not in S:
        print(di)
        flag = False
        break
        
if flag:
    print('None')

Solution (Python):
S = input()
alp = set(list('abcdefghijklmnopqrstuvwxyz'))
alp -= set(S)
if len(alp) == 0:
    print('None')
else:
    print(sorted(list(alp))[0])

Solution (Python):
s = input()
abc = [chr(i+97) for i in range(26)]
for i in s:
    if i in abc:
        abc.remove(i)
if abc:
    print(min(abc))
else:
    print("None")

Solution (Python):
s = input()

alp = [True for _ in range(26)]

for c in s:
    alp[ord(c) - ord('a')] = False

for flag, i in zip(alp, range(26)):
    if flag:
        print(chr(ord('a') + i))
        exit()
print('None')

Solution (Python):
x = list(input())
i=0
while True:
	if i==26:
		print('None')
		break
	if not chr(ord('a')+i) in x:
		print(chr(ord('a')+i))
		break
	i+=1

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

def main():
    S=set(input())
    a=ord('a')
    for i in range(26):
        if not chr(a+i) in S:
            print(chr(a+i))
            exit()
    print('None')

if __name__ == '__main__':
    main()

Solution (Python):
s = list(set(list(input())))
flag = True
for c in [chr(i) for i in range(97, 97+26)]:
    if c not in s:
        print(c)
        flag = False
        break
if flag:
    print('None')

Solution (Python):
from collections import defaultdict
import string

alf = string.ascii_lowercase

d = defaultdict(int)
S = ''.join(sorted(input()))
for v in alf:
    d[v] = 0

for i, v in enumerate(S):
    d[v] += 1


sd = sorted(d.items())

count = 0
for v in sd:
    if(v[1] == 0):
        print(v[0])
        exit()
    else:
        count += 1
        continue

if (count == 26):
    print('None')

Solution (Python):
S = set(input())
ans = set([chr(i) for i in range(ord('a'), ord('z')+1)])

ans = list(ans - S)
if not ans:
    print("None")
else:
    ans.sort()
    print(ans[0])

Solution (Python):
s = input()
s = set(s)
for i in range(ord('a'), ord('z') + 1):
    t = chr(i)
    if t not in s:
        print(t)
        break
else:
    print('None')

Solution (Python):
s = list(input())
ss = list(set(s))
alp = [chr(ord("a")+i) for i in range(26)]
ans = "None"
for a in alp:
    if a in ss:
        continue
    else:
        ans = a
        break
print(ans)

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
MOD = 10**9+7

def main():
    S = set(input())
    A = set('abcdefghijklmnopqrstuvwxyz')
    diff = A - S
    ans = list(diff)
    print(min(ans) if ans else 'None')


if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin
import sys

S = stdin.readline().rstrip()

for c in range(ord('a'), ord('z')+1):
    if S.find(chr(c)) == -1:
        print(chr(c))
        sys.exit()

print("None")

Solution (Python):
S = list(input())
minal = ord('z')
for i in range(ord('a'), ord('z')+1):
    if i < minal and chr(i) not in S:
        minal = i
list = set(S)
print(chr(minal) if len(list)!=26 else 'None')

Solution (Python):
ch = 97
s = input()
for i in range(26):
    s_ = chr(ch+i)
    if s_ not in s:
        print(s_)
        exit()
print("None")

Solution (Python):
s = input()

for i in range(26):
    if s.count(chr(ord("a") + i)) == 0:
        print(chr(ord("a") + i))
        exit()

print("None")

Solution (Python):
S = set(input())
def solve(S):
    for i in 'abcdefghijklmnopqrstuvwxyz':
        if not i in S:
            return i
    return 'None'
ans = solve(S)
print(ans)

Solution (Python):
import string
S=input()
ans=''
for s in string.ascii_lowercase:
  if s not in S:
    ans=s
    break
if ans=='':
  print('None')
else:
  print(ans)

Solution (Python):
alphabet = "abcdefghijklmnopqrstuvwxyz"

S = input()

result = ""
found = True

for i in alphabet:
    if i not in S:
        result = i
        found = False
        break

if not found:
    print(result)
else:
    print("None")

Solution (Python):
s = input()
alphabet = 'abcdefghijklmnopqrstuvwxyz'
for t in s:
	alphabet = alphabet.replace(t, '')
r = alphabet[0] if len(alphabet) > 0 else 'None'
print(r)

Solution (Python):
s = list(input())
set(s)
s.sort()
t = list("abcdefghijklmnopqrstuvwxyz")

for c in t:
  if c in s:
    continue
  else:
    print(c)
    exit()

print("None")

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']
s=set(input())
n=0
for i in alp:
  if i not in s:
    print(i)
    n=1
    break
if n==0:
  print('None')

Solution (Python):
S = input()

for i in range(26):
  if not chr(ord("a")+i) in S:
    print(chr(ord("a")+i))
    exit()
print("None")

Solution (Python):
S = input()
for i in range(ord("a"), ord("z")+1):
  if chr(i) not in S:
    print(chr(i))
    exit()
print("None")

Solution (Python):
import sys
import os
import math

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

MOD = 10 ** 9 + 7


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    T = set('abcdefghijklmnopqrstuvwxyz')
    S = set(iss())
    s = sorted(T ^ S)
    print(s[0] if len(s) > 0 else 'None')



if __name__ == '__main__':
    main()

Solution (Python):
s = input()

alpha = [chr(i) for i in range(97,123)]

for i in s:
  if i in alpha:
    alpha.remove(i)

if len(alpha) == 0:
  print("None")
else:
  print(alpha[0])

Solution (Python):
exist = True
s = list(input())
e_l = [chr(i) for i in range(97, 97+26)]
for i in e_l:
    if i not in s:
        exist = False
        break
if exist:
    print('None')
else:
    print(i)

Solution (Python):
l=list(ord(c) for c in input())
sample=list(range(97,123))
diff=list(sorted(set(sample).difference(l)))
if len(diff)>0:
    print (chr(diff[0]))
else:
    print ('None')

Solution (Python):
def main():
    S = input()
    abc = 'abcdefghijklmnopqrstuvwxyz'
    for c in abc:
        if c not in S:
            print(c)
            exit()
    print('None')


if __name__ == '__main__':
    main()

Solution (Python):
S=input()
L="abcdefghijklmnopqrstuvwxyz"
for i in range(len(L)):
    if L[i] not in S:
        print(L[i])
        exit()
print("None")

Solution (Python):
s = input()
set_s = set(s)

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

ans_li = sorted([a for a in alphabet_li if a not in set_s])

if len(ans_li)==0:
    print('None')
else:
    print(ans_li[0])

Solution (Python):
S = input()

al = 'abcdefghijklmnopqrstuvwxyz'

ans = ''

for i in range(len(al)):
    if al[i] not in S:
        print(al[i])
        ans = al[i]
        break
if ans=='':
    print('None')

Solution (Python):
S=input()
L="abcdefghijklmnopqrstuvwxyz"
for i in range(len(L)):
    if L[i] not in S:
        print(L[i])
        exit()
print("None")

Solution (Python):
s = set(input())
l = list("abcdefghijklmnopqrstuvwxyz")
for i in s:
    l.remove(i)
if l == []:
    print("None")
else:
    print(l[0])

Solution (Python):
s = input()
set_s = set(s)

moji = [chr(i) for i in range(97,97+26)]
for i in range(len(moji)):
    if not(moji[i] in set_s):
        print(moji[i])
        quit()
print("None")

Solution (Python):
s = input()
set_s = set(s)
if len(set_s) == 26:
    print("None")
    quit()
moji = [chr(i) for i in range(97,97+26)]
for i in range(len(moji)):
    if not(moji[i] in set_s):
        print(moji[i])
        quit()

Solution (Python):
S = input()
alphabet = [chr(ord("a") + i) for i in range(26)]
ans = "None"

for c in alphabet:
    if c not in S:
        ans = c
        break

print(ans)

Solution (Python):
s = list(sorted(input()))

ans = 'None'
for i in range(26):
    if chr(97 + i) not in s:
        ans = chr(97 + i)
        break
print(ans)

Solution (Python):
s=input()
lowercase = 'abcdefghijklmnopqrstuvwxyz'
count=0
for moji in lowercase:
  if moji not in s:
    print(moji)
    break
else:
  print('None')

Solution (Python):
S = input()
S = set([s for s in S])

if len(S) == 26:
    print('None')
else:
    for i in range(97, 123):
        if chr(i) not in S:
            print(chr(i))
            break

Solution (Python):
from string import ascii_lowercase
alpha = {i for i in ascii_lowercase}
s = set([i for i in input()])
ans = sorted(alpha - s)
if ans==[]:
    print('None')
else:
    print(ans[0])

Solution (Python):
s = input()
sample = list("abcdefghijklmnopqrstuvwxyz")

for i in s:
    if i in sample:
        sample.remove(i)

if len(sample) == 0:
    print("None")
else:
    print(sample[0])

Solution (Python):
from string import ascii_lowercase

s = set(list(input()))

for c in ascii_lowercase:
    if c not in s:
        print(c)
        exit()
print("None")

Solution (Python):
S = list(input())
S = list(set(S))
allset = [chr(i) for i in range(97, 97+26)]
not_duplicate = list(set(allset) ^ set(S))
not_duplicate.sort()
print(not_duplicate[0]) if len(not_duplicate) != 0 else print("None")

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

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

for i in chrs:
  if i not in s:
    print(i)
    exit()
print("None")

Solution (Python):
key = ["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", "None"]
judge = dict()
for value in key:
  judge[value] = False
s = input()
n = len(s)
for i in range(n):
  judge[s[i]] = True

for i in range(27):
  if judge[key[i]] == False:
    print(key[i])
    break

Solution (Python):
mset=set(list(input()))
aset=set(list("qazwsxedcrfvtgbyhnujmikolp"))
aset=aset-mset
lis=sorted(list(aset))
if len(lis):
    print(lis[0])
else:
    print("None")

Solution (Python):
s = input()
l = list({s[i] for i in range(len(s))})
a = [False] * 26
for c in l:
    a[ord(c) - ord("a")] = True
ans = "None"
for i in range(len(a)):
    if a[i] == False:
        ans = chr(ord("a") + i)
        break
print(ans)

Solution (Python):
import string


S = input()
lowercase_list = string.ascii_lowercase

bucket = [0 for i in range(len(lowercase_list))]
for s_i in S:
    bucket[lowercase_list.index(s_i)] += 1


for index, val in enumerate(bucket):
    if val == 0:
        print(lowercase_list[index])
        exit()
print('None')

Solution (Python):
s = input()
flg = 0
for i in 'abcdefghijklmnopqrstuvwxyz':
    if i not in s:
        print(i)
        flg = 1
        break
if flg == 0:
    print('None')

Solution (Python):
s = input()
alps = 'abcdefghijklmnopqrstuvwxyz'
for i in alps:
    if i not in s:
        print(i)
        break
else:
    print('None')

Solution (Python):
s = input()
alps = 'abcdefghijklmnopqrstuvwxyz'
for alp in alps:
    if alp not in s:
        print(alp)
        break
else:
    print('None')

Solution (Python):
icase=0
if icase==0:
    s=set(input())
    abc=list("abcdefghijklmnopqrstuvwxyz")

    yn=""
    for i in range(len(abc)):
        if not abc[i] in s:
            print(abc[i])
            yn="OK"
            break
    if yn=="":
        print("None")

Solution (Python):
import itertools
import math
import string
import collections
from collections import Counter
from collections import deque
import sys
sys.setrecursionlimit(2*10**5)
INF = 2**60


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor



dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]

S = input()

SS = list(S)
a = []
for i in range(97, 97+26):
    a.append(chr(i))

result = list(set(a)-set(SS))



if result == []:
    print('None')
else:
    print(sorted(result)[0])

Solution (Python):
import sys
S = input()
als = ["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 S[i] in als:
        als.remove(S[i])
    if als ==[]:
        print("None")
        sys.exit()
print(als[0])

Solution (Python):
s = input()
alps = 'abcdefghijklmnopqrstuvwxyz'
for alp in alps:
    if alp not in s:
        print(alp)
        break
else:
    print('None')

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

sentence=input()
sentence= sentence.lower()

for i in eng:
  if not i in sorted(list(set(sorted(sentence)))):
    print(i)
    break
else:
    print('None')

Solution (Python):
S = list(input())
s = set(S)

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

ans = A - s

ANS = list(ans)

ANS.sort()

if ANS != []:
    print(ANS[0])
else:
    print("None")

Solution (Python):

import io

data=input()

for i in 'abcdefghijklmnopqrstuvwxyz':
    if not i in data:
        print(i)
        break
else:
    print('None')

Solution (Python):












slist = "abcdefghijklmnopqrstuvwxyz"
S = input()

fulset = set(list(slist))
Sset = set(list(S))
kouho = fulset-Sset

ans = "None"
if len(kouho)!=0:
    ans = min(kouho)
print(ans)

Solution (Python):
from string import ascii_lowercase

s = input()
for c in ascii_lowercase:
    if c not in s:
        print(c)
        break
else:
    print('None')

Solution (Python):

s = list(input())

for i in range(97,123):
    if chr(i) not in s:
        print(chr(i))
        exit()
print("None")

Solution (Python):
s=input()
al=[chr(_) for _ in range(97,123)]
for i in range(len(s)):
    if s[i] in al:
        al.remove(s[i])
if len(al)==0:
    print('None')
else:
    print(al[0])

Solution (Python):
s=input()
s=list(set(s))

A=[]
for i in range(97,123):
    A.append(chr(i))


for i in range(len(A)):
    if A[i] in s:
        continue
    else:
        print(A[i])
        exit()

print("None")

Solution (Python):
s = list(input())
label = [chr(i) for i in range(97, 97+26)]

ans = "None"
for l in label:
  if not l in s:
    ans = l
    break
    
print(ans)

Solution (Python):
s=input()
s=list(set(s))

A=[]
for i in range(97,123):
    A.append(chr(i))


for i in range(len(A)):
    if A[i] in s:
        continue
    else:
        print(A[i])
        exit()

print("None")

Solution (Python):
s = list(input())
flag = True


for i in range(ord('a'), ord('z') + 1):
    if s.count(chr(i)) == 0:
        flag = False
        ans = chr(i)
        break
print('None' if flag else ans)

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

for a in alpha:
    if a not in S:
        print(a)
        break
else:
    print("None")

Solution (Python):
def main():
    S = input()
    alphabet = "abcdefghijklmnopqrstuvwxyz"
    flag = 0
    for c in alphabet:
        if S.count(c) == 0:
            print(c)
            flag = 1
            break
    if flag == 0:
        print("None")
main()

Solution (Python):
s = set('abcdefghijklmnopqrstuvwxyz')
S = input()

for c in S:
    if c in s:
        s.remove(c)

if len(s) == 0:
    print('None')
else:
    print(min(s))

Solution (Python):
S = input()

for i in range(27):
  if i == 26:
    print("None")
  elif chr(i+97) in S:
    continue
  else:
    print(chr(i+97))
    break

Solution (Python):
S = set(list(input()))
b = set(list("abcdefghijklmnopqrstuvwxyz"))

if len(S) == 26:
  print("None")
else:
  print(sorted(list(b-S))[0])

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

for i in al:
    if i not in S:
        print(i)
        exit()


print('None')

Solution (Python):
S = input()

s = set(S)

if len(s) == 26:
    print('None')
else:
    for i in 'abcdefghijklmnopqrstuvwxyz':
        if i not in S:
            print(i)
            break

Solution (Python):
def myAnswer(S:set)-> str:
   alf = [chr(ord('a')+i) for i in range(26)]
   counter = "None"
   for a in alf:
      if((a in S) == False):
         counter=a
         break
   return counter



   

def modelAnswer():
   tmp=1
def main():
   S = set(input())
   print(myAnswer(S))

if __name__ == '__main__':
   main()

Solution (Python):
S = input()

for i in range(ord('a'), ord('a') + 26):
    if chr(i) not in S:
        print(chr(i))
        break
else:
    print('None')

Solution (Python):
s = input()
Al = [chr(_)  for _ in range(97,123)]
   
for i in range(len(s)):
  if s[i] in Al:
    Al.remove(s[i])

if len(Al) ==0:
    print('None')
else :
    print(Al[0])

Solution (Python):
import collections

S =input()
char = collections.Counter(S)
char_bas = 'abcdefghijklmnopqrstuvwxyz'

for i in range(len(char_bas)):
    if char_bas[i] in char:
        if char_bas[i] == 'z':
            print('None')
            break
        continue
    else:
        print(char_bas[i])
        break

Solution (Python):

a = 'abcdefghijklmnopqrstuvwxyz'
s = input()
for c in s:
    if c in a:
        a = a.replace(c, '')

print(a[0] if len(a) > 0 else 'None')

Solution (Python):
S = set(input())
ascii_list = [i for i in range(97, 123)]
for i in S:
    ascii_list.remove(int(ord(i)))
if ascii_list:
    print(chr(ascii_list[0]))
else:
    print('None')

Solution (Python):
import string


def main():
    s = input()
    a = {i: False for i in string.ascii_lowercase}
    for i in s:
        a[i] = True
    r = [i for i, j in a.items() if j == False]
    if 0 < len(r):
        print(r[0])
    else:
        print("None")


main()

Solution (Python):
S = input()

word = 'abcddefghijklmnopqrstuvwxyz'

import sys

for s in word:
    if S.count(s) == 0:
        print(s)
        sys.exit()
        
print('None')

Solution (Python):
S = input()
a = set([chr(i) for i in range(ord('a'),ord('a')+26)])
S = set(list(S))
A = a-S
if len(A)==0:
    print('None')
else:
    print(sorted(list(A))[0])

Solution (Python):
S = input()
L = "abcdefghijklmnopqrstuvwxyz"
for i in L:
  if i not in S:
    print(i)
    exit()
print("None")

Solution (Python):
s = input()
a = True
for i in range(97,123):
    if not(chr(i) in s):
        print(chr(i))
        a = False
        break
if a:
    print(None)

Solution (Python):
import collections
import sys
import numpy as np
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
MOD = 10**9+7
import itertools
import math

s = 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"]
li_cnt = [0]*26
for i in range(len(s)):
    for j in range(len(li)):
        if li[j] == s[i]:
            li_cnt[j] += 1
ans = ""
for i in range(len(li_cnt)):
    if li_cnt[i] == 0:
        ans += li[i]
        break
if len(ans) == 0:
    print("None")
else:
    print(ans)

Solution (Python):
import string

s = set(input())

a = set(string.ascii_lowercase)
b = sorted(list(a - s))
ans = b[0] if len(b) else "None"
print(ans)

Solution (Python):
S = input()

used = set([s for s in S])
ans = "None"
for c in [chr(i) for i in range(97, 97 + 26)]:
    if c not in used:
        ans = c
        break

print(ans)

Solution (Python):
s  =input()
alp = [chr(ord('a')+i)for i in range(26)]
for x in alp:
    if x not in s:
        print(x)
        exit(0)
print('None')

Solution (Python):
S = list(input())
S = set([ord(s) for s in S])

for i in range(97, 123):
    if i not in S:
        print(chr(i))
        exit()
else:
    print('None')

Solution (Python):
alphabets = "abcdefghijklmnopqrstuvwxyz"


s = input()

FOUND = {c:False for c in alphabets}
for c in s:
    FOUND[c] = True

for c in alphabets:
    if not FOUND[c]:
        print(c)
        exit()
print(None)

Solution (Python):
import string
s = set(list(input()))
ans = 'None'
for c in string.ascii_lowercase:
    if not c in s:
        ans = c
        break

print(ans)

Solution (Python):
from __future__ import print_function

import sys

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction
from fractions import gcd



import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


def lcm(n, m):
    return int(n * m / gcd(n, m))


def coprimize(p, q):
    common = fractions.gcd(p, q)
    return (p // common, q // common)


def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


def find_gcd(list_l):
    x = reduce(gcd, list_l)
    return x


def main():
    S = set(list("abcdefghijklmnopqrstuvwxyz")) - set(list(input().strip())) 
    if len(list(S))!=0:
        print( sorted(list(S))[0] )
    else:
        print("None")
    

if __name__ == '__main__':
    main()