peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
def main():
    a, b = (int(i) for i in input().split())
    print(a*b)


if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
n,d = map(int,input().split())

x = [list(map(int,input().split())) for _ in range(n)]

ans = 0

for i in range(n-1):
    for j in range(i+1,n):
        sub = 0
        for k in range(d) :
            sub += (x[i][k]-x[j][k])**2
        sub = sub**0.5
        print(sub)
        if sub.is_integer() :
            ans += 1

print(ans)
# Judge status: Wrong Answer
vowelslist=["a","e","i","o","u"]
print(input() in vowelslist)
# Judge status: Wrong Answer
N,M=map(int,input().split())
city_l=[]
for i in range(M):
    a,b=map(int,input().split())
    city_l.append(a)
    city_l.append(b)
print(city_l)
for i in range(1,N+1):
    print(city_l.count(i))
# Judge status: Wrong Answer
import math
from decimal import Decimal

if __name__ == "__main__":
    L = int(input())
    hoge = L / 3 
    ret = (hoge* 10**6) **3
    print(ret)
# Judge status: Accepted
import math

a, b ,c = map(int, input().split())
lis = [a, b, c]
lis = sorted(lis)

t = lis[0] * lis[1]

b = math.ceil(lis[2]/2)
s = math.floor(lis[2]/2)

print(t*b - t*s)
# Judge status: Accepted
s=input()
if ("RRR" in s):
  print(3)
elif ("RR" in s):
  print(2)
elif ("R" in s):
  print(1)
else:
  print(0)
# Judge status: Accepted
import sys

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


def resolve():
    a, b, c = map(int, input().split())
    print("Yes") if a < c < b or b < c < a else print("No")

if __name__ == '__main__':
    resolve()
# Judge status: Wrong Answer
n=int(input())

cnt=1##文字数
tmp=26

while n>tmp:
    cnt+=1
    tmp+=26**cnt
 
