Harryxun/stf_run huggingface dataset:
S = input()
N = len(S)
ans = [0] * N
i = 0
while i < N:
  count = 1
  while S[i+count] == S[i]:
    count += 1
    if count == N-1-i:
      break
  if S[i] == 'R':
    ans[i+count] += (count+1)//2
    ans[i+count-1] += count//2
  else:
    ans[i] += (count+1)//2
    ans[i-1] += count//2
  i += count
print(*ans)

### FIXED CODE ###

S = input()
N = len(S)
ans = [0] * N
i = 0
while i < N:
  if i == N-1:# 一番右はL固定
    ans[N-1] +=1
    break
  count = 1
  while S[i+count] == S[i]:
    count += 1
    if count == N-i:
      break
  if S[i] == 'R':
    ans[i+count-1] += (count+1)//2
    ans[i+count] += count//2
  else:
    ans[i] += (count+1)//2
    ans[i-1] += count//2
  i += count
print(*ans)
a, b, h = map(int, input().split())
print((a+b) * (h/2))


### FIXED CODE ###

a = int(input())
b = int(input())
h = int(input())
print(int((a+b)*h/2))
#C
N, M = map(int, input().split())
Table = [list(map(int, input().split())) for _ in range(M)]
Table.sort(key=lambda x:x[0])
Table.sort(key=lambda x:x[1])
#print(f'Table:{Table}')
first = Table[0][0]
end = Table[0][1]
Table.pop(0)

#print(f'first:{first} end:{end}')
for task in Table:
    #print(f'task:{task}')
    num = task[0]
    #print(f'num:{num}')
    if num <= end:
        first = num
    else:
        ans = 0
        break

if ans == 0:
    print(ans)
else:
    print(end-first+1)

### FIXED CODE ###

def kasanari(A, B, C, D):
    if B < C or A > D:
        return 0
    elif B <= D:
        if A >= C:
            return [A, B]
        else:
            return [C, B]
    else:
        if A >= C:
            return [A, D]
        else:
            return [C, D]

N, M = map(int, input().split())
L = []
for _ in range(M):
    L.append(list(map(int, input().split())))

tmp = [L[0][0], L[0][1]]
L.pop(0)
for i in L:
    L1 = tmp[0]
    R1 = tmp[1]
    tmp = kasanari(L1, R1, i[0], i[1])
    if tmp == 0:
        print(0)
        exit()
print(tmp[1]-tmp[0]+1)
from math import ceil
n, h = map(int, input().split())
data1, data2 = [], []
for i in range(n):
    a, b = map(int, input().split())
    data1.append([a, b])
    data2.append([a, b])

data1 = sorted(data1, key = lambda x: x[0], reverse = True)
data2 = sorted(data2, key = lambda x: x[1], reverse = True)
ans = 0
while data1[0][0] < data2[0][1]:
    h -= data2[0][1]
    ans += 1
    del data2[0]
ans += ceil(h / data1[0][0])
print(ans)

### FIXED CODE ###

from math import ceil
n, h = map(int, input().split())
data1, data2 = [], []
for i in range(n):
    a, b = map(int, input().split())
    data1.append([a, b])
    data2.append([a, b])

data1 = sorted(data1, key = lambda x: x[0], reverse = True)
data2 = sorted(data2, key = lambda x: x[1], reverse = True)
ans = 0
while h > 0 and data1[0][0] < data2[0][1]:
    h -= data2[0][1]
    ans += 1
    del data2[0]
    if len(data2) == 0:
        break
ans += ceil(max(0, h) / data1[0][0])
print(ans)
n = input()
if 7 in n:
    print('Yes')
else:
    print('No')

### FIXED CODE ###

n = input()
if '7' in n:
    print('Yes')
else:
    print('No')
n = input()
a, b, c = sorted(map(int, raw_inpu().split()))
print 'YES' if a*a+b*b==c*c else 'NO'

### FIXED CODE ###

n = input()
for i in xrange(n):
    a, b, c = sorted(map(int, raw_input().split()))
    print 'YES' if a*a+b*b==c*c else 'NO'
a,b,c,d=map(int,input().split())
ans = -10**9
for i in range([a,b]):
  for j in range([c,d]):
    ans = max(ans, i*j)

