peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
x = int(input())
y = int(input())
z = int(input())

a = max(x,y)
if z%a == 0:
  print(z//a)
else:
  print(z//a+1)
# Judge status: Accepted
s = sorted(list(input()))
t = list(input())
t.sort(reverse = True)
s += "".join(s)
t += "".join(t)
if s < t:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
import math
A,B,H,M=map(int,input().split())
C2=A**2+B**2-2*A*B*math.cos((30*H-11*M/2)/180*math.pi)
print(C2**(1/2))
# Judge status: Accepted
n,m = map(int,input().split())
if(n % 2 == 0):
    d = n // 2 - 1
    c = 0
    i = 1
    while(d > 0):
        print(i,i+d)
        d -= 2
        i += 1
        c += 1
        if(c == m):exit()
    d = n // 2 - 2
    i = n // 2 + 1
    while(d > 0):
        print(i,i+d)
        d -= 2
        i += 1
        c += 1
        if(c == m):exit()


else:
    for i in range(m):
        print(i+1,n-i)
# Judge status: Accepted
import sys
sys.setrecursionlimit(1000000000)
import math
from fractions import gcd
from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok
#

def main():
    H,A=mis()
    print(math.ceil(H/A))


main()
# Judge status: Accepted
import math

N = int(input())
ans = (math.ceil(N/2))/N
print(ans)
# Judge status: Accepted
blue={}
red={}
n=int(input())
for i in range(n):
    s=input()
    blue[s]=blue.get(s,0)+1
m=int(input())
for i in range(m):
    t=input()
    red[t]=red.get(t,0)+1

mx=0
for k,v in blue.items():
    mx=max(mx,blue[k]-red.get(k,0))
print(mx)
# Judge status: Wrong Answer
W,a,b =map(int,input().split())
if b-(a+W)<0:
    print(0)

elif b<a:
    print(a-(b+W))
else:
    print(b-(a+W))
# Judge status: Accepted
n,m = map(int, input().split())
h = list(map(int, input().split()))

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

ans = 0
for i in range(n):
  if ab[i] < h[i]:
    ans += 1
print(ans)
# Judge status: Accepted
x,y=map(int,input().split())
print(int(x+y/2))
# Judge status: Wrong Answer
a, b = map(int, input().split())
if 1 <= a <= 9 and 1 <= a <= 9:
    print(a*b)
else:
    print(-1)
# Judge status: Accepted
a, b, c, d, e = map(int, input().split())
x = [a, b, c, d, e]

print(x.index(0) + 1)
# Judge status: Accepted
a,b=map(int,input().split())
print(str(a)*b if a<=b else str(b)*a)
# Judge status: Accepted
n = int(input())
a = [int(input()) for _ in range(n)]
aa = sorted(a)[:n-1]
maxa = max(a)
b = a.index(maxa)
for i in range(n):
	if i == b:
		print(max(aa))
	else:
		print(maxa)
# Judge status: Accepted
s, t = input().split()

print(t,s,sep='')
# Judge status: Wrong Answer
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

n = ii()
A = iil()
B = iil()
ans = 0
sB = sum(B)
for i in range(n):
    ans = max(sum(A[:i])-sum(B[:i-1])+sB,ans)
print(ans)
# Judge status: Accepted
s = input()
cnt = 0

if 'RRR' in s:
    print(3)
    exit()
if 'RR' in s:
    print(2)
    exit()
if 'R' in s:
    print(1)
    exit()

print(0)
# Judge status: Accepted
#!/usr/bin/env python3

N = int(input())

Ret = [0 for _ in range(10**5)]

for i in range(1, 101):
    for j in range(1, 101):
        for k in range(1, 101):
            r = i**2 + j**2 + k**2 + i*j + j*k + i*k
            Ret[r] += 1

for r in Ret[1:N+1]:
    print(r)
# Judge status: Accepted
in_string = input()
in_arr = in_string.split()
N = int(in_arr[0])
A = int(in_arr[1])
B = int(in_arr[2])

if ((B-A) % 2) == 0:
    print(int((B-A)//2))
else:
    if (N-B) > A-1:
        print(int(A+(B-A-1)//2))
    else:
        print(int(N-B+1+((N-(A+N-B+1))//2)))
# Judge status: Accepted
import numpy as np

N = int(input())
#N,K,d= map(int,input().split())
#A = list(map(int,input().split()))
#S = str(input())
#T = str(input())

num=np.zeros(10**4+1)
for x in range(1,100):
    for y in range(1,100):
        for z in range(1,100):
            ans = x**2 + y**2 + z**2 + x*y + y*z + z*x
            if ans < 10**4+1:
                num[ans]+=1


for i in range(N):
    print(int(num[i+1]))
# Judge status: Accepted
N = int(input())
print(1 - (N//2) / N)
# Judge status: Accepted

n,m = map(int,input().split())

s_L = []

for i in range(m):
    L = list(map(int,input().split()))
    a = min(L)
    b = max(L)

    if a == 1:
        s_L.append(b)
    elif b == n:
        s_L.append(a)

#print(s_L)
if len(set(s_L)) == len(s_L):
    print("IMPOSSIBLE")
else:
    print("POSSIBLE")
# Judge status: Wrong Answer
from collections import Counter
N,K=map(int,input().split())
A=Counter(list(map(int,input().split())) )
print(sum(sorted(A.keys(), reverse=True)[K:]))
# Judge status: Wrong Answer
a = int(input())
ans = (a + (a**2) + (a**3))
# Judge status: Accepted
N, M = map(int, input().split())
PYi = [list(map(int, input().split()))+[i] for i in range(M)]
PYi.sort()
ans = ['']*M
counter = {}

for v in PYi:
    P, Y, i = v

    if not P in counter:
        counter[P] = 1
    else:
        counter[P] += 1

    tmp = ''
    tmp += str(P).zfill(6)
    tmp += str(counter[P]).zfill(6)
    ans[i] = tmp

for v in ans:
    print(v)
# Judge status: Accepted
N, M = map(int, input().split())

x = {i + 1 for i in range(M)}
for _ in range(N):
    x &= set(list(map(int, input().split()))[1:])
print(len(x))
# Judge status: Accepted
n = int(input())
a = list(map(int, input().split()))
ans = 1
a.sort()
for i in range(n):
  ans *= a[i]
  if ans > 10**18:
    print(-1)
    exit()
print(ans)
# Judge status: Wrong Answer
N,K= map(int, input().split())
A = list(map(int,input().split()))
if(A[0] == 1):
    print(1)
    exit(0)
p = 1
P = []
start,stop = 0, 0
for i in range(N):
    p = A[p-1]
    if p in P:
        start = P.index(p)
        break
    P.append(p)
stop = len(P)-1
if len(P) == K:
    print(B[-1])
else:
    del P[0:start]
    Z = (K-start-1)%((stop-start+1))
    print(P[Z])
# Judge status: Accepted
p,r,q = map(int,input().split())

ans = []

ans.append(p+r)
ans.append(q+r)
ans.append(p+q)

print(min(ans))
# Judge status: Accepted
a,b,x = list(map(int, input().split()))
print(b//x - (a-1)//x)
# Judge status: Accepted
n = int(input())
L = [input() for i in range(n)]

LL = set(L)
if len(LL) != n:
    print('No')
    exit()
    
for i in range(n-1):
    if L[i][-1] != L[i+1][0]:
        print('No')
        exit()
else:
    print('Yes')
# Judge status: Wrong Answer
input()
S=input()
s=set(S)
a=1
for c in s:a*=(S.count(c)+1)%(10**9+7)
print(a-1)
# Judge status: Wrong Answer
n, k = map(int, input().split())

MOD = 10**9+7

dp = [0] * (n+1)

dp[1] = n+1

for i in range(2, n+1):
    dp[i] = dp[i-1] * (n + 1 - (i-1)) // i

print(sum(dp[k:]) % MOD)
# Judge status: Wrong Answer
def main():
  K,N = map(int, input().split())
  A_list = list(map(int, input().split()))

  space_max = 0

  if A_list[N-1] - A_list[0] <= K/2:
    print(A_list[N-1] - A_list[0])
    exit()
  else:
    pass

  for i in range(N-1):
    space =  A_list[i+1] - A_list[i]
    if space > space_max:
      space_max = space
    else:
      pass
  
  print(K-space_max)


if __name__ == "__main__":
  main()
# Judge status: Accepted
N, M = map(int, input().split())
G = [[] for _ in range(N)]
res = [10 ** 12] * M
for i in range(M):
    p, y = map(int, input().split())
    G[p - 1].append((y, i))

G = list(map(sorted, G))
for p in range(N):
    for m, (y, i) in enumerate(G[p], 1):
        res[i] += (p + 1) * 10 ** 6 + m

for r in res:
    print(str(r)[1:])
# Judge status: Wrong Answer
import sys
A,B,N=map(int,input().split())
X=B-1
X=max(B-1,N)
ans=(A*X)//B-A*(X//B)
print(ans)
# Judge status: Accepted
import math
h, w = [int(w) for w in input().split()]

if h == 1 or w == 1:
    print(1)
else:
    print(math.ceil(h * w / 2))
# Judge status: Accepted
n = int(input())

def dig(num):
    ans = 0
    while num>0:
        ans += num%10
        num//=10
    return ans

mi = float('inf')
for i in range(1,n//2+1):
    a = dig(i)+dig(n-i)
    mi = min(a,mi)
print(mi)
# Judge status: Wrong Answer
n=int(input())
listA=list(map(int,input().split()))
listB=[0]

for i in range(len(listA)-1):
  if listA[i+1]>listA[i]:
    listB.append(listA[i+1]-listA[i])

print(sum(listB))
# Judge status: Accepted
a, b = map(int, input().split())
if a>=b:
    c = a
    a -= 1
else :
    c = b
    b -= 1
if a>b :
    d = a
    a -= 1
else :
    d = b
    b -= 1
print(c + d)
# Judge status: Accepted
def resolve():
    N = int(input())
    a = list(map(int, input().split()))
    Alice = sorted(a)[::2]
    Bob = sorted(a)[1::2]
    print(abs(sum(Alice)-sum(Bob)))
resolve()
# Judge status: Accepted
q,h,s,d = map(int,input().split())
n = int(input())
h = min(h, 2*q)
s = min(s, 2*h)
d = min(d, 2*s)
res = d*(n//2)
res += s if n%2!=0 else 0
print(res)
# Judge status: Accepted
import sys

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


def resolve():
    S = input()
    T = input()
    res = 0
    for s, t in zip(S, T):
        if s != t:
            res += 1
    print(res)


if __name__ == '__main__':
    resolve()
# Judge status: Wrong Answer
s = []
s.append(input())
Q = int(input())
cnt = 0
for _ in range(Q):
    tmp = input().split()
    if tmp[0] == '1':
        cnt += 1
        continue
    else:
        if cnt % 2:
            pass
        else:
            s.reverse()
        if tmp[2] == 1:
            s.insert(0, tmp[2])
        else:
            s.append(tmp[2])
if cnt % 2:
    pass
else:
    s.reverse()
print(''.join(s))
# Judge status: Wrong Answer
n=int(input())
ro=n**0.5
# print( ro )

maxi=1
for i in range(2, int(ro)):
    if n%i==0:
        maxi=i

print( maxi-1+n//maxi-1)
# Judge status: Wrong Answer
N = int(input())
List = list(map(int, input().split()))
print("Yes" if max(List) <= sum(List)-max(List) else "No")
# Judge status: Accepted
w = list(input())
import collections
c = collections.Counter(w)
li = list(c.values())
ans = "Yes"
for i in range(len(li)) :
    if li[i] % 2 == 1 :
        ans = "No"
        break
print(ans)
# Judge status: Wrong Answer
l, r = map(int, input().split())

if (r % 2019 == 0) or (l % 2019 == 0) or (r-l >= 2019):
    print('1')
else:
    min_num = 2020
    for left in range(l, r):
        for right in range(left+1, r+1):
            mod = (left * right) % 2019
            min_num = min(min_num, mod)
    print(min_num)
# Judge status: Accepted
#!/usr/bin/env python3
a, b, c = map(int, input().split())
o = 0
if a == b == c:print(a%2-1);exit() 
while 1-any([a%2, b%2, c%2]):
    a, b, c = (b+c)//2, (c+a)//2, (a+b)//2
    o += 1
print(o)
# Judge status: Accepted
input_map = []
string_num, string_length = map(int, input().split())
for i in range(string_num):
    input_line = input()
    input_map.append(input_line)

input_map.sort()

line = ""
for i in range(string_num):
    line = line + input_map[i]

print(line)
# Judge status: Wrong Answer
sx,sy,tx,ty = map(int,input().split())
going1 = ""
returning1 = ""
going2 = ""
returning2 = ""
going1 = 'R' * (tx - sx) + 'U' * (ty - sy)
returning1 = 'L' * (tx -sy) + 'D' * (ty - sy)
going2 = 'D' + 'R' * (tx - sx + 1) + 'U' * (ty - sy + 1) + 'L'
returning2 = 'U' + 'L' * (tx - sx + 1) + 'D' * (ty - sy + 1) + 'R' 
print(going1 + returning1 + going2 + returning2)
# Judge status: Accepted
n = int(input())
print(int((1/2)*n*(n+1)))
# Judge status: Accepted
n = int(input())
robot = [0]*n
for i in range(n):
  a, b = map(int, input().split())
  robot[i] = [a+b, a-b]

robot.sort()
ans = 0
for i in range(n):
  if i == 0:
    key = robot[0][0]
    ans += 1
    continue
  if robot[i][1] < key:
    continue
  key = robot[i][0]
  ans += 1
print(ans)
# Judge status: Wrong Answer
L, R, d = map(int, input().split())

print((R - L + 1) // d)
# Judge status: Accepted
N=int(input())
lis = list(map(int, input().split()))
ans=1
j=True
if lis.count(0) > 0:
    print(0)
else:
    for a in lis:
        ans*=a
        if ans > pow(10,18):
            j=False
            break
    if j:
        print(ans)
    else:
        print(-1)
# Judge status: Accepted
a = int(input())
print(int(a+a**2+a**3))
# Judge status: Accepted
k = int(input())
print(k // 2 * -(-k // 2))
# Judge status: Accepted
from collections import deque

K = int(input())
Q = list(range(1, 10))

for i in range(K):
    x = Q[i]
    y = x%10
    if y != 0:
        Q.append(10*x + y-1)
    Q.append(10*x + y)
    if y != 9:
        Q.append(10*x + y+1)

print(Q[K-1])
# Judge status: Accepted
# -*- coding: utf-8 -*-

N,K = map(int, input().split())
A = list(map(int, input().split()))

def num_cut(L):
  result = 0
  for a in A:
    result += a//L
    if a%L == 0:
      result -= 1
  return result

m = 0
M = 10**9

while M-m>1:
  X = (m+M)//2
  if num_cut(X)>K:
    m = X
  else:
    M = X

print(M)
# Judge status: Accepted
#B
import math
a = []
a1 = []
f = 10
for i in range(5):
    a.append(int(input()))
    a1.append(math.ceil(a[i] / 10) * 10)
    if f > a[i] % 10 and a[i] % 10 != 0:#ロスタイムfが小さい0はすぐに注文できるから
        f = a[i] % 10
#累計時間sum(a1)-最小ロスタイムf
print(sum(a1) - 10 + f)
# Judge status: Accepted
n,x,y = map(int,input().split())

s = [0]*(n)

for i in range(1,n):
    for k in range(i+1,n+1):
        dist = min(k-i, abs(x-i) + 1 + abs(y-k))
        s[dist] += 1

for i in range(1,n):
    print(s[i])
# Judge status: Accepted
l=' RainyCloudySunny';print(l[l.find(input())-6:][:6])
# Judge status: Wrong Answer
import math

num1, num2, target = map(int, input().split())

number = math.gcd(num1, num2)

table = []
for j in range(1, number+1):
    if number % j == 0:
        table.append(j)
print(table[target - 1])
# Judge status: Wrong Answer
#=input()
#=int(input())
n,d=map(int,input().split())
#=map(str,input().split())
#=list(map(int,input().split()))
xy = [map(int , input().split())for _ in range(n)]
x,y = [list(i) for i in zip(*xy)]
t = 0
for k in range(n):
    xk=x[k]
    yk=y[k]
    if xk^2 + yk^2 <= d:
        t += 1
print(t)
# Judge status: Wrong Answer
n=int(input())
l=[list(map(int,input().split())) for _ in range(n-1)]
for i in range(n):
    t=0
    for j in range(i,n-1):
        c,s,f=l[j][0],l[j][1],l[j][2]
        if t<s:
            t=s
        elif not t%f==0:
            t=t+f-t&f
        t+=c
    print(t)
# Judge status: Accepted
x,y = map(int,input().split())
if x%y != 0:
    print(x)
else:
    print(-1)
# Judge status: Accepted
N = int(input())
table = [[int(i) for i in input().split()] for N in range(N)]

a = -1
b = 10**10
c = -10**10
d = 10**10
for i in range(N):
    p = table[i][0]
    q = table[i][1]
    if a < p+q:
        a = p+q
    if b > p+q:
        b = p+q
    if c < p-q:
        c = p-q
    if d > p-q:
        d = p-q

print(max(a-b,c-d))
# Judge status: Accepted
N=int(input())
A=[int(i) for i in input().split()]
CS=[A[0]]
for i in range(1,N-1):
  CS.append(CS[-1]+A[i])
SUM=sum(A)
ans=10**20
for s in CS:
  ans=min(ans,abs(SUM-s-s))
print(ans)
# Judge status: Accepted
n = int(input())
l = []
for i in range(n):
    s,p = input().split()
    l.append((s,-int(p),i+1))

l.sort()
for i in range(n):
    print(l[i][2])
# Judge status: Accepted
s = input()
s = [c for c in s]
leng = len(s)
s = set(s)
if leng==len(s):
    print('yes')
else:
    print('no')
# Judge status: Accepted
K,A,B=map(int,input().split())
b_count=1

if B-A<=2:
    b_count+=K
else:
    b_chenge_count=max(0,int((K-(A-1))/2))
    b_count+=b_chenge_count*(B-A)+(A-1)+(K-(A-1)-b_chenge_count*2)

print(b_count)
# Judge status: Accepted
n=input()
a=list(map(int,input().split()))
for x in a:
    if x%2 == 1:
        continue
    if x%3==0 or x%5 == 0:
        continue
    else:
        print('DENIED')
        break
else:
    print('APPROVED')
# Judge status: Accepted
mods=10**9+7

N, K = map(int,input().split(' '))

cnt = 0
for k in range(K,N+1+1):
    minsum = k*(k+1)/2 -k
    maxsum = k*(k+1)/2 + (N-k)*(k)

    cnt+=(maxsum-minsum+1)
    cnt=cnt%mods

print(int(cnt))
# Judge status: Accepted
n, x, y = map(int, input().split())
x -= 1
y -= 1
ans = [0] * n
for i in range(n - 1):
    for j in range(i, n):
        dist = min(j-i, abs(x-i) + abs(y-j) + 1)
        ans[dist] += 1

for i in range(1, n):
    print(ans[i])
# Judge status: Wrong Answer
x, y = map(int, input().split())
A = list(map(int, input().split()))

for num in range(y):
    x -= A[num]

print(x)
# Judge status: Accepted
(n,),aa,bb = [list(map(int, s.split())) for s in open(0)]

up = down = 0

for i in range(n):
    a = aa[i]
    b = bb[i]
    if a > b:
        down += a-b
    if b > a:
        d,m = divmod(b-a,2)
        up += d+m
        down += m

diff = sum(bb) - sum(aa)

if up <= diff and down <= diff:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
N, K = map(int, input().split())
H = sorted([int(input()) for i in range(N)])
list1 = []

for i in range(N - K + 1):
 
  h = H[i + K -1]-H[i]
  list1.append(h)

print(min(list1))
# Judge status: Accepted
a, b = map(int, input().split())
if (0 < a):
  res = "Positive"

elif a <= 0 <= b:
  res = "Zero"

else:
  if a == b:
    res = "Positive"
  elif (b-a) % 2 == 1:
    res = "Positive"
  else:
    res = "Negative"
print(res)
# Judge status: Accepted

a,b,c,d,e = map(int,input().split())
ans = 15 - a - b - c - d-e
print(ans)
# Judge status: Accepted
# -*- coding:utf-8 -*-
import sys
input = sys.stdin.readline
a = int(input())
b = int(input())
h = int(input())
print(int((a+b)*(h/2)))
# Judge status: Accepted
w, h, x, y = map(int, input().split())

if x == w/2 and y == h/2:
    print(w * h / 2, 1)
else:
    print(w * h / 2, 0)
# Judge status: Accepted
n=int(input())
p=list(map(int,input().split()))

cnt=0
m=10**9
for i in p:
 if i<=m:
  cnt+=1
  m=i
print(cnt)
# Judge status: Accepted
s = input()

if s[-1] == 's':
    print(s + 'es')
else:
    print(s + 's')
# Judge status: Accepted
N = int(input())
a = list(map(int, input().split()))

ans = 0

for  i in range(0, N, 2):
    if a[i] % 2 == 1:
        ans += 1
    else:
        pass

print(ans)
# Judge status: Accepted
S = input()

S = list(S)
if S[2] == S[3] and S[4] == S[5]:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
from math import factorial

n = int(input())
print(factorial(n) % 1000000007)
# Judge status: Accepted
N=int(input())
L=list(map(int,input().split()))
L.sort()
count=0

for i in range(N):
    for j in range(i,N):
        for k in range(j,N):
            if (L[i] != L[j] and L[j] != L[k]):
                    if (L[i] + L[j] > L[k]):
                            count += 1
                        
print(count)
# Judge status: Accepted
x, y = map(int, input().split())
ans = 0
while x <= y:
    ans += 1
    x *= 2
print(ans)
# Judge status: Wrong Answer
A=list(input())
B=list(input())
C=list(input())

next="a"
while True:
  if next=="a":
    if len(A)==0:
      print("A");exit()
    next=A.pop()    
  elif next=="b":
    if len(B)==0:
      print("B");exit()
    next=B.pop()    
  else:
    if len(C)==0:
      print("C");exit()
    next=C.pop()
# Judge status: Accepted
h,m,a,b,k=map(int,input().split())
h_to_min = h * 60
a_to_min = a * 60
re1 = a_to_min - h_to_min
re2 = b - m
re = re1 + re2
print(re-k)
# Judge status: Accepted
def main():
    n = int(input())
    x = list(map(int, input().split()))
    min = 10000000000
    for point in range(10000):
        s = sum([(i - point)**2 for i in x])
        if s < min:
            min = s
    print(min)


if __name__ == "__main__":
    main()
# Judge status: Accepted
n = int(input())
L = list(map(int,input().split()))
cnt = 0
for i in range(n-2):
  s = L[i:i+3][1]
  A = sorted(L[i:i+3])
  t = A[1]
  if s == t:
    cnt += 1
print(cnt)
# Judge status: Accepted
n,k = map(int, input().split( ))
ins = [tuple(map(int, input().split( ))) for _ in range(n)]
ins.sort()
cnt = 0
for i in range(n):
    cnt += ins[i][1]
    if cnt >= k:
        print(ins[i][0])
        exit()
# Judge status: Wrong Answer
N, M = map(int, input().split())
n_student = [list(map(int, input().split())) for i in range(N)]
m_point = [list(map(int, input().split())) for i in range(M)]

for x in range(N):
    min_y = 0
    min_value = 1000000
    for y in range(M):
        distance = abs(n_student[x][0] - m_point[y][0]) + \
            abs(n_student[x][1] - m_point[y][1])
        if distance < min_value:
            min_value = distance
            min_y = y + 1
    print(min_y)
# Judge status: Accepted
a,b,c=map(int,input().split())
if a<=c<=b:
  print("Yes")
else:
  print("No")
# Judge status: Wrong Answer
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()
q.sort()
r.sort()
p = p[x-a:]
q = q[y-b:]

ans = p+q+r
ans.sort(reverse=True)
print(sum(ans[:x+y]))
# Judge status: Accepted
n = int(input())
s = 'No'

for i in range(26):
    for j in range(16):
        total = 4*i +7*j
        if total == n:
            s = 'Yes'
            break
    if total ==n:
        break
print(s)
# Judge status: Wrong Answer
N = int(input())
A = [int(i) for i in input().split()]
A.sort(reverse=True)

comf = 0
for i in range(1,N):
  comf += A[i-1]
print(comf)
# Judge status: Accepted
s=input()

if s=="Sunny":print("Cloudy")
elif s=="Cloudy":print("Rainy")
elif s=="Rainy":print("Sunny")
# Judge status: Wrong Answer
N,M = map(int,input().split())
AB = [list(map(int,input().split())) for _ in range(M)]

WAY = [[] for _ in range(N+1)]
for a,b in AB:
  WAY[a].append(b)
  WAY[b].append(a)
  
ans = []
for i in range(1,N+1):
  c = len(set(WAY[i]))
  ans.append(c)
  
print("\n".join(map(str,ans)))
# Judge status: Accepted
n = int(input())
list = list(map(int, input().split()))
b = -1
cont = True

while cont:
  b += 1
  for i in range(n):
    if(list[i] % 2 == 0):
      list[i] = list[i] / 2
    else:
      cont = False
     
print(b)
# Judge status: Accepted
a,b,k=map(int,input().split())
lst=[]
for i in range(a,a+k):
    if i>b:
        break
    lst.append(i)
    print(i)
for i in range(b-k+1,b+1):
    if i<a:
        continue
    if not i in lst:
        print(i)
# Judge status: Accepted
N = int(input())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = B*1
B.append(0)
B.append(0)

ans = 0
tamari = 0
for i in range(N+1):
  if A[i] <= tamari:
    ans += A[i]
    tamari = B[i]
  elif A[i] <= tamari + B[i]:
    ans += A[i]
    tamari = tamari+B[i]-A[i]
  else: #倒しきれない
    ans += tamari + B[i]
    tamari = 0
    
    
print(ans)
# Judge status: Accepted
x=int(input())
if x%11>0:
  if (x%11)%6!=0:
    ans=2*(x//11)+((x%11)//6)+1
  else:
    ans=2*(x//11)+1
else:
  ans=2*(x//11)
print(ans)
# Judge status: Accepted
from collections import defaultdict
S = input()

d = defaultdict(int)

for i in range(len(S)):
    d[S[i]] += 1
f = 0
for i in range(len(S)):
    if d[S[i]] != 2:
        f = 1

if f == 0:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
a, b = map(int,input().split())
print(a * b if 10>a and 10>b else -1)
# Judge status: Accepted
import copy

def main():
    N = int(input())
    A = list(map(int, input().split()))
    A.sort()
    A_max = A[N-1]

    div_count = [0] * (A_max + 1)

    for a in A:
        for n in range(a, A_max+1, a):
            div_count[n] += 1

    exists = [False] * (A_max + 1)
    for a in A:
        exists[a] = True

    result = 0
    for i, d in enumerate(div_count):
        if d == 1 and exists[i]:
            result += 1

    print(result)

main()
# Judge status: Accepted
N = int(input())
number = [0]*N
for i in range(N):
    a,b = map(int,input().split())
    if a==b:
        number[i]=1

for i in range(N-2):
    if number[i]==1 and number[i+1]==1 and number[i+2]==1:
        print("Yes")
        exit(0)

print("No")
# Judge status: Accepted
S = input()
ans = ""
for i in range(len(S)):
    ans += "x"
print(ans)
# Judge status: Accepted
#!/usr/bin/env python3
n, Q = map(int, input().split())
s = input()
q = [[*map(int, input().split())] for _ in range(Q)]
R = [0]
for i in range(n - 1):
    R.append(R[-1] + (s[i:i + 2] == "AC"))
for l, r in q:
    print(R[r-1]-R[l-1])