num=n-(tmp//26)
 
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"]
 
if n<=26:
    ans=alp[n-1]
    print(ans)
else:
    ans=["0"]*cnt
    for i in range(cnt):
        j=num%26
        ans[-i-1]=alp[j]
        num//=26
    
    print(ans)
# Judge status: Accepted
s=list(input())
alp=list("abcdefghijklmnopqrstuvwxyz")
ans="None"
for w in alp:
    if w not in s:
        ans=w
        break
    else:
      pass
print(ans)
# Judge status: Wrong Answer
abcde=input().split()
for i in range(5):
    if int(abcde[i]) == 0:
        print(i)
# Judge status: Accepted
K = int(input())
odd = (K + 1) // 2
even = K - odd
print(odd * even)
# Judge status: Accepted
d,n = map(int,input().split())
a = 100**d
if n != 100:
    print(a*n)
else:
    print(a*(n+1))
# Judge status: Accepted
n=int(input())
a=list(map(int,input().split()))
cnt=[0,0]
for i in range(n):
    if a[i]%2==0:
        if a[i]%4==0:
            cnt[1]+=1
        else:
            cnt[0]+=1
if cnt[0]==0 and cnt[1]!=0:
    if 2*cnt[1]+1>=n:
        print("Yes")
    else:
        print("No")
elif cnt[0]+2*cnt[1]>=n:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
s = list(input())

dup = [x for x in set(s) if s.count(x) == 2]

if len(dup) == 2:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
import sys
sys.setrecursionlimit(10**6)

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

if d==0:
    if n==100:
        print(n+1)
        exit()
    print(n)
elif d!=0 and n==100:
    print((n+1)*100**d)
else:
    print(n*100**d)
# Judge status: Accepted
a,b,c,d=map(int,input().split())
ans="No"

if abs(a-c)<=d:
  ans="Yes"
if abs(a-b)<=d and abs(b-c)<=d:
  ans="Yes"
  
print(ans)
# Judge status: Accepted
def resolve():
    w = input()
    flag = 0
    abc = "abcdefghijklmnopqrstuvwxyz"
    for i in range(len(abc)):
        if w.count(abc[i])%2 == 0:
            continue
        else:
            flag = 1
    print("Yes" if flag == 0 else "No")
resolve()
# Judge status: Wrong Answer
import sys
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(rs())
def rs_(): return [_ for _ in rs().split()]
def ri_(): return [int(_) for _ in rs().split()]

a = sorted(ri_(),reverse=True)
b = a[0] - a[1]
c = a[0] - a[2]
print(b // 2 + b % 2 + c // 2 + c % 2)
# Judge status: Accepted
a, b = map(int,input().split())
if a+b >= 24:
    print(a + b -24)
else:
    print(a+b)
# Judge status: Accepted
N, A, B = map(int, input().split())
S = list(input().rstrip())

limit = A+B
cnt = 0

for s in S:
    if s=="c":
        print("No")
    elif (s=="a") & (cnt<limit):
        print("Yes")
        cnt += 1
    elif (s=="b") & (cnt<limit) & (B>0):
        print("Yes")
        cnt += 1
        B -= 1
    else:
        print("No")
# Judge status: Accepted
# -*- coding: utf-8 -*-

import math

t=[int(input()) for _ in range(5)]
r=[(i-1)%10+1 for i in t]
c=r.index(min(r))
ans=0
for i in range(5):
    if i==c:
        ans+=t[i]
    else:
        ans+=math.ceil(t[i]/10)*10
print(ans)
# Judge status: Accepted
k, a, b = map(int, input().split())
if a+2>=b:
    print(k+1)
    exit()
k -= a+1
ans = b
ans += (b-a)*(k//2) + k%2
print(ans)
# Judge status: Accepted
n=int(input());l=[0]*n
for i in range(1,n):
 c,s,f=map(int,input().split())
 for j in range(i):l[j]=max(-l[j]//f*-f,s)+c
print(*l,sep='\n')
# Judge status: Accepted
n = list(map(int,input()))[::-1]
n.append(0)
for i in range(len(n)):
    if n[i] >= 6 or (n[i] == 5 and n[i+1] >= 5):
        n[i] = 10 - n[i]
        n[i+1] += 1
print(sum(n))
# Judge status: Wrong Answer
N = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))

Ans = 0
next_A = A[0]
for i in range(N):
    Ans += min(next_A+A[i+1], B[i])
    next_A = max(0, A[i+1] + min(A[i]-B[i], 0))

print(Ans)
# Judge status: Accepted
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
a, b = [0]*(N+1), [0]*(M+1)
for i in range(N):
	a[i+1] = a[i] + A[i] 
for i in range(M):
	b[i+1] = b[i] + B[i]
 
ans, j = 0, M
for i in range(N + 1):
	if a[i] > K:
		break
	while b[j] > K - a[i]:
		j -= 1
	ans = max(ans, i + j)
print(ans)
# Judge status: Wrong Answer
n = int(input())
XL = []
for i in range(n):
  x, l = map(int, input().split())
  XL.append([x, l])
  
XL.sort(key=lambda x: x[0]-x[1])

seen = 0
ans = 0
for i in range(n):
  rob = XL[i]
  if i==0:
    seen = rob[0]+rob[1]
  else:
    if seen > rob[0]-rob[1]:
      ans +=1

    else:
      seen = rob[0]+rob[1]

print(n-ans)
# Judge status: Accepted
h, n = map(int,input().split())
a = list(map(int,input().split()))
atack = sum(a)
can = h <= atack
print("Yes" if can else "No")
# Judge status: Wrong Answer
n, *A = map(int, open(0).read().split())
B = [0] * 9
for a in A:
  if a < 3200:
  	B[a // 400] = 1
  else:
    B[8] += 1
print(max(sum(B[:8]), B[8]), min(8, sum(B)))
# Judge status: Wrong Answer
N = int(input())
A = list(map(int,input().split()))

color = [0]*8
free_color = 0
for a in A:
  if a < 400:
    color[0] = 1
  elif a < 800:
    color[1] = 1
  elif a < 1200:
    color[2] = 1
  elif a < 1600:
    color[3] = 1
  elif a < 2000:
    color[4] = 1
  elif a < 2400:
    color[5] = 1
  elif a < 2800:
    color[6] = 1
  elif a < 3200:
    color[7] = 1
  else:
    free_color += 1

print(sum(color),sum(color)+free_color)
# Judge status: Accepted
if int(input()) in [3,5,7]:print('YES')
else:print('NO')
# Judge status: Accepted
a, b = map(int, input().split())

if a > 0: print('Positive')
elif a == 0 or (a < 0 and b >= 0): print('Zero')
else: print('Positive') if (b - a) % 2 else print('Negative')
# Judge status: Accepted
import itertools
n,m,q = map(int,input().split())
ch = list(itertools.combinations_with_replacement(range(1,m+1),n))
lch = len(ch)
rel = [0]*lch
l = [list(map(int,input().split())) for _ in range(q)]
for k in range(lch):
    for i in range(q):
        if ch[k][l[i][1]-1]-ch[k][l[i][0]-1]==l[i][2]:
            rel[k]+=l[i][3]
print(max(rel))
# Judge status: Accepted
def main():
    N = int(input())
    print(-(-N // 2))
    return


main()
# Judge status: Accepted
import sys
input = sys.stdin.readline

def main():
    n = int(input())
    a_list = list(map(int, input().split()))
    c = [0] * n
    s = 0
    for i, a in enumerate(a_list):
        if i+a < n:
            c[i+a] += 1
        if i-a >= 0:
            s += c[i-a]
    print(s)

if __name__ == '__main__':
    main()
# Judge status: Accepted
def main():
    N, L = map(int, input().split())
    P = 0
    for i in range(1, N+1):
        P += L + i - 1
    ans = float("inf")
    for i in range(1, N+1):
        tmp = L + i - 1
        x = P - tmp
        if abs(P - x) < abs(P - ans):
            ans = x
    print(ans)

if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
n = int(input())
a = sorted(list(map(int, input().split())))
x = a[-1]
y = max(a)//2
a = a[:-1]
while y < x:
    y += 1
    if y in a: break
    if x-y in a:
        y = x-y
        break
print(x,y)
# Judge status: Accepted
n = int(input())
if n % 2 == 1:
  print(0)
else:
  n //= 2
  ans = 0
  while n != 0:
    n //= 5
    ans += n
  print(ans)
# Judge status: Wrong Answer
import math
n, d = map(int, input().split())
x = []
ans = [i**2 for i in range(1, n*d)]
for i in range(n):
    tmp = list(map(int, input().split()))
    x.append(tmp)
cnt = 0
sum_t = 0
for i in range(n):
    for j in range(i+1, n):
        sum_t = 0
        for k in range(d):
            sum_t += (x[i][k]-x[j][k])**2
        if sum_t in ans:
            cnt += 1


print(cnt)
# Judge status: Accepted
n = int(input())
a = [int(i)-1 for i in input().split()]
ans = 0
for i in range(n):
    if a[i] != (i - ans):
        ans += 1
print(ans if ans != n else -1)
# Judge status: Wrong Answer
L, R = map(int, input().split())

Lmod = L%2019
Rmod = R%2019

if (R-L+1) <= 2019 and Lmod < Rmod:
    print((L*(L+1))%2019)
elif (R-L+1) <= 2019 and Lmod > Rmod:
    print(0)
elif (R-L+1) > 2019:
    print(0)
# Judge status: Accepted
Q, H, S, D = map(int, input().split())
N = int(input())

cost = [Q, min(Q*2, H), min(Q*4, H*2, S), min(Q*8, H*4, S*2, D)]

print(N//2*cost[3] + N%2*cost[2])
# Judge status: Accepted
n=int(input())
b0=input().split()
b=[int(x) for x in b0]

ret=0

if b[-1]==0:
  ret=-1
else:
  maxl=[]
  v=1
  for i in range(n+1):
    maxl.append(v)
    v=(v-b[i])*2
    if v<0:
      ret=-1
      break

v=0
vsum=0
if ret!=-1:
  for i in range(n,-1,-1):
    v=min(v+b[i],maxl[i])
    vsum+=v

if ret==-1:
  print(-1)
else:
  print(vsum)
# Judge status: Wrong Answer
import sys
input = sys.stdin.readline
n, a, b = map(int, input().split())
strings = input()
lists = ['No'] * len(strings)
remain = a + b
b_remain = b
for i in range(len(strings)):
  if strings[i] == 'a':
    if remain > 0:
      lists[i] = 'Yes'
      remain = remain - 1
    else:
      break
  elif strings[i] == 'b':
    if b_remain > 0:
      if remain > 0:
        lists[i] = 'Yes'
        remain = remain - 1
        b_remain = b_remain - 1
  else:
    pass
for i in lists:
  print(i)
# Judge status: Wrong Answer
n,m=map(int,input().split())
g=[[] for i in range(n)]
for _ in range(m):
  u,v=map(int,input().split())
  g[u-1].append(v-1)
  g[v-1].append(u-1)
for x in g[0]:
  for y in g[x]:
    if y==n-1:
      print('POSSIBLE')
      exit()
print('No')
# Judge status: Accepted
def main():
  _, _, *lst = map(int, open(0).read().split())
  l, r = max(lst[::2]), min(lst[1::2])
  print(0 if l > r else r - l + 1)

main()
# Judge status: Accepted
n = int(input())
xy = [tuple(map(int, input().split())) for _ in range(n)]
p = [x + y for x, y in xy]
a1 = max(p) - min(p)
q = [x - y for x, y in xy]
a2 = max(q) - min(q)
print(max(a1, a2))
# Judge status: Wrong Answer
a, b, c, d = input()
count = 0
if a == b:
  if a == c or a == d:
    count += 1
elif a == c:
  if a == d:
    count += 1
elif b == c:
  if b == d:
    count += 1

if count == 1:
  print("Yes")
else:
  print("No")
# Judge status: Accepted
alp='abcdefghijklmnopqrstuvwxyz'

def f(N, s, x):
  if len(s)==N:
    print(s)
    return
  for i in range(x+2):
    f(N, s+alp[i], max(x, i))
    
f(int(input()), 'a', 0)
# Judge status: Accepted
x = int(input())
if x>=30:
  print('Yes')
else:
  print('No')
# Judge status: Accepted
N = int(input())
ans = 0
for i in range(N+1):
    if i*i <= N: ans = i*i
    else: break
print(ans)
# Judge status: Accepted
# ABC125 A

def main():
    a, b, t = map(int, input().split())
    
    print((t // a) * b)

if __name__ == '__main__':
    main()
# Judge status: Accepted
N=int(input())
X=list(map(int,input().strip().split()))

Y=sorted(X)
a=Y[N//2-1]
b=Y[N//2]
for n in range(N):
    if X[n]<=a:
        print(b)
    else:
        print(a)
# Judge status: Accepted
N, M, K = map(int, input().split())
ans = "No"
for n in range(N+1):
  for m in range(M+1):
    if (N*m + M*n - 2*m*n) == K:
      ans = "Yes"
      break
print(ans)
# Judge status: Accepted
n, k = [int(i) for i in input().split()]

ans = 0
for i in range(1, n + 1):
    j = 1
    while i < k:
        j /= 2
        i*=2
    ans += j
ans /= n
print(ans)
# Judge status: Wrong Answer
import math

N,M = map(int, open(0).read().split())
X = math.floor((M-2*N)/2)
print(math.floor((2*N+X)/2))
# Judge status: Accepted
from bisect import bisect_left,bisect
 
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
lenc=len(c)

a.sort()
b.sort()
c.sort()

jsum=0
for j in b:
    ai=bisect(a,j-1)
    ci=lenc-bisect_left(c,j+1)
#    print(j,ai,ci)
    jsum+=ai*ci

print(jsum)
# Judge status: Accepted
s = [list(map(int,input().split())) for i in range(3)]

def solve():
    if not (s[0][1] - s[0][0] == s[1][1] - s[1][0] == s[2][1] - s[2][0]): return False
    if not (s[0][2] - s[0][1] == s[1][2] - s[1][1] == s[2][2] - s[2][1]): return False
    if not (s[1][0] - s[0][0] == s[1][1] - s[0][1] == s[1][2] - s[0][2]): return False
    if not (s[2][0] - s[1][0] == s[2][1] - s[1][1] == s[2][2] - s[1][2]): return False
    return True

print('Yes' if solve() else 'No')
# Judge status: Accepted
N=int(input())
A=[int(i) for i in input().split()]

ans=0
for i in range(1,N):
    if A[i]<A[i-1]:
        ans+=A[i-1]-A[i]
        A[i]=A[i-1]

print(ans)
# Judge status: Wrong Answer
import sys
import bisect

input = sys.stdin.readline
N, M = map(int, input().split())
AB = sorted([list(map(int, input().split())) for _ in range(N)], key=lambda x: x[1])[::-1]
plan = []
ans = 0
for a, b in AB:
    i = bisect.bisect_left(plan, a)
    if a+len(plan)-i<=M and len(plan)<M:
        plan.insert(i, a)
        ans += b
print(ans)
# Judge status: Accepted
N, K = map(int, input().split())
s = input()

print(s[:K-1]+s[K-1].lower()+s[K:])
# Judge status: Wrong Answer
n,m,k = map(int, input().split())
ans = "No"
for i in range(n+1):
    l = k-i*m
    j = n-2*i
    if j==0:
        if l==0:
            ans = "Yes"
        else:
            continue
    else:
        if l%j==0:
            ans = "Yes"
        else:
            continue
print(ans)
# Judge status: Wrong Answer
n, m = map(int, input().split())
if 2 * n >= m:
    print(n)
else:
    print(n + (m-(2*n))//4)
# Judge status: Wrong Answer
s = list(input())
print(s.index('Z')-s.index('A')+1)
# Judge status: Accepted
N=int(input())
s=dict()
for _ in range(N):
    S=input()
    if S not in s:
        s[S]=0
    s[S]+=1
M=int(input())
for _ in range(M):
    t=input()
    if t in s:
        s[t]-=1
print(max(max(0,x) for x in s.values()))
# Judge status: Wrong Answer
x, y = map(int,input().split())
print([-1, x][x>y or y%x>0])
# Judge status: Accepted
s=input()
l=len(s)
se=dict()
k=0
for i in range(l-1,-1,-1):
    k+=(pow(10,l-1-i,2019)*int(s[i]))
    k%=2019
    if k in se:
        se[k]+=1
    else:
        se[k]=1

ans=0
for j in se:
    i=se[j]
    if i>1:
        ans+=(i*(i-1)//2)
    if j==0:
        ans+=i
print(ans)
# Judge status: Accepted
a, b = map(int, input().split())
print(a - 1 if a > b else a)
# Judge status: Accepted
S, T = input().split()
A, B = map(int, input().split())
U = input()

if S == U:
    A -= 1
else:
    B -= 1

print(str(A) + ' ' + str(B))
# Judge status: Accepted
N=int(input())
S=input()
c1,c2=0,0
for s in S:
    if s=='(': c1+=1
    elif c1>0: c1-=1
for s in reversed(S):
    if s==')': c2+=1
    elif c2>0: c2-=1
print('('*c2 + S + ')'*c1)
# Judge status: Accepted
a,b,c,d=map(int,input().split())
ans = -10000000000000000000
ans = max( ans, a*c)
ans = max( ans, a*d)
ans = max( ans, b*c)
ans = max( ans, b*d)
print(ans)
# Judge status: Wrong Answer
inputs = [input() for i in range(2)]
n = int(inputs[0])
a = map(lambda x: int(x), inputs[1].split(" "))

b = {}
for i in a:
  if i not in b:
    b[i] = 1
  else:
    b[i] += 1
count = 0
for k in b.keys():
  count += abs(k - b[k])

print(count)
# Judge status: Accepted
N = int(input())
ans = ''
while N >0:
    N -=1
    ans += chr(ord('a') + N%26)
    N //=26

print(ans[::-1])
# Judge status: Wrong Answer
n = int(input())
s = str(input().split())
t = str(input().split())
a = set(s+t)
print(a)
print(len(a)-3)
# Judge status: Accepted
n,m =  map(int,input().split())
a = list(map(int,input().split()))
cnt = 0
for i in a:
    if i >= sum(a)/(4*m):
        cnt += 1
if cnt >= m:
    print("Yes")
else:
    print("No")
# Judge status: Wrong Answer
n = int(input())

al = [int(input()) for _ in range(n)]

ans = 0
for i in range(n-1):
    rest = ((al[i] + al[i+1]) // 2) * 2
    ans += rest
    for j in range(2):
        if al[i+j] > rest:
            al[i+j] -= rest
            break
        else:
            rest -= al[i+j]
            al[i+j] = 0


print(ans//2)
# Judge status: Accepted
n,m=map(int,input().split())
if(n%m==0):
    print(0)
else:
    print(1)
# Judge status: Accepted
l = [1,3,5,7,8,10,12]
m = [4,6,9,11]
a,b  = map(int,input().split())
if (a in l and b in l) or (a in m and b in m):
  print("Yes")
else:
  print("No")
# Judge status: Accepted
import numpy as np
a, b = map(int, input().split())
print(np.lcm(a, b))
# Judge status: Accepted
n = int(input())
t = [int(input()) for _ in range(n)]

import fractions

ans = t[0]
for i in range(1, n):
   ans = ans * t[i] // fractions.gcd(ans, t[i])
print(ans)
# Judge status: Wrong Answer
D, T, S = map(int, input().split())

if (T * S) >= D :
    print("YES")
else :
    print("NO")
# Judge status: Wrong Answer
n, m = map(int,input().split())
data = [list(map(int, input().split())) for _ in range(m)]
start = set(i[1] for i in data if i[0] == data[0][0])
goal = set(j[0] for j in data if j[1] == data[-1][1])
if start & goal:
    print('POSSIBLE')
else:
    print('IMPOSSIBLE')
# Judge status: Accepted
#!/usr/bin/env python3

d = int(input())

if d == 25:
    print("Christmas")
elif d == 24:
    print("Christmas Eve")
elif d == 23:
    print("Christmas Eve Eve")
else:
    print("Christmas Eve Eve Eve")
# Judge status: Accepted
A = int(input())
B = int(input())

ans = [1, 2, 3]
ans.remove(A)
ans.remove(B)

print(ans.pop())
# Judge status: Accepted
a = list(map(int,input().split()))
cnt = 0
for i in range(3):
    if a[i]%2 == 0:
        cnt += 1
if cnt == 0:
    a.sort()
    print(a[0]*a[1])
else:
    print(0)
# Judge status: Accepted
def solve():
    N = int(input())
    H = list(map(int, input().split()))
    h_max = H[0]
    ret = True
    for h in H:
        if h_max-1 > h:
            ret = False
            break
        if h_max < h:
            h_max = h
    print('Yes' if ret else 'No')
    
solve()
# Judge status: Accepted
def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a


K = int(input())
tot = 0
for a in range(1, K+1):
    for b in range(1, K+1):
        x = gcd(a, b)
        for c in range(1, K+1):
            y = gcd(x, c)
            tot += y
print(tot)
# Judge status: Accepted
import bisect

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

A.sort()
B.sort()
C.sort()

ans = 0
for b in B:
    a = bisect.bisect_left(A, b)
    c = bisect.bisect_right(C, b)
    ans += a*(N-c)

print(ans)
# Judge status: Accepted
n = int(input())
a = list(map(int, input().split()))

ans = 1
up = False
down = False
for i in range(n - 1):
  if a[i] == a[i + 1]:
    continue
  if a[i] < a[i + 1]:
    up = True
    if down:
      ans += 1
      down = False
      up = False
  elif a[i] > a[i + 1]:
    down = True
    if up:
      ans += 1
      up = False
      down = False

print(ans)
# Judge status: Accepted
N, A, B, C, D = map(int, input().split())
S = input()

if C < D:
    if '##' not in S[A - 1:D]:
        print('Yes')
    else:
        print('No')
else:
    if '##' not in S[A - 1:C] and '...' in S[B - 2: D + 1]:
        print('Yes')
    else:
        print('No')
# Judge status: Wrong Answer
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
count = 0
sort_array = b + c
sort_array.sort()

num = a[2]

print(sort_array)
for i in range(0,len(sort_array)):
    num -= sort_array[i]
    if num >= 0:
        count += 1


print(count)
# Judge status: Accepted
a, b = map(int, input().split())
flag = 0

for i in range(1, 1001):
    hati = int(i * 0.08)
    juu = int(i * 0.1)
    
    if hati == a and juu == b:
        flag = 1
        print(i)
        break
    
if flag == 0:
    print("-1")
# Judge status: Accepted
n = int(input())
a = set()
for i in range(n):
    num = int(input())
    if num in a:
        a.remove(num)
    else:
        a.add(num)
print(len(a))
# Judge status: Wrong Answer
x=int(input())
for i in range(1,100001):
  t=i*(i+1)//2
  s=(i+1)*(i+2)//2
  if t<x<=s:
    print(i+1)
    exit(0)
# Judge status: Accepted
a,s,b=input().split()

print('A'+s[0]+'C')
# Judge status: Accepted
import sys
input=sys.stdin.readline
ans=0
n,d=map(int,input().split())
for i in range(n):
	x,y=map(int,input().split())
	if x**2+y**2<=d**2:
		ans+=1
print(ans)
# Judge status: Wrong Answer
import fractions
A,B,C,D = map(int,input().split())
S = B-A+1
print(S-(S//C + S//D - S//((C*D)//fractions.gcd(C,D))))
# Judge status: Accepted
x =int(input())

ans=0
sum=0

for i in range(0,50000):
    sum+=i
    if sum>=x:
        break
    
    ans+=1

print(ans)
# Judge status: Accepted
x = int(input())

y = x//100
if y*100 <= x <= y*105:
	print("1")
else:
    print("0")
# Judge status: Accepted
a, b, c = map(int, input().split())
if a == b == c or a != b != c != a:
    print("No")
else:
    print("Yes")
# Judge status: Accepted
s=input()
t=0
for i in range((len(s))//2):
    if s[i]!=s[len(s)-i-1]:
        t+=1
print(t)
# Judge status: Wrong Answer
a,b=map(int,input().split())
print(['Impossible','Possible'][a/3==0 or b/3==0 or (a+b)%3==0])
# Judge status: Wrong Answer
a, b = map(int, input().split())
ans = 1
while True:
  if ans * a >= b:
    break
  ans += 1
print(ans)
# Judge status: Accepted
N,*a = map(int,open(0).read().split())
for i in range(N)[::-1]:
    part_rem = sum(a[i::i+1]) % 2
    if a[i] != part_rem:
        a[i] = abs(a[i] - 1) 

print(sum(a))
print(*[i+1 for i,v in enumerate(a) if v == 1])
# Judge status: Wrong Answer
count = int(input())
num_list = list(map(int,input().split()))

count  = 3
num_list =[8,12,40]

output = 0
stop_flag = 0

while 1:
    for num in num_list:
        if((num % 2) == 1 ):
            stop_flag = 1
    if stop_flag == 0:
        output += 1
    
    num_list = list(map(lambda x: x/2,num_list))

    if stop_flag == 1:
        break
    
print(output)
# Judge status: Wrong Answer
n = int(input())
lis = [input() for _ in range(n)]
m1 = max(lis)
sort_lis = sorted(lis)
m2 = sort_lis[n-2]

for i in range(n):
  if lis[i] == m1:
    print(m2)
  else:
    print(m1)
# Judge status: Accepted
a,b,k=map(int,input().split())
if a>k:
  a-=k
  k=0
else:
  k-=a
  a=0
b=max(0,b-k)
print(a,b)
# Judge status: Wrong Answer
k = input()
num = list(map(int, input().split()))
cost = []
for i in range(0,100):
  plus_val = list(map(lambda x: x-i, num))
  minus_val = list(map(lambda x: x+i, num))
  plus_val_cost = sum(list(map(lambda x: x**2, plus_val)))
  minus_val_cost = sum(list(map(lambda x: x**2, minus_val)))
  cost.append(plus_val_cost)
  cost.append(minus_val_cost)
  
min_val = min(cost)
print(min_val)
# Judge status: Accepted
x,y = map(int,input().split())
 
ans = 0
for i in range(x+1):
    f = (2*i) + 4*(x-i)
    if  f == y:
        print("Yes")
        exit()
 
print("No")
# Judge status: Accepted
input()
A=list(map(int,input().split()))
ans=0
while all(a%2==0 for a in A):
    A=[a/2 for a in A]
    ans+=1
print(ans)
# Judge status: Accepted
N = int(input())
P = list(map(int, input().split()))
P.sort()
#print(P)
A = P[int(N/2)-1]
B = P[int(N/2)]
#print(A,B)
print(B-A)