print(ans)


### FIXED CODE ###

a,b,c,d=map(int,input().split())
ans = a*c
for i in [a,b]:
  for j in [c,d]:
    ans = max(ans, i*j)

print(ans)
from statistics import median

n = int(input())
a = [int(i) for i in input().split()]

b = int(median([v-i for i, v in enumerate(a, 1)]))
res = 0
for i, v in enumerate(a, 1):
    res += abs(v-(b+i))

print(res)


### FIXED CODE ###

import statistics  
N = int(input())
A=list(map(int, input().split()))
B=[]
for number, i in enumerate(A, 1):
    B.append(i-number)
median = int(statistics.median(B))
ans2 = 0
for i in B:
    ans2 += abs(i-median)
print(ans2)
import math

S = input().split()
A = int(S[0])
B = int(S[1])
C = int(S[2])
D = int(S[3])

E = (C * D) / math.gcd(C, D)
X = math.floor(B/C) - math.floor(A/C)
Y = math.floor(B/D) - math.floor(A/D)
Z = math.floor(B/E) - math.floor(A/E)

print(int(B-A-X-Y+Z))


### FIXED CODE ###


def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a

 #最小公倍数


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


S = input().split()
A = int(S[0])
B = int(S[1])
C = int(S[2])
D = int(S[3])

E = lcm(C, D)

