peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
H=int(input())
W=int(input())
N=int(input())

import math
print(math.ceil(N/(max(H,W))))
# Judge status: Wrong Answer
N, M = map(int, input().split())

ans = 0
x = (M-2*N) // 4
r = min(10, M//2)
for i in range(max(0, x-r), x+r):
    tmp = min(N+i, (M-2*i)//2)
    ans = max(ans, tmp)

print(ans)
# Judge status: Accepted
# import bisect
# import copy
# import fractions
# import math
# import numpy as np
# from collections import Counter, deque
# from itertools import accumulate,permutations, combinations,combinations_with_replacement,product

def resolve():
    S=str(input())
    print('yes' if len(S)==len(set(S)) else 'no')

resolve()
# Judge status: Accepted
n,m = map(int,input().split())
n, m = min(n,m),max(n,m)

if n == 1 and m == 1:
    print(1)
elif n == 1:
    print(m-2)
elif n == 2:
    print(0)
else:
    print((n*m)-(2*n)-(2*m)+4)
# Judge status: Wrong Answer
print(['ABD', 'ABC'][int(input())//1000])
# Judge status: Accepted
n = int(input())
a = list(map(int, input().split()))

a.sort()

candi = a[-1]
middle = (candi - 1) / 2

tmp = float("inf")
ans = 0

for i in range(len(a) - 1):
    if tmp >= abs(a[i] - middle):
        tmp = abs(a[i] - middle)
        ans = i
print(candi, a[ans])
# Judge status: Accepted
N, M = list(map(int, input().split()))
if N % 2 == 1:
    for i in range(1, M+1):
        print(i, N-i+1)
else:
    for i in range(1, M+1):
        if i % 2 == 1:
            print(N//2+M//2  -i//2, N//2+ M//2  - i//2 + i)
        else:
            print(M//2 + 1 - i//2, M//2 + 1 - i//2 + i)
# Judge status: Accepted
n=int(input())
nums=list(map(int,input().split()))
cnt=0
flag=0
while flag is 0:
    for i in range(n):
        num=nums[0]/2
        key=nums[0]%2
        if key==1:
            flag=1
            break
        else:
            del nums[0]
            nums.append(num)
    if flag==0:
        cnt+=1

print(cnt)
# Judge status: Accepted
N, A, B = map(int, input().split())

if A > B:
    print(0)
    exit()
elif A == B:
    print(1)
    exit()
else:
    if N == 1:
        print(0)
        exit()

ans = (B * (N - 1) + A) - (A * (N - 1) + B) + 1
print(ans)
# Judge status: Accepted
n = int(input())
a = [int(i) for i in input().split()]
x, y = a[0], sum(a) - a[0]
r = abs(x-y)
for i in range(1, n-1):
    x += a[i]
    y -= a[i]
    r = min(r, abs(x-y))
print(r)
# Judge status: Accepted
def get_pair():
    return map(int, input().split())

cnt = 0
ans = "No"
for idx in range(int(input())):
    D1, D2 = get_pair()
    if D1 == D2:
        cnt += 1
    else:
        cnt = 0

    if cnt >= 3:
        ans = "Yes"
        break
print(ans)
# Judge status: Accepted
# -*- coding: utf-8 -*-
a, b, c, d = map(int, input().split())
print(max(a*c, a*d, b*c, b*d))
# Judge status: Accepted
A,B=map(int,input().split())
s=input()
S=[s[i] for i in range(len(s))]
N=A+B+1
c=0
num={str(i) for i in range(10)}
if S[A]=='-' and len(S)==N:
  c=1
  S.pop(A)
  for i in range(N-1):
    if 1-(S[i] in num):
      c=0
if c==1:
  print('Yes')
else:
  print('No')
# Judge status: Wrong Answer
n=int(input())
l=[*map(int,input().split())]
c=0
for e,i in enumerate(l):
  if i<0:
    c+=1
    l[e]=-i
print(sum(l)-[0,min(l)*2][i%2 and l.count(0)>0])
# Judge status: Accepted
import sys
input = sys.stdin.readline
n,w = map(int,input().split())
wv = [tuple(map(int,input().split())) for i in range(n)]

dp = [0]*(w+1)
for i in range(n):
    for j in range(w,wv[i][0]-1,-1):
        dp[j] = max(dp[j],dp[j-wv[i][0]]+wv[i][1])

print(max(dp))
# Judge status: Accepted
#template
from collections import Counter
def inputlist(): return [int(j) for j in input().split()]
#template
N,A,B = inputlist()
if A>B:
    print(0)
    exit()
ans = (B-A)*(N-2) +1
if ans <=0:
    ans = 0
print(ans)
# Judge status: Accepted
n = int(input())
s = input()

black = []
white = []

cb=0
cw=0
for l in s:
    if l =="#":
        cb+=1
    else:
        cw+=1
    black.append(cb)
    white.append(cw)

if n == 1:
    print(0)
else:
    ans = [white[-1],black[-1]]
    for i in range(n):
        ans.append(black[i-1]+white[-1]-white[i-1])
    print(min(ans))
# Judge status: Accepted
from math import ceil

S = int(input())
ax, ay = 10 ** 9 , 1
by = ceil(S / 10 ** 9)
bx = 10 ** 9 * by - S
print(0, 0, ax, ay, bx, by)
# Judge status: Accepted
n = int(input())
pares=0
for i in range(1, n):
    for j in range(0, n-i):
        if((i%2==0 and (n-j)%2!=0) or (i%2!=0 and (n-j)%2==0)):
            pares+=1
print(pares)
# Judge status: Accepted
N, M = map(int, input().split())
x = sorted(list(map(int, input().split())))
dis = sorted([x[i] - x[i-1] for i in range(1, M)])
if N < M:
    print(sum(dis[:M-N]))
else:
    print(0)
# Judge status: Wrong Answer
mod=10**9+7
def Ch(n,r):
  res=1
  for i in range (n,n-r,-1):
    res*=(i%mod)
    res%=mod
  return res

n=int(input())
ans=0
for zero in range(1,9):
  for nine in range(1,10-zero):
    ans+=((Ch(n,zero)*Ch(n-zero,nine))%mod)*(8**(n-zero-nine)%mod)
    ans%=mod
# Judge status: Accepted
s=input()
if s=='SUN':
    print(7)
elif s=='MON':
    print(6)
elif s=='TUE':
    print(5)
elif s=='WED':
    print(4)
elif s=='THU':
    print(3)
elif s=='FRI':
    print(2)
elif s=='SAT':
    print(1)
# Judge status: Accepted
#ABC111

n = int(input())

for i in range(10):
    if i * 111 < n <= (i+1)*111:
        print((i+1)*111)
        break
# Judge status: Wrong Answer
n = int(input())
print(-(-n//2)*((n+1)//2))
# Judge status: Accepted
N = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))

result = False

big_a = sum([ai - bi for ai, bi in zip(a,b) if ai > bi])
big_b = sum([(bi - ai) // 2 for ai, bi in zip(a,b) if bi > ai])
sum_diff = sum(b) - sum(a)

if big_a <= big_b:
  result = True

ans = "Yes" if result else "No"
print(ans)
# Judge status: Accepted
N = int(input())

can = True
for i in range(N):
    t, x, y = list(map(int, input().split()))
    
    if not t%2 == (x+y)%2 or (x+y) > t:
        can = False
        break
        
if can:
    s = "Yes"
else:
    s = "No"
print(s)
# Judge status: Accepted
s,w=map(int,input().split())
if w>=s:
  ans='unsafe'
else:
  ans='safe'
print(ans)
# Judge status: Accepted
#133_C
l,r=map(int,input().split())

if r//2019>l//2019: print(0)
else:
    r%=2019
    l%=2019
    ans=2019
    for i in range(l,r+1):
        for j in range(i+1,r+1):
            ans=min(ans,(i*j)%2019)
    print(ans)
# Judge status: Accepted
N,M = map(int,input().split())
sc = [list(map(int,input().split())) for _ in range(M)]
i = 0

while len(str(i))<=N:
  k = 0
  if len(str(i))!=N:
    i += 1
    continue
  for el in sc:
    if str(i)[el[0]-1] == str(el[1]):
      k += 1
  if k == M:
    print(i)
    exit()
  i += 1
  
print(-1)
# Judge status: Accepted
n,k,q=list(map(int,input().split()))
wins=[0]*n
for i in range(q):
  a=int(input())
  wins[a-1]+=1
#print(wins)

for w in wins:
  if k-(q-w)>0:
    print('Yes')
  else:
    print('No')
# Judge status: Wrong Answer
import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)

W, H, x, y = rl()

area = (H*W)/2.0
flag = 0
if x*2 == W or y*2 == H:
	flag = 1
print(area, flag)
# Judge status: Accepted
def INT():
    return int(input())

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

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

from collections import Counter
import sys

N = INT()
A = LI()
count_A = Counter(A)
ans = 0

if sum([c > 1 for c in count_A.values()]) <= 1:
    print(ans)
    sys.exit()
    
count_st = []

for k, v in count_A.items():
    if v == 1:
        continue
    
    count_st.append(k)
    
    if v >= 4:
        count_st.append(k)
    
count_st.sort(reverse = True)
ans = count_st[0] * count_st[1]
print(ans)
# Judge status: Accepted
from fractions import gcd
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))

def lcm(values):
    ans = values[0]
    for i in range(1, len(values)):
        ans = ans * values[i] // gcd(ans, values[i])
    return ans

def count_div2(value):
    count = 0
    while value % 2 == 0:
        count += 1
        value //= 2
    return count

min_value = lcm(A)
amount = M * 2 // min_value

div2 = count_div2(A[0])
if any([count_div2(a) != div2 for a in A]):
    print(0)
else:
    print((amount + 1) // 2)
# Judge status: Wrong Answer
a,b,c=map(int,input().split())

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

ans = 'Yes' if c % gcd(a,b) == 0 else 'No'
print(ans)
# Judge status: Accepted
n,m=map(int,input().split())
if n%2==1:
    x=""
    for i in range(m):
        x+=f"{i+1} {n-i} "
    print(x)
else:
    x=""
    for i in range(m):
        x+=(f"{i+1} {n-i} " if i<m/2 else f"{i+1} {n-i-1}\n")
    print(x)
# Judge status: Accepted
x,y,a,b,c= list(map(int, input().split()))
p= list(map(int, input().split()))
q= list(map(int, input().split()))
r= list(map(int, input().split()))
p.sort(reverse=True)
q.sort(reverse=True)
r.sort(reverse=True)
np=p[0:x]
nq=q[0:y]
np.extend(nq)
m=min(np)
nr=[i for i in r if i>=m]
np.extend(nr)
np.sort(reverse=True)
print(sum(np[0:x+y]))
# Judge status: Accepted
L,R,d = list(map(int, input().split()))
ans = 0
for i in range(L,R+1):
    if i % d == 0 :
        ans += 1
print(ans)
# Judge status: Wrong Answer
N,X = map(int,input().split())
W = list(map(int,input().split())) + [X]
W = sorted(W)

print(W[1]-W[0])
# Judge status: Wrong Answer
import math

i = list(map(int, input().split()))
a = i[0]
b = i[1]
c = i[2]

left = a + b + math.sqrt(a*b)
right = c
if (left < right):
    print ('Yes')
else:
    print ('No')
# Judge status: Accepted
L,R,d = map(int,input().split())
ans=0
for i in range(L,R+1):
    if i%d==0:
        ans+=1
print(ans)
# Judge status: Wrong Answer
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N, *XY = map(int, read().split())

    P = [x + y for x, y in zip(*[iter(XY)] * 2)]
    mi = min(P)
    ma = max(P)

    print(abs(mi - ma))

    return


if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
n, k = map(int, input().split())
p = list(map(int, input().split()))
exp = 0
for i in range(n - k + 1):
    s = 0
    for j in range(k):
        s += p[i+j]
    if exp <= s:
        exp = s
print((s + 3) / 2)
# Judge status: Accepted
n = int(input())
a = 1
s = list(map(int, input().split()))
if 0 in s:
    print(0)
    exit()
for i in s:
    a*=i
    if a>10**18:
        print(-1)
        exit()
else:
    print(a)
# Judge status: Accepted
N = int(input())
t_x_y = [list(map(int, input().split())) for _ in range(N)]
t_x_y.insert(0, [0, 0, 0])

ans = 'Yes'
for i in range(N):
  dt = t_x_y[i+1][0] - t_x_y[i][0]
  dist = abs(t_x_y[i+1][1] - t_x_y[i][1]) + abs(t_x_y[i+1][2] - t_x_y[i][2])
  
  if dt < dist:
    ans = 'No'
    break
  else:
    # dt >= dist
    if (dt - dist) % 2 != 0:
      ans = 'No'
      break
  
print(ans)
# Judge status: Wrong Answer
N = int(input())
ST = []
for i in range(N):
    x, l = list(map(int, input().split()))
    ST.append([x-l+1, x+l-1])
ST.sort(key = lambda x :x[1])
startT = ST[0][1]
ans = 1
for i in range(1,N):
    if startT >= ST[i][0]:
        continue
    else:
        startT = ST[i][1]
        ans += 1
print(ans)
# Judge status: Accepted

def main():
    n = int(input())
    a = list(map(int, input().split(" ")))
    all = 0
    for ele in a:
        all ^= ele
    for ele in a:
        print(all ^ ele,end = " ")
    print()



if __name__ == "__main__":
    main()
# Judge status: Accepted
n=int(input())
if n in [1,2,3,5,6,9,10,13,17,24]:
  print('No')
else:
  print('Yes')
# Judge status: Wrong Answer
s = input()
s_num = int(s)
len_s = len(s)
list=[0 for x in range(len_s+1)]
for i in range(len_s-1,-1,-1):
    for j in range(4,min(9,len_s-i+1)):
        if int(s[i:i+j])%2019==0:
            list[i]=list[i+j]+1
            break
print(sum(list))
# Judge status: Accepted
s = input()
t = input()
print('Yes' if len(s) + 1 == len(t) and s == t[:-1] else 'No')
# Judge status: Accepted
n = int(input())
p = list(map(int, input().split()))
q = list(map(int, input().split()))

import itertools

a = [i for i in range(1, n + 1)]

cnt = 0
t = []
for i in itertools.permutations(a, n):
    cnt += 1
    if list(i) == p:
        t.append(cnt)
    if list(i) == q:
        t.append(cnt)
print(abs(t[0] - t[1]))
# Judge status: Accepted
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
sys.setrecursionlimit(10**7)

def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())

def main():
    N,K = LI()
    H = sorted(LI(),reverse=True)
    H_removed = H[K:]
    print(sum(H_removed))


main()
# Judge status: Accepted
Q,H,S,D = map(int,input().split())
N = int(input())
cnt = (N//2)*min(8*Q,4*H,2*S,D)
if N%2==1:
    cnt += min(4*Q,2*H,S)
print(cnt)
# Judge status: Accepted
def resolve():
    sx, sy, tx, ty = [int(i) for i in input().split()]
    x = tx - sx
    y = ty - sy
    print("U" * y, "R" * x, sep="", end="")
    print("D" * y, "L" * x, sep="", end="")
    print("L", "U" * y, "U", "R" * x, "RD", sep="", end="")
    print("R", "D" * y, "DL", "L" * x, "U", sep="", end="")
    print()

resolve()
# Judge status: Accepted
a, b, c = map(int, input().split())
c -= a + b
ok = True
if c * c <= 4 * a * b:
	ok = False
if c <= 0:
	ok = False
if ok:
	print("Yes\n")
else:
	print("No\n")
# Judge status: Accepted
N=int(input())
A=list(map(int,input().split()))

for i in range(N):
	if A[i]%4==0:
		A[i]=4
	elif A[i]%4!=0 and A[i]%2==0:
		A[i]=2
	else:
		A[i]=1
if A.count(2)==0:
	if A.count(4)+1<A.count(1):
		print("No")
	else:
		print("Yes")
else:
	if A.count(4)<A.count(1):
		print("No")
	else:
		print("Yes")
# Judge status: Wrong Answer
s=input()
t=input()
l=len(s)
m=len(t)
flag=0
for i in range(0,l):
    if s[i]==t[i]:
        flag=1
    else:
        break
if flag==1:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
#n = int(input())
#L = list(map(int, input().split()))
x, k, d = map(int, input().split())
#p = list(set(L))
a = abs(x)//d
b = abs(x)%d
if k < a:
  print(abs(x) - d*k)
else:
  if (k-a)%2 == 0:
    print(b)
  else:
    print(d-b)
# Judge status: Wrong Answer
N = int(input())
S = []
for _ in range(N):
    S.append(input()) 
a = S.count('AC')
b = S.count('WA')
c = S.count('TLE')
d = S.count('RE')
print ('AC ×' +' ' + str(a))
print('WA ×' + ' '+ str(b))
print('TLE ×' +' ' + str(c))
print('RE ×' +' '+ str(d))
# Judge status: Accepted
n,m=map(int,input().split())
cnt=0
lst=sorted([list(map(int,input().split())) for _ in range(n)])
#print(lst)
i=0
while cnt<m:
    cnt+=lst[i][1]
    if cnt<m:
        i+=1
print(lst[i][0])
# Judge status: Wrong Answer
N,A,B=map(int,input().split())

if A%2==B%2:
    print(int((B-A)/2))
else:
    print(min(A-1,N-B)+1+int((B-A-1)/2))
# Judge status: Wrong Answer
import fractions
a,b,c,d = map(int,input().split())
e,f,g,h,i,j = b//c,b//d,(a-1)//c,(a-1)//d,b//((c*d)/fractions.gcd(c,d)),(a-1)//((c*d)/fractions.gcd(c,d))
print(int(b-(e+f-i)-(a-1-(g+h-j))))
# Judge status: Accepted
N = int(input())

freebies_list = [input() for i in range(N)]
freebies_set = set(freebies_list)

print(len(freebies_set))
# Judge status: Accepted
def solve():
    n, m = map(int, input().split())

    if 2*n <= m:
        return n + (m-2*n)//4
    else:
        return m//2

    

print(solve())
# Judge status: Accepted
INF = 300

n = int(input())
a = [INF] + list(map(int, input().split())) + [-INF]

money = 1000
stock = 0
for e1, e2 in zip(a, a[1:]):
    if e1 < e2:
        buy = money // e1
        money -= buy * e1
        stock += buy
    else:
        money += stock * e1
        stock = 0

print(money)
# Judge status: Wrong Answer
N = int(input())
A = []
for i in range(N):
    A.append(int(input()))
A.sort()
A.reverse()
for i in range(N):
    if A[i]==A[0]:
        print(A[1])
    else:
        print(A[0])
# Judge status: Accepted
n = int(input())
ans = True
for i in range(n):
    t,x,y = map(int,input().split())
    if (x+y)%2 != t%2:
        ans = False
    if x+y>t:
        ans = False
 
if ans:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
s = input()
k = 'keyence'
r = 'NO'
for i in range(len(k)):
    if s[:i] + s[-7+i:] == k:
        r = 'YES'
        break
print(r)
# Judge status: Accepted
n = int(input())
p = list(map(int,input().split()))
ans = 0

for i in range(1,n - 1):
    if p[i - 1] <= p[i] <= p[i + 1] or p[i + 1] <= p[i] <= p[i - 1]:
        ans += 1
print(ans)
# Judge status: Wrong Answer
# yorikatu_58_b.py
def summlize(C,i):
    ans = C[i]
    if i > 1:
       ans += C[i-1]
    if i < len(C):
        ans += C[i+1]
    return ans

N = int(input())
A = list(map(int,input().split()))
import collections
C = collections.Counter(A)

ans = 0
for i in range(100005):
    sums = summlize(C,i)
    if ans < sums:
        ans = sums
print(ans)
# Judge status: Accepted
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
ans=0
for i in range(n):
  if a[i]>=b[i]:
    ans=ans+b[i]
  elif a[i]+a[i+1]>=b[i]:
    ans=ans+b[i]
    a[i+1]=a[i+1]-b[i]+a[i]
  else:
    ans=ans+a[i]+a[i+1]
    a[i+1]=0
print(ans)
# Judge status: Accepted
a=int(input())
b=int(input())
c=int(input())
x=int(input())
ans=0
for i in range(a+1):
    for j in range(b+1):
        for h in range(c+1):
            if 500*i+100*j+50*h==x:
                ans+=1
print(ans)
# Judge status: Accepted
A,B = map(int,input().split())
ans = (A+B)%24

print(ans)
# Judge status: Wrong Answer
n = int(input())
a = [input() for i in range(n)]
b = list(set(a))
b.sort()

max = a.count(b[0])

for i in range(len(b)-1):
	if a.count(b[i]) < a.count(b[i+1]):
		max = a.count(b[i+1])

for j in range(len(b)):
	if a.count(b[j]) == max:
		print(b[j])
# Judge status: Accepted
n = int(input())
d = list(map(int, input().split()))
d.sort()
num = 0
n3 = n//2
n2 = n3-1
if d[n2] == d[n3]:
    print(0)
else:
    for i in range(d[n2],d[n3]):
        num += 1
    print(num)
# Judge status: Accepted
n,k = map(int,input().split())
answer = 0
if k >= n:
  gap = k-n
  if gap > n:
    answer = n
  else:
    answer = gap
else:
  sho = n // k
  if n % k == 0:
    dec = sho - 1
  else:
    dec = sho
  n = n - k*dec
  if k >= n:
    gap = k-n
    if gap > n:
      answer = n
    else:
      answer = gap
print(answer)
# Judge status: Wrong Answer
s = list(input())
t = list(input())

s_a = ''.join(sorted(s))
t_a = ''.join(sorted(t, reverse=True))

print(s_a, t_a)

if s_a < t_a :
    print('Yes')
else :
    print('No')
# Judge status: Accepted
n = int(input())
p = list(map(int, input().split()))
p_min = p[0]
ans = 1
for i in range(1, n):
    if p[i] <= p_min:
        ans += 1
        p_min = p[i]
print(ans)
# Judge status: Wrong Answer
#!/usr/bin/env python3

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

x = I()
y = x % 11
ans = (x // 11) * 2
if y <= 6:
    ans += 1
else:
    ans += 2
print(ans)
# Judge status: Accepted
N, x = map(int, input().split())
a = list(map(int, input().split()))

ans = 0
keep = a[0]
for i in range(1, N):
    if (keep + a[i]) > x:
        ans = ans + (keep + a[i] - x)
        keep = max(x - keep, 0)
    else:
        keep = a[i]


print(ans)
# Judge status: Accepted
s=['2019/04/30']
s.append(input())
s.sort()
if s[0]=='2019/04/30':
    if s[1]=='2019/04/30':
        print('Heisei')
    else:
        print('TBD')
else:
    print('Heisei')
# Judge status: Accepted
n = int(input())
h = list(map(int, input().split()))

ans = "Yes"
m = h[0]

for i in range(1, n):
    m = max(m, h[i])
    if h[i] < m - 1:
        ans = "No"

print(ans)
# Judge status: Wrong Answer
data=list(input())
c=0
for i in range(0,len(data)-1):
    for j in range(i+1,len(data)):
        if data[i]==data[j]:
            c=c+1
if c==0:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
n = int(input())
m=n
lst=[]
while True:
  if m in lst:
    print(len(lst)+1)
    break;
  else:
    lst.append(m)
    if m%2==0:
      m=m//2
    else:
      m=3*m+1
# Judge status: Wrong Answer
from collections import Counter
s = input()
t = input()
s_cnt = sorted(Counter(s).values(), reverse=True)
t_cnt = sorted(Counter(t).values(), reverse=True)
print(s_cnt)
print(t_cnt)
if s_cnt == t_cnt:
    print('Yes')
else:
    print('No')
# Judge status: Wrong Answer
X=int(input())
if X==7 or X==5 or X==3:
  print("Yes")
else:
  print("No")
# Judge status: Wrong Answer
a, b, c = map(int, input().split())
print(min(c, a // b))
# Judge status: Accepted
X,Y,A,B,C=map(int,input().split())
p=sorted(map(int,input().split()),reverse=True)
q=sorted(map(int,input().split()),reverse=True)
r=sorted(map(int,input().split()),reverse=True)
li=[]
for i in range(X):
    li.append(p[i])
for i in range(Y):
    li.append(q[i])
n=0
res=sum(li)
li=sorted(li)
for i in range(len(li)):
    if(li[i]<r[n]):
        res+=(r[n]-li[i])
        n+=1
    else:
        break
    if(n==len(r)):
        break
print(res)
# Judge status: Accepted
import sys
N = sys.stdin.readline()
Alst = list(map(int, sys.stdin.readline().split()))
now = 1
x = 0
for i in Alst:
    if now < i:
        now = i
    else:
        x += (now - i)

print(x)
# Judge status: Accepted
n,m = map(int,input().split())
a = [int(input()) for _ in range(m)]

p = 10**9 +7
ans = [0]*(n+1)
ans[0] = 1
ans[1] = 1

broken = [0]*(n+1)
for i in a:
    broken[i]= -1

for i in range(1,n):
    if broken[i] == -1:
        ans[i] = 0
        ans[i+1] = ans[i-1]%p
    else:
        ans[i+1] = (ans[i-1] + ans[i])%p

print(ans[-1])
# Judge status: Accepted
# -*- coding: utf-8 -*-
import math

numList = []
result = []

user2 = list(map(int, input().split()))


numList.append(user2[0] * user2[2] )
numList.append(user2[0] * user2[3]) 
numList.append(user2[1] * user2[2]  )
numList.append (user2[1] * user2[3])

numList.sort()

print(numList[3])
# Judge status: Wrong Answer
c_list = list(input())
flag = True

for i in range(len(c_list)):
 if(c_list.count(c_list[i])%2 == 1):
  print("NO")
  flag = False
  break

if(flag):
 print("YES")
# Judge status: Accepted
import sys
input = sys.stdin.readline

from collections import deque
N,Q = (int(x) for x in input().split())
S = list(input())
d = deque(S)
cum = [0] * N
count = 0
t1 = d.popleft()
for i in range(1,N):
    t2 = d.popleft()
    if t1 == 'A' and t2 == 'C':
        count += 1
    cum[i] = count
    t1 = t2
for i in range(Q):
    l,r = (int(x) for x in input().split())
    print(cum[r-1]-cum[l-1])
# Judge status: Accepted
x,y=map(int,input().split())
ans=0
while x<=y:x*=2;ans+=1
print(ans)
# Judge status: Accepted
N,W = map(int,input().split())
dp = [[0 for j in range(W+1)] for i in range(N+1)]
for i in range(1,N+1):
    w,v = map(int,input().split())
    for j in range(W+1):
        if j >= w:
            dp[i][j] = max(dp[i-1][j], dp[i-1][j-w]+v)
        else:
            dp[i][j] = dp[i-1][j]
print(dp[N][W])
# Judge status: Wrong Answer
n=int(input())
s=[input() for _ in range(n)]
m=int(input())
t=[input() for _ in range(m)]
print(max([s.count(s[i]) - t.count(s[i]) for i in range(len(s))]))
# Judge status: Accepted
n=int(input())
s=input()
l=''
c=0
d=0
for i in range(n):
  if s[i]=='(':
    c+=1
  else:
    if c>0:
      c-=1
    else:
      l+='('
print(l+s+')'*c)
# Judge status: Accepted
#1000 8
#1 3 4 5 6 7 8 9
n,k = map(int, raw_input().split())
s = set(map(int, raw_input().split()))
letters = [u for u in range(10) if u not in s]
def dfs(u,n,letters):
	if u >= n:
		return u
	return min([dfs(u*10 +l,n,letters) for l in letters if u or l])

print dfs(0,n,letters)