X = int(B//C)-int((A-1)//C)
Y = int(B//D)-int((A-1)//D)
Z = int(B//E)-int((A-1)//E)

print(B-A+1-X-Y+Z)
aaa = input()
bbb = input()
d = {}
ans = 'Yes'
for a, b in zip(aaa, bbb):
  if a in d and d.get(a) != b:
    print ('%s %s %s %s' % (aaa, bbb, a,b ))
    ans = 'No'
  d[a] = b
vs = list(d.values())
if max([vs.count(k) for k in vs]) >= 2:
  ans = 'No'
print(ans)

### FIXED CODE ###

aaa = input()
bbb = input()
d = {}
d_rev = {}
ans = 'Yes'
for a, b in zip(aaa, bbb):
  if (a in d and d.get(a) != b) or (b in d_rev and d_rev.get(b) != a):
    ans = 'No'
  d[a] = b
  d_rev[b] = a
print(ans)
import sys
input = sys.stdin.readline

def main():
    N = int(input())
    X = int(input(),2)
    LIST = []
    ANS = [0]*N
    TEMP = [0]*N
    CHAIND = [0]*N
    bit = 1

    cnt = count_ones_by_bitmask(X)
    if cnt !=0:
        p = X % (cnt+1)
        m = X % (cnt-1)
    for i in range(N):
        LIST.append(X^bit)
        if LIST[i]!=0:
            ANS[i] = 1
            if (X & bit == 0):
                TEMP[i] = (p + bit % (cnt+1) ) % (cnt+1)
            else:
                TEMP[i] = (m - bit % (cnt-1) ) % (cnt-1)            
        bit = bit<<1


    CHA = list(set(TEMP))

    for i in range(len(CHA)):
        an = 0
        cha = CHA[i]
        cnt = count_ones_by_bitmask(CHA[i])
        while cnt>0:
            an += 1
            cha = cha%cnt
            cnt = count_ones_by_bitmask(cha)
        CHAIND[CHA[i]] = an

    for i in reversed(range(N)):
        print(ANS[i]+CHAIND[TEMP[i]])




def count_ones_by_bitmask(num):
    count = 0
    while num:
        count += num & 1
        num >>= 1
    return count

if __name__ == '__main__':
    main()


### FIXED CODE ###

def main():
    N = int(input())
    X = input()
    XINT = int(X,2)
    ANS = [0]*N
    TEMP = [0]*N
    CHAIND = [0]*N

    cnt = count_ones_by_bitmask(XINT)
    
    if cnt == 0:
        for i in range(N):
            print(1)
            return
    if cnt ==1:
        for i in  range(N):
            if X[i] == '1':
                print(0) #全てが0になる
            else:
                if i==N-1:
                    print((int(X[N-1])+1)%2+1) # 2の剰余の反転
                else:
                    print((int(X[N-1]))%2+1) # 2の剰余
        return

    p = XINT % (cnt+1)
    m = XINT % (cnt-1)
    pmod = 1
    mmod = 1
    for i in range(N):
        ANS[i] = 1
        if (X[N-i-1] == '0'):
            TEMP[i] = (p + pmod) % (cnt+1)
        else:
            TEMP[i] = (m - mmod) % (cnt-1)
        pmod = (pmod*2) % (cnt+1)
        mmod = (mmod*2) % (cnt-1)


    CHA = list(set(TEMP))

    for i in range(len(CHA)):
        an = 0
        cha = CHA[i]
        cnt = count_ones_by_bitmask(CHA[i])
        while cnt>0:
            an += 1
            cha = cha%cnt
            cnt = count_ones_by_bitmask(cha)
        CHAIND[CHA[i]] = an

    for i in reversed(range(N)):
        print(ANS[i]+CHAIND[TEMP[i]])


def count_ones_by_bitmask(num):
    count = 0
    while num:
        count += num & 1
        num >>= 1
    return count

if __name__ == '__main__':
    main()
n=int(input())
s=[int(input()) for i in range(n)]
#print(n,s)

dp=[float('-inf') for i in range(10000+1)]
#print(dp)

dp[0]=0
k=0
for j in range(n):
    k+=s[j]
    for i in range(k):
        dp[i+k]=dp[i]+s[j]
#print(dp)

for i in range(len(dp)):
    if dp[i]%10==0:
        dp[i]=0
        
print(max(dp))




### FIXED CODE ###

n=int(input())
s=[int(input()) for i in range(n)]
#print(n,s)
t=[[float('-inf') for i in range(10000+1)] for i in range(n+1)]

t[0][0]=0
for j in range(1,n+1):
    t[j]=t[j-1]
    tmp=[]
    for i in range(10000+1):
        if t[j-1][i]>=0:
            tmp.append(t[j-1][i])
    for i in tmp:
        t[j][i+s[j-1]]=i+s[j-1]

for i in range(len(t[n])):
    if t[n][i]%10==0:
        t[n][i]=0

print(max(t[n]))
H, W = map(int, input().split())
N = int(input())

i = 0
buf = [0] * W
k = 1
for x, ai in aip(range(1, N+1), map(int, input().split())):
  for _ in range(ai)
	buf[i] = x
    i += 1
    if i >= W:
      print(" ".join(buf[::k]))
      i = 0
      k = -k



### FIXED CODE ###

H, W = map(int, input().split())
N = int(input())

i = 0
buf = [0] * W
k = 1
for x, ai in zip(range(1, N+1), map(int, input().split())):
  for _ in range(ai):
    buf[i] = x
    i += 1
    if i >= W:
      print(" ".join(map(str, buf[::k])))
      i = 0
      k = -k
def LCS():
  x = raw_input()
  y = raw_input()
  X = len(x)
  Y = len(y)
  
  for i in range(X):
    c[i][0] = 0
  for j in range(Y):
    c[0][j] = 0

  for i in range(X):
    for j in range(Y):
      if X[i] == Y[i]: 
        c[i][j] = c[i - 1][j - 1] + 1

      elif c[i - 1][j] >= c[i][j - 1]:
        c[i][j] = c[i - 1][j]

      else:
        c[i][j] = c[i][j - 1]

  print c[X][Y]

q = input()

for i in range(q):
  LCS()

  
    

### FIXED CODE ###

def LCS():
    X = raw_input()
    Y = raw_input()
 
    a, b = len(X), len(Y)
    c1 = [0 for i in range(b+1)]
    for i in range(a):
        e1 = X[i]
        c2 = c1+[]
        for j in range(b):
            if e1 == Y[j]:
                c1[j+1] = c2[j] + 1
            elif c1[j+1] < c1[j]:
                c1[j+1] = c1[j]
    return c1[-1]
 
n = input()
for i in range(n):
    print LCS()
a,b,c=[int(input())for i in range(3)]
    print((a-b)%c)

### FIXED CODE ###

x,a,b = [int(input()) for i in range(3)]
print((x-a)%b)
a,b=map(int,input())
c,d=map(int,input())
print((a-c)*(b-d))

### FIXED CODE ###

a,b=map(int,input().split())
c,d=map(int,input().split())
print((a-c)*(b-d))
n, t = map(int, input().split)
routes = []
for _ in range(n):
  routes.append(tuple(map(int, input().split)))
print(min(route[0] for route in routes if route[1]<t))

### FIXED CODE ###

n, t = map(int, input().split())
routes = []
for _ in range(n):
  routes.append(tuple(map(int, input().split())))
try:
  print(min(route[0] for route in routes if route[1]<=t))
except:
  print("TLE")
s = list(input())

t = list("AKIHABARAw")
cnt = 0

if len(s) > len(t)-1:
    print("NO")
    exit()

for i in range(len(s)):
    if s[i] == t[cnt]:
        cnt += 1
    else:
        if t[cnt] == "A":
            cnt += 1
            if t[cnt] == s[i]:
                cnt += 1
            else:
                print("NO")
                eixt()
        else:
            print("NO")
            exit()
            
if cnt >= 7:
    print("YES")
else:
    print("NO")
            

### FIXED CODE ###

s = input()

check = ["KIHBR","KIHBRA","KIHBAR","KIHBARA","KIHABR","KIHABRA","KIHABAR","KIHABARA","AKIHBR","AKIHBRA","AKIHBAR","AKIHBARA","AKIHABR","AKIHABRA","AKIHABAR","AKIHABARA"]

if s in check:
    print("YES")
else:
    print("NO")
import sys

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


def resolve():
    n, m = map(int, input().split())

    cnt = [0] * n
    for i in range(n):
        a, b = map(int, input().split())
        cnt[a - 1] += 1
        cnt[b - 1] += 1

    for i in cnt:
        if i % 2:
            print("NO")
            break
    else:
        print("YES")


if __name__ == '__main__':
    resolve()


### FIXED CODE ###

import sys

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


def resolve():
    n, m = map(int, input().split())

    cnt = [0] * n
    for i in range(m):
        a, b = map(int, input().split())
        cnt[a - 1] += 1
        cnt[b - 1] += 1

    for i in cnt:
        if i % 2:
            print("NO")
            break
    else:
        print("YES")


if __name__ == '__main__':
    resolve()
def judge(N):
    return N//100000000

N=int(input())
arr0=[]
arr1=[]
arr2=[]
arr3=[]
arr4=[]
arr5=[]
arr6=[]
arr7=[]
arr8=[]
arr9=[]
arrs=[arr0,arr1,arr2,arr3,arr4,arr5,arr6,arr7,arr8,arr9]

amount=0

for n in range(N):
    _=int(input())
    a = judge (_)
    if arrs[a].count(_)>=1:
        arrs[a].remove(_)
    else:
        arrs[a].append(_)

for x in range(len(arrs)):
    amount +=len(arrs[x])

print(amount)

### FIXED CODE ###

N=int(input())
S=set()

for n in range(N):
    _=int(input())
    if _ in S:
        S.remove(_)
    else:
        S.add(_)

print(len(S))
from sys import stdin

a, b = stdin.readline().rstrip().split()
if (a*b) % 2:
    print("Odd")
else:
    print("Even")

### FIXED CODE ###

from sys import stdin
 
a, b = map(int, input().split())
if (a*b) % 2:
    print("Odd")
else:
    print("Even")
import math
import sys

def overlap(p1, p2, d):
    return (p1[0] - p2[0])**2 + (p1[1] - p2[1])**2 <= d

def intersection(o1,o2):
    a  = 2*(o2[0] - o1[0])
    b  = 2*(o2[1] - o1[1])
    c  = (o1[0] - o2[0])*(o1[0] + o2[0]) + (o1[1] - o2[1])*(o1[1] + o2[1])
    a2 = a**2 + b**2
    b2 = a*c + a*b*o1[1] - b**2*o1[0]
    c2 = b**2*(o1[0]**2 + o1[1]**2 - 1) + c**2 + 2*b*c*o1[1]
    x1 = (-b2 + math.sqrt(b2**2 - a2*c2))/a2
    x2 = (-b2 - math.sqrt(b2**2 - a2*c2))/a2
    if b == 0:
        y1 = (o1[1] + o2[1])/2
        y2 = (o1[1] + o2[1])/2
    else:
        y1 = -(a*x1 + c)/b
        y2 = -(a*x2 + c)/b
    if b2**2 - a2*c2 < 10e-6:
        return [x1, y1], [None, None]
    else:
        return [x1, y1], [x2, y2]

while True:
    n = int(input())
    if n == 0:
        break
    p = []
    for i in range(n):
        p.append(list(map(float, input().split(","))))
    ans = 0
    for i in range(n - 1):
        for j in range(i + 1, n):
            if not overlap(p[i], p[j], 4):
                continue
            elif overlap(p[i], p[j], 10e-6):
                continue
            p1, p2 = intersection(p[i], p[j])
            cnt1 = 0
            cnt2 = 0
            for k in range(n):
                if overlap(p1, p[k], 1):
                    cnt1 += 1
                if p2[0] != None and overlap(p2, p[k], 1):
                    cnt2 += 1
            ans = max([ans, cnt1, cnt2])
    print(ans)



### FIXED CODE ###

import math

def dist(p1, p2):
    return math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)

def intersection(o1,o2):
    if dist(o1,o2) > 2:
        p1, p2 =  [None, None], [None, None]
    elif dist(o1,o2) == 2:
        p1, p2 =  [(o1[0] + o2[0])/2, (o1[1] + o2[1])/2], [None, None]
    else:
        m = [(o1[0] + o2[0])/2, (o1[1] + o2[1])/2]
        v = [m[0] - o1[0], m[1] - o1[1]]
        v_abs = dist(v,[0,0])
        w = [v[1], -v[0]]
        w_abs = dist(w,[0,0])
        n = [w[0]/w_abs, w[1]/w_abs]
        l = math.sqrt(1 - v_abs**2)
        p1 = [m[0] + l*n[0], m[1] + l*n[1]]
        p2 = [m[0] - l*n[0], m[1] - l*n[1]]
    return p1, p2
err = 1.0e-6
while True:
    n = int(input())
    if n == 0:
        break
    p = []
    for i in range(n):
        p.append(list(map(float, input().split(","))))
    ans = 1
    for i in range(n - 1):
        for j in range(i + 1, n):
            p1, p2 = intersection(p[i], p[j])
            cnt1 = 0
            cnt2 = 0
            for k in range(n):
                if p1[0] and dist(p1, p[k]) <= 1 + err:
                    cnt1 += 1
                if p2[0] and dist(p2, p[k]) <= 1 + err:
                    cnt2 += 1
            ans = max([ans, cnt1, cnt2])
    print(ans)
from copy import copy
def gcd(a, b):
	if a%b == 0:
		return b
	else:
		return gcd(b, a%b)

n = int(input())
a = list(map(int, input().split()))

if n==2:
	print(max(a))
	quit()

gcds = []


for i in range(n):
	temp = copy(a)
	temp.pop(i)

	num1 = temp[0] 
	num2 = temp[1] 
	result = gcd(num1, num2) 
  
	for j in range(2, len(temp)): 
		if result in gcds:
			break
		result = gcd(result, temp[j]) 

	if result not in gcds:
		gcds.append(result)
      
if len(gcds)==1:
	print(gcds[0])
else:
	gcds = sorted(gcds)
	print(gcds[1])

### FIXED CODE ###

a, b, t = map(int, input().split())

num = t//a

print(b*num)
import math
A, B, C, D = map(int, input().split())
bc = B // C
bd = B // D
ac = (A - 1) // C
ad = (A - 1) // D
def lcm(C, D):
    return (C * D) // math.gcd(C, D)
bcd = B // lcm(C, D)
acd = (A - 1) // lcm(C, D)
a = bc - ac
b = bd - ad
c = bcd - acd
print((B + 1 - A) - (a + b - c))

### FIXED CODE ###

A, B, C, D = map(int, input().split())
bc = B // C
bd = B // D
ac = (A - 1) // C
ad = (A - 1) // D
def gcd(C, D):
    while D:
        C, D = D, C % D
    return C
def lcm(C, D):
    return C * D // gcd(C, D)
bcd = B // lcm(C, D)
acd = (A - 1) // lcm(C, D)
a = bc - ac
b = bd - ad
c = bcd - acd
print((B + 1 - A) - (a + b - c))
import subprocess
import os
import time


import sys
import math
from copy import deepcopy
from collections import deque, defaultdict
from operator import mul
from functools import reduce
sys.setrecursionlimit(20000000)

input = sys.stdin.readline


def find_n(x, y):
    moves = int((x+y)/3)
    for n in range(moves+1):
        if n + (moves-n)*2 == x and n*2 + (moves-n) == y:
            return n, moves-n


def cmb(n, m):
    return math.factorial(n+m) // (math.factorial(n+m - n) * math.factorial(n))


def main():
    x, y = map(int, input().split())

    if (x+y) % 3:
        print(0)
        sys.exit()

    n, m = find_n(x, y)

    ans = cmb(min([n, m]), max([n, m]))

    print(ans % (10**9 + 7))


if __name__ == '__main__':
    main()

### FIXED CODE ###

import subprocess
import os
import time


import sys
import math
from copy import deepcopy
from collections import deque, defaultdict
from operator import mul
from functools import reduce
sys.setrecursionlimit(20000000)

input = sys.stdin.readline


mod = 10**9+7
N = 10**6
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]


# def find_n(x, y):
#     moves = int((x+y)/3)
#     for n in range(moves+1):
#         if n + (moves-n)*2 == x and n*2 + (moves-n) == y:
#             return n % mod, (moves-n) % mod


# def cmb(n, r):
#     return math.factorial(n) % mod // ((math.factorial(r) % mod) * (math.factorial(n-r) % mod))


def cmb(n, r):
    if r < 0 or r > n:
        return 0
    r = min(r, n-r)

    return g1[n] * g2[r] * g2[n-r] % mod


def main():
    for i in range(2, N + 1):
        g1.append((g1[-1] * i) % mod)
        inverse.append((-inverse[mod % i] * (mod // i)) % mod)
        g2.append((g2[-1] * inverse[-1]) % mod)

    x, y = map(int, input().split())

    if (x+y) % 3:
        print(0)
        sys.exit()

    # n, m = find_n(x, y)

    n = int(((x*2 - y) // 3))
    m = int(((y*2 - x) // 3))

    ans = cmb(n+m, n)

    print(ans)


if __name__ == '__main__':
    main()
n,r = map(int, nput().split())
print(r if n>10 else r+100*(10-n))

### FIXED CODE ###

n,r = map(int, input().split())
print(r if n>10 else r+100*(10-n))
N = input()
input_data = [input() for i in range(N)]

#num = 0
#while input_data[num] > 0 :
#	print("Case","{0}:".format(num+1),"{1}".format(input_data[num]))
#	num+=1

### FIXED CODE ###

input_data = []
while 1:
	n = int(input())
	if n == 0:
		break
	input_data.append(n)
n=0
for i in input_data:
	print("Case {}:".format(n+1),"{}".format(input_data[n]))
	n+=1
N, M = map(int, raw_input().split())
a={}
b={}
for i in range(M):
    k,l=map(int, raw_input().split())
    if k==1:
        a.add(k)
    if l==N:
        b.add(l)
if a&b:
    print("POSSIBLE")
else:
    print("IMPOSSIBLE")

### FIXED CODE ###

N, M = map(int, input().split())
a=set()
b=set()
for i in range(M):
    k,l=map(int, input().split())
    if k==1:
        a.add(l)
    if l==N:
        b.add(k)
if a&b:
    print("POSSIBLE")
else:
    print("IMPOSSIBLE")
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

from itertools import accumulate


def factorial(x):
    if x == 0:
        return 1

    return factorial(x - 1) * x


def comb(n, r):
    return factorial(n) / factorial(r) / factorial(n - r)


def main():
    n = int(input())
    l = list(map(int, input().split()))

    nums = [0] * 1001

    for e in l:
        nums[e] += 1

    acm = list(accumulate(nums))

    l.sort()
    ans = 0
    tmp = [0] * 1001
    tmp2 = [0] * 1001
    for i in range(n-2):
        for j in range(i+1, n-1):
            a = l[i]
            b = l[j]
            k = min(1000, a+b-1)

            # b < c のときの数
            cnt = acm[k] - acm[b]

            # b == c のときの補正
            if nums[b] >= 3 and a == b and tmp[b] == 0:
                cnt += int(comb(nums[b], 3))
                tmp[b] = 1

            if nums[b] >= 2 and a != b and tmp2[b] == 0:
                cnt += int(comb(nums[b], 2))
                tmp2[b] = 1

            ans += cnt

    print(ans)


if __name__ == "__main__":
    main()


### FIXED CODE ###

import sys
input = sys.stdin.readline

from bisect import bisect_left


def main():
    n = int(input())
    l = list(map(int, input().split()))

    l.sort()

    ans = 0
    for i in range(n - 2):
        for j in range(i + 1, n - 1):
            a = l[i]
            b = l[j]
            mx = bisect_left(l, a + b)
            ans += mx - j - 1

    print(ans)


if __name__ == "__main__":
    main()
ccc=[list(map(int,input().split())) for i in range(2)]

for idx in range(2,n):
  if (ccc[1][idx-1] == ccc[1][idx]):
    continue
  elif (ccc[1][idx-1] - 1 == ccc[1][idx] ):
    ccc[1][idx] = ccc[1][idx-1]
    continue
  elif (ccc[1][idx-1] -1 > ccc[1][idx] ):
    print("No")
    break
    
  if (idx == n-1):
    print("Yes")
  

### FIXED CODE ###


ccc=[list(map(int,input().split())) for i in range(2)]


if ccc[0][0] == 1:
  print("Yes")
else:
  for idx in range(1,ccc[0][0]):
    if (ccc[1][idx-1] <= ccc[1][idx]):
      if (idx == ccc[0][0]-1):
        print("Yes")
      continue
    elif (ccc[1][idx-1]  == ccc[1][idx] + 1 ):
      ccc[1][idx] = ccc[1][idx-1]
      if (idx == ccc[0][0]-1):
        print("Yes")
      continue
    elif (ccc[1][idx-1] -1 > ccc[1][idx] ):
      print("No")
      break
# -*- coding: utf-8 -*-
import math

# 整数の入力
#a = int(input())
# スペース区切りの文字列の入力
st = input().split()
st_list = []
st_list = [int(st) for st in st]

# スペース区切りの数値の入力
a, b = map(int, input().split())

# 文字列の入力
s = input()

# スペース区切りの文字列の入力
#a,b = map(input().split())

if(str(s) == st_list[0]):
  a = a-1
elif(str(s) == st_list[1]):
  b = b-1
# 出力

print(a,b)



### FIXED CODE ###

# -*- coding: utf-8 -*-
#import math

# 整数の入力
#a = int(input())
# スペース区切りの文字列の入力
st = input().split()
st_list = []
st_list = [str(st) for st in st]

# スペース区切りの数値の入力
a, b = map(int, input().split())

# 文字列の入力
s = input()

# スペース区切りの文字列の入力
#a,b = map(input().split())

if(str(s) == st_list[0]):
  a = a-1
elif(str(s) == st_list[1]):
  b = b-1
# 出力

print(a,b)
def resolve():
    # 整数 1 つ
    s = input()
    # 整数複数個
    # a, b, c = list(map(int, input().split()))
    # 整数 N 個 (改行区切り)
    # N = [int(input()) for i in range(N)]
    # 整数 N 個 (スペース区切り)
    # N = list(map(int, input().split()))
    # 整数 (縦 H 横 W の行列)
    # A = [list(map(int, input().split())) for i in range(H)]

    alpha = string.ascii_lowercase
    A = [alpha[i] for i in range(len(alpha))]

    for x in A:
        if x not in s:
            print(x)
            break
        if x == "z":
            print("None")

resolve()

### FIXED CODE ###

import string

def resolve():
    # 整数 1 つ
    s = input()
    # 整数複数個
    # a, b, c = list(map(int, input().split()))
    # 整数 N 個 (改行区切り)
    # N = [int(input()) for i in range(N)]
    # 整数 N 個 (スペース区切り)
    # N = list(map(int, input().split()))
    # 整数 (縦 H 横 W の行列)
    # A = [list(map(int, input().split())) for i in range(H)]

    alpha = string.ascii_lowercase
    A = [alpha[i] for i in range(len(alpha))]

    for x in A:
        if x not in s:
            print(x)
            break
        if x == "z":
            print("None")

resolve()