peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
a = input()

for i in range(1 << 3):
  ans = int(a[0])
  f = a[0]
  
  for j in range(3):
    if i & (1 << j):
      ans += int(a[j+1])
      f += '+'
    else:
      ans -= int(a[j+1])
      f += '-'
    f += a[j+1]
    
  if ans == 7:
    print(f + '=7')
    exit()
# Judge status: Accepted
from collections import Counter
n = int(input())
A = Counter([int(input()) for _ in range(n)])
cnt = 0
for k in A.values():
    if k%2 != 0:
        cnt +=1
print(cnt)
# Judge status: Accepted
n, k = map(int, input().split())
h = list(map(int, input().split()))

dp = [float('inf')] * n
dp[0] = 0

for i in range(1, n):
  for j in range(1, k+1):
    if(i-j < 0):
      break
    dp[i] = min(dp[i], dp[i-j] + abs(h[i-j] - h[i]))

print(dp[-1])
# Judge status: Wrong Answer
MOD = 1000000007

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

ans = 0
for k in range(60):
    mask = 1<<k
    cnt1 = sum(1 for x in a if x&mask != 0)
    ans += cnt1*(n-cnt1)*(1<<k)
print(ans)
# Judge status: Wrong Answer
#ABC097
import math
x = int(input())
l = [1]
for i in range(int(math.sqrt(x))+1):
    j = 1
    for j in range(100):
        if i ** j > x:
            l.append(i ** (j-1))
            break
            
print(l[-1])
# Judge status: Accepted
n,m=map(int, input().split())
a_list=[int(i) for i in input().split()]

a_list.sort(reverse=True)
#print(a_list)

standard=sum(a_list)/(4*m)

#print(a_list[m-1])
#print(standard)
if a_list[m-1]<standard:
    print("No")
    
else:
    print("Yes")
# Judge status: Accepted
N = int(input())
ans = N*(N-1)//2
print(ans)
# Judge status: Accepted
n =int(input())
a =list(int(input()) for i in range(n))

dict = {}
for i in range(n):
  if str(a[i]) in dict:
    dict.pop(str(a[i]))
    continue
    
  if not(str(a[i]) in dict):
    dict[str(a[i])] =1
    continue
  
    
print(len(dict))
# Judge status: Accepted

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 range(n):
    print(cnt[i])
# Judge status: Wrong Answer
A,B,C,D=list(map(int, input().split()))
ma=min(B,D)
mi=max(A,C)
print(ma-mi)
# Judge status: Accepted
x = int(input())
ans = x // 11
m = x % 11

ans *= 2
if m > 6:
  ans += 2
elif m != 0:
  ans += 1
print(ans)
# Judge status: Accepted
H1, M1, H2, M2, K = map(int, input().split())
h = H2 - H1
m = M2 - M1
T = h * 60 + m
print(T-K)
# Judge status: Accepted
a,b=map(int,input().split())

if a<=0 and b>=0:
    print("Zero")
elif a>0:
    print("Positive")
else:
    if (abs(a-b)+1)%2==0:
        print("Positive")
    else:
        print("Negative")
# Judge status: Accepted
n_5 = 0
n_7 = 0

a = map(int, input().split())
for i in a:
    if i == 5:
        n_5 += 1
    elif i == 7:
        n_7 += 1

if n_5 == 2 and n_7 == 1:
    print("YES")
else:
    print("NO")
# Judge status: Wrong Answer
n = int(input())
l = [list(map(int,input().split())) for i in range(n)]
x = list(sorted(l,key=lambda x: x[0]))
y = list(sorted(l,key=lambda x: x[1]))
ax = abs(x[0][0]-x[-1][0])+abs(x[0][1]-x[-1][1])
ay = abs(y[0][0]-y[-1][0])+abs(y[0][1]-y[-1][1])
print(max(ax,ay))
# Judge status: Accepted
N=int(input())

if N>=1000:
    print('ABD')
else:
    print('ABC')
# Judge status: Accepted
n, m = map(int, input().split())
print(n * (n - 1) // 2 + m * (m - 1) // 2)
# Judge status: Wrong Answer
k,x = map(int,input().split())
print("No") if x // k > 500 else print("Yes")
# Judge status: Accepted
A,B,C = map(int,input().split())
D=A+B
if D>=C:
	print("Yes")
else:
	print("No")
# Judge status: Wrong Answer
import math
n,k = map(int,input().split())

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

ans = 0

x = 0
for i in range(n):
    x = max(x,lst1[i][0])

sum1 = 0
for i in range(n):
    if lst1[i][1] > x:
        k -= lst1[i][1]
        ans += 1
    if k <= 0:
        print(ans)
        exit()

print(ans + math.ceil(k/x) )
# Judge status: Accepted
a,b,c=list(map(int,input().split()))
if b - a == c - b:
  print("YES")
else:
  print("NO")
# Judge status: Wrong Answer
n = int(input())
s = input()
if len(s)%2 == 1:
    print('No')
else:
    m = len(s)
    s1, s2 = s[:m], s[m:]
    if s1 == s2:
        print('Yes')
    else:
        print('No')
# Judge status: Accepted
#!/usr/bin/env python3
import sys


input = sys.stdin.readline
def IS(cb): return cb(input().strip())
def IL(cb): return [cb(s) for s in input().strip().split()]
def IR(cb, rows): return [IS(cb) for _ in range(rows)]
def ILL(cb, rows): return [IL(cb) for _ in range(rows)]


def solve():
    h1, m1, h2, m2, k = IL(int)
    all_time = (h2 * 60 + m2) - (h1 * 60 + m1)
    print(all_time - k)


solve()
# Judge status: Wrong Answer
l=int(input())
print(int(l**3/27))
# Judge status: Accepted
n, k = map(int, input().split())
p = sorted(map(int, input().split()))

print(sum(p[:k]))
# Judge status: Accepted
N,X = map(int,input().split())
L_li = input().split()
for i in range(len(L_li)):
    L_li[i] = int(L_li[i])

D = [0]*(N+1)
for i in range(1,N+1,1):
    D[i] = D[i-1] + L_li[i-1]
print(len([i for i in D if i <= X]))
# Judge status: Accepted
n,k=map(int, input().split())
n=n%k
n1=abs(n-k)
n2=abs(n1-k)
print(min(n1,n2))
# Judge status: Accepted
N, M = map(int, input().split())
X = list(map(int, input().split()))
if N >= M:
    print(0)
    exit()
X.sort()
Y = []
for i in range(1, M):
    Y.append(X[i] - X[i - 1])
Y.sort()
ans = sum(Y[:M-N])
print(ans)
# Judge status: Accepted
N=int(input())
A=list(map(int,input().split()))
MIN=10**9
for i in range(N):
  count=0
  while 1:
    if A[i] % 2 == 0:
      A[i] //= 2
    else:
      break
    count += 1
  MIN = min(MIN,count)
  if MIN==0:
    print(0)
    exit()
print(MIN)
# Judge status: Accepted
a,b,c,d = map(int,input().split())

th1 = "R"*(c-a)
th2 = "U"*(d-b)
th3 = "L"*(c-a)
th4 = "D"*(d-b)
th5 = "D"+"R"*(c-a+1)+"U"*(d-b+1)+"L"
th6 = "U"+"L"*(c-a+1)+"D"*(d-b+1)+"R"

ans=th1+th2+th3+th4+th5+th6
print(ans)
# Judge status: Accepted
x = input()

if int(x) % 2:
    print(int(int(x)/2+0.5))
else:
    print(int(int(x)/2))
# Judge status: Wrong Answer
N = int(input())
A = list(map(int, input().split()))
s = 0
if N==1:
  print(0)
  exit()

for i,a in enumerate(A):
  if i==0:
    continue
  
  s+=(a<A[i-1])*a

print(s)
# Judge status: Accepted

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

def main():
    mod=10**9+7
    w=input()
    from collections import defaultdict
    dd = defaultdict(int)
    
    for i in range(len(w)):
        dd[w[i]]+=1
        
        
    f=1
    for k,v in dd.items():
        if v%2==1:
            f=0
            
    if f==1:
        print("Yes")
    else:
        print("No")

main()
# Judge status: Accepted
A,B,C=map(int,input().split())
print("Yes" if A+B>=C else "No")
# Judge status: Accepted
x, k, d = map(int, input().split())
x = abs(x)
# x > 0のとき
left = abs(x - d * (x // d + 1))
right = abs(x - d * (x // d))

if k < x // d:
    print(x - d * k)
    exit()

if (k - (x // d)) % 2 == 0:
    print(right)
else:
    print(left)
# Judge status: Wrong Answer
a, b, c = map(int, input().split())
d, e, f = map(int, input().split())
g, h, i = map(int, input().split())

if a-d==b-e==c-f and a-g==b-h==c-i and a-b--d-e==g-h and a-c==d-f==g-i:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
a = input()
print(a[:3]+'8'+a[4:])
# Judge status: Accepted
N, K = map(int, input().split())
D = set(input().split())

for n in range(N, 100001):
    for s in str(n):
        if s in D:
            break
    else:
        print(n)
        exit()
# Judge status: Accepted
ABC = list(map(int, input().split()))
if ABC.count(5) == 2 and ABC.count(7):
    print('YES')
else:
    print('NO')
# Judge status: Wrong Answer
s=input()
ans=len(s)
for i in range(2):
  cnt=0
  for j in s:
    if int(j) % 2 == 0 and j!=i: cnt+=1
    if int(j) % 2 == 1 and j==i: cnt+=1
  ans=min(cnt,ans)
print(ans)
# Judge status: Wrong Answer
k = int(input())
lunlun = list(range(1, 10))

for i in range(k - 1):
    a = lunlun[i]
    b = a * 10 + a % 10
    if a % 10 != 0:
        lunlun.append(b - 1)
    lunlun.append(b)
    if a % 10 != 9:
        lunlun.append(b + 1)
print(lunlun)
print(lunlun[k - 1])
# Judge status: Accepted
n,a,b=map(int,input().split())
s=list(input())

ac=0
fc=0

for i in range (n):
  if s[i]=='a' and ac<a+b:
    ac+=1
    print ('Yes')
  elif s[i]=='b' and ac<a+b and fc<b:
    ac+=1
    fc+=1
    print ('Yes')
  else:
    print ('No')
# Judge status: Accepted
n = int(input())
s = list(input())

counter = [0] * n

counter[0] = s[1:].count('E')

for i in range(1, n):
    n = 0
    if s[i - 1] == 'W':
        n += 1
    if s[i] == 'E':
        n -= 1
    counter[i] = counter[i - 1] + n

print(min(counter))
# Judge status: Wrong Answer
N = input()
S=[]
for i in range(int(N)):
    S.append(input())

ls=[]
for i in S:
    if i not in ls:
        ls.append(i)
str_ls =[]
num_ls = []
flag = 0

for i in ls:
    num_ls.append(S.count(i))
    str_ls.append(i)

for i in range(len(str_ls)):
    if num_ls[i] == max(num_ls):
        print(str_ls[i])
# Judge status: Accepted
s=input()
a,b,c=0,0,0

for i in range(len(s)):
    if s[i]=='a':
        a+=1
    elif s[i]=='b':
        b+=1
    else :
        c+=1

ans = (abs(a-b) <2) and (abs(c-b)<2) and (abs(c-a)<2)
print( "YES" if ans else "NO")
# Judge status: Wrong Answer
a,b=map(int,input().split())
ab=[i for i in range(a,b+1)]
if 0 in ab:
    print('Zero')
elif a>0 :
    print('Positive')
else:
    print('Negative')
# Judge status: Accepted
X = int(input())

l = [1,2,3,4,5]
a = X // 100
b = X % 100

ans = 0
for i in l:
    if b % i == 0:
        if b // i <= a:
            ans = 1
            break

print(ans)
# Judge status: Accepted
from collections import defaultdict

N = int(raw_input())
A = map(int, raw_input().split())

lookup = defaultdict(int)
for a in A:
  lookup[a] += 1
  
cur_sum = 0
for k in lookup:
  cur_sum += k*lookup[k]
  
Q = int(raw_input())
for q in xrange(Q):
  b, c = map(int, raw_input().split())
  cur_sum -= b*lookup[b]
  cur_sum += c*lookup[b]
  
  lookup[c] += lookup[b]
  lookup[b] = 0
  
  print cur_sum
# Judge status: Accepted
n = int(input())
count = 0
for a in range(1,n):
    count += (n-1)//a
print(count)
# Judge status: Wrong Answer

a,b=map(int,input().split())
l=list(map(int,input().split()))
l=l+l
e=sum(l)
if e>=a:
    print("YES")
else:
    print("NO")
# Judge status: Wrong Answer
n = int(input())
t,a =  map(int, input().split())
h = list(map(int, input().split()))
ave = [float(a)-float(t-i*0.006) for i in h]
print(ave.index(min(ave))+1)
# Judge status: Accepted
S = list(input())
q = int(input())
procedure = [list(input().split()) for i in range(q)]

cnt = 0
S2 = []

for i in range(q):
    if procedure[i][0] == '1':
        cnt += 1
    if procedure[i][0] == '2':
        if (procedure[i][1] == '1' and cnt%2 == 0) or (procedure[i][1] == '2' and cnt%2 == 1):
            S2.append(procedure[i][2])
        else:
            S.append(procedure[i][2])

S2.reverse()
S = S2 + S
if cnt%2 == 1:
    S.reverse()

print(''.join(S))
# Judge status: Accepted
N = int(input())

four = 0

while 4*four <= N:
    X = N - 4*four
    if X % 7 == 0:
        print("Yes")
        exit()
    four += 1

print("No")
# Judge status: Accepted
a, b, c = map(int, input().split())
left = 4 * a * b
right = c - (a + b)
if (right < 0):
  print('No')
  exit()
right = right ** 2
if (left < right):
  print('Yes')
else:
  print('No')
# Judge status: Wrong Answer
N = int(input())
S = []
for i in range(N):
  S.append(input())
T = []
M = int(input())
for j in range(M):
  T.append(input())

S = list(set(S))
T = list(set(T))
count = 0
for i in range(len(S)):
  for j in range(len(T)):
    if S[i] != T[j]:
      count = count + 1
      
print(count)
# Judge status: Accepted
x = int(input())

for i in range(1, 1000):
    if x * i % 360 == 0:
        print(i)
        exit()
# Judge status: Accepted
import time
from datetime import date
S = list(map(int, input().split("/")))
day = date(S[0], S[1], S[2])
border = date(2019, 4, 30)
if day <= border:
  print("Heisei")
else:
  print("TBD")
# Judge status: Accepted
# coding: utf-8
# Your code here!

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

for i in range(3):
    print(a[-1+i], end=" ")
# Judge status: Accepted
a=[0,0,0]
a[0],a[1],a[2]=map(int,input().split())
a=sorted(a)
sa1=a[2]-a[0]
sa2=a[2]-a[1]
if (a[0]%2==a[1]%2==a[2]%2):
  print(sa1//2 + sa2//2)
else:
  if (sa1%2==0 and sa2%2==1):
    print((sa1//2)+1 + (sa2+1)//2)
  elif (sa1%2==1 and sa2%2==0):
    print(((sa1+1)//2)+(sa2//2)+1)
  else:
    print((sa2-sa1)//2+sa1)
# Judge status: Accepted
sx,sy,tx,ty = map(int,input().split())
ans = ''
for i in range(tx-sx):
    ans += 'R'
for i in range(ty-sy):
    ans += 'U'
ans += 'R'
for i in range(ty-sy+1):
    ans += 'D'
for i in range(tx-sx+1):
    ans += 'L'
ans += 'U'
for i in range(ty-sy):
    ans += 'U'
for i in range(tx-sx):
    ans += 'R'
ans += 'U'
for i in range(tx-sx+1):
    ans +='L'
for i in range(ty-sy+1):
    ans += 'D'
ans += 'R'
print(ans)
# Judge status: Wrong Answer
S = input()
list1 = []
divisor = 2019
while (divisor <= 200000) and (divisor > 1):
    divisor += 2019
    to_string = str(divisor)
    if to_string in S:

        list2 = [x for x in range(len(S)) if S.startswith(to_string, x)]

        for num in list2:
            list1.append(num)
print(len(list1))
# Judge status: Wrong Answer
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline

s = int(input())
arr = [0] * 1000000
cnt = 0
while True:
    if s % 2 == 0:
        s //= 2
    else:
        s = 3 * s + 1
    cnt += 1
    arr[s] += 1
    if arr[s] > 1:
        print(cnt + 1)
        exit()
# Judge status: Wrong Answer
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))

N = int(input())

s = [int(input()) for i in range(N)]


if len(list(set(a) & set(s))) or len(list(set(b) & set(s))) or len(list(set(c) & set(s))) == 3:
    print('Yes')

elif len(list(set([a[0],b[1],c[2]]) & set(s))) or len(list(set([a[2],b[1],c[0]]) & set(s))) == 3:
    print('Yes')

else:
    print('No')
# Judge status: Wrong Answer
N=int(input())
T,A=map(int,input().split())
mylist=list(map(int,input().split()))
min=T
index=0

for i in range(N):
  if(min>abs(T-0.006*mylist[i])):
    min=mylist[i]
    index=i
print(index)
# Judge status: Accepted
n=int(input())
s=input()
t=input()
while True:
  if s==t:
    break
  s=s[1:]
  t=t[:-1]
  n+=1
print(n)
# Judge status: Wrong Answer
a,b=input().split()
a=int(a)
b=int(float(b)*100)
print(int(a*b/100))
# Judge status: Accepted
l, r, d = map(int, input().split())
a = 0
for i in range(l, r+1):
  if i % d == 0:
    a += 1
print(a)
# Judge status: Wrong Answer
l,r,d = map(int,input().split())

print((r-l+1)//d)
# Judge status: Wrong Answer
n = int(input())
a = list(map(int, input().split()))
c = [0] * 9
for i in a:
    if i < 3200:
        c[i // 400] += 1
    else:
        c[8] += 1
ans = 0
for i in range(8):
    if c[i] != 0:
        ans += 1
print(ans, ans + c[8])
# Judge status: Wrong Answer
n = int(input())
l = []
 
for _ in range(n):
    a = int(input())
    l.append(a)

l.sort()
print(l)
ans = 0
cnt = 1
tmp = l[0]
for i in range(1,len(l)):
    if tmp == l[i]:
        cnt += 1
        tmp = l[i]
    else:
        if cnt%2 != 0:
            ans += 1
            cnt = 1
            tmp = l[i]
        else:
            cnt = 1
            tmp = l[i]

print(ans)
# Judge status: Accepted
import collections, math, bisect

local = False
if local:
    file = open("input.txt", "r")
    import time

def inp():
    if local:
        return file.readline().rstrip()
    else:
        return input().rstrip()

def ints():
    return [int(_) for _ in inp().split()]

if local:
    start=time.time()

N, K = ints()
D = [False]*10

for d in ints():
    D[d] = True

while any([D[int(d)] for d in str(N)]):
    N+=1

print(N)

if local:
    fin = (time.time()-start)*1000
    print("{:.2f}".format(fin) + "ms")
# Judge status: Accepted
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))

sum_ = 0
for i in range(n):
  if a[i]>=b[i]:
    a[i]-=b[i]
    sum_+=b[i]
    b[i]=0
  else:
    b[i]-=a[i]
    sum_+=a[i]
    a[i]=0
    if a[i+1]>=b[i]:
      a[i+1]-=b[i]
      sum_+=b[i]
      b[i]=0
    else:
      b[i]-=a[i+1]
      sum_+=a[i+1]
      a[i+1]=0
print(sum_)
# Judge status: Wrong Answer
n = int(input())
t, a = map(int, input().split())
h = list(map(float, input().split()))

dt = 10000000
ans = 0
for i in range(len(h)):
    print(i)
    tmp = float(t) - 0.006 * h[i]
    if dt > abs( a - tmp ):
        dt = abs( a - tmp )
        ans = i + 1

print(ans)
# Judge status: Wrong Answer
s = input()
for i in range(7):
    if s[i] + s[-7 + i] == "keyence":
        print("YES")
        exit()
print("NO")
# Judge status: Accepted
x,n = map(int,input().split())
if n == 0:
  print(x)
  exit()
a = list(map(int,input().split()))
b = [0 for _ in range(-300,301)]
for y in a:
  b[y+300] = 1
c = []
for i in range(601):
  j = i - 300
  if b[i] == 0:
    c.append([abs(x-j),j])
print(min(c)[1])
# Judge status: Wrong Answer
n,m = map(int,input().split())
a = sorted(map(int,input().split()))

import bisect

for i in range(m):
    a[-1] //= 2
    
    if 1 < len(a):
        if a[-2] > a[-1]:
            bisect.insort(a,a[-1])
            a = a[:-1]
    
print(sum(a))
# Judge status: Accepted
n,k=map(int,input().split())
a=list(map(int,input().split()))
for i in range(n-k):
    print(["No","Yes"][a[i] <a[i+k]])
# Judge status: Accepted
N, K = map(int, input().split())
X = list(map(int, input().split()))
ans = 10**9

for i in range(N-K+1):
    if X[i] >= 0:
        ans = min(ans, X[K+i-1])
    elif X[K+i-1] <= 0:
        ans = min(ans, -X[i])
    else:
        ans = min(ans, 2*X[K+i-1]-X[i], X[K+i-1]-2*X[i])
print(ans)
# Judge status: Accepted
import sys
input = sys.stdin.readline

n=int(input())
D={}

for i in range(1,n+1):
    s=(str(i)[0],str(i)[-1])
    if s not in D:
        D[s]=1
    else:
        D[s]+=1
ans=0
for i in D:
    t=(i[1],i[0])
    if t in D:
        ans+=D[t]*D[i]
print(ans)
# Judge status: Accepted
S = list(str(input()))
T = list(str(input()))

l = len(S) - len(T)
f = len(T)

for i in range(l+1):
    temp = 0
    for j in range(len(T)):
        if S[i+j] != T[j]:
            temp += 1
    if f > temp:
        f = temp

print(f)
# Judge status: Accepted
L,R,d = map(int, input().split())

if L%d==0:
    print(R//d-L//d+1)
else:
    print(R//d-L//d)
# Judge status: Wrong Answer
N, C, K = list(map(int, input().split()))
T = []
for i in range(N):
  T.append(int(input()))

bus = []
departure=0

T.sort()

for passenger in T:
  if bus == []:
    bus.append(passenger)
    
  elif passenger <= bus[0]+K and len(bus)<(C-1):
    bus.append(passenger)
  
  else:
    bus.clear()
    departure+=1
    
if bus != []:
  print(departure + 1)
else:
  print(departure)
# Judge status: Wrong Answer
import sys
from collections import Counter

N = int(input())
A = list(map(int, sys.stdin.readline().rsplit()))

C = list(Counter(A).items())
C.sort(reverse=True)

a = 0
b = 0
for c in C:
    if c[1] > 1 and a == 0 and b == 0:
        a = c[0]
    elif c[1] > 1 and a != 0 and b == 0:
        b = c[0]
        break

print(a * b)
# Judge status: Accepted
N, K = map(int, input().split())
A = list(map(int, input().split()))

B = [0] * N
C = []

C.append(0)
now = 0
B[0] = 1
for i in range(N):
    now = A[now] - 1
    if B[now] == 1:
        break
    else:
        C.append(now)
        B[now] = 1

mae = 0
for i in range(len(C)):
    if C[i] == now:
        mae = i
        break

ato = len(C) - 1

if K + 1 <= mae:
    print(C[K] + 1)
else:
    print(C[mae + (K - mae) % (ato - mae + 1)] + 1)
# Judge status: Accepted
d,n = map(int,input().split())
if n == 100:
    n += 1
print(100 ** d * n)
# Judge status: Accepted
A,B = map(int,input().split())

if A == B:
  print(2*A)
else:
  print(max(A,B)+max(A,B)-1)
# Judge status: Accepted
(h, n), *m = [[*map(int, i.split())] for i in open(0)]
dp = [0] * 20001
for i in range(1, h + 1):
    dp[i] = min(dp[i-a]+b for a, b in m)
print(dp[h])
# Judge status: Accepted
from decimal import Decimal, getcontext

getcontext().prec = 50

a, b, c = map(Decimal, input().split())
print('Yes' if a.sqrt() + b.sqrt() < c.sqrt() else 'No')
# Judge status: Accepted
s=input().split()[1][0]
print("A"+s+"C")
# Judge status: Wrong Answer
N = input()
if N[-1] == "3":
    print("bon")
elif N[-1] == "0" or N[-1] == "1" or N[-1] == 6 or N[-1] ==8:
    print("pon")
else:
    print("hon")
# Judge status: Accepted
n,m,x=map(int,input().split())
lis=[list(map(int,(input().split()))) for i in range(n)]

c=float('inf')
p=0
for i in range(2**(n+1)):
    al=[0]*m
    cost=0
    for j in range(n):
        if (i>>j)&1:
            for k in range(1,m+1):
                al[k-1]+=lis[j][k]
            cost+=lis[j][0]
    if min(al)>=x:
        c=min(c,cost)
        p=1
print(c) if p==1 else print(-1)
# Judge status: Wrong Answer
n = int(input())
a_list = []
b_list = []
ans = 0

for i in range(n):
    a,b = map(int,input().split())
    a_list.append(a)
    b_list.append(b)

for i,j in zip(a_list[::-1],b_list[::-1]):
    if (i+ans) > j:
        if (i+ans)%j != 0:
            inc = j - ((i+ans)%j)
            ans += inc
    else:
        ans += (j-(i+ans))

print(ans)
# Judge status: Accepted
n,m=map(int,input().split())
l=m//n #gの下限値

def make_divisors(n):
    D=[]
    for i in range(1, int(n**0.5)+1):
        if n%i==0:
            D.append(i)
            if i!=n//i:
                D.append(n//i)
    return list(sorted(D))

D=make_divisors(m)
ans=1

for d in D:
    if d>l:
        continue
    if m//d>=n:
        ans=d

print(ans)
# Judge status: Accepted
d,n = map(int,input().split())
if n==100:
  n=101
print(n*100**d)
# Judge status: Wrong Answer
N = int(input())
applist = list(map(int, input().split()))

flag = 0
for i in applist:
  if i % 2 == 0:
    if i % 3 == 0 or i % 5 == 0:
      flag = 1
    else:
      flag = 0
      break

if flag == 1:
  print("APPROVED")
else:
  print("DENIED")
# Judge status: Accepted
n, k = map(int, input().split())
print((n + k - 3) // (k - 1))
# Judge status: Wrong Answer
a,b,c,x,y = map(int,input().split())

if a//2 + b//2 > c:
    buf = min(x,y) * c * 2
    buf2 = max(x,y) * c * 2
    if min(x,y) == y:
        tmp = buf + abs(x-y) * a
    else:
        tmp = buf + abs(x-y) * b
    ans = min(buf2,tmp)
else:
    ans = x * a + y * b

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

dis = abs(a-b)

if dis % 2 == 0:
  print(dis // 2)

else:
  high = n - min(a, b)
  low = max(a, b) - 1
  print(min(high, low))
# Judge status: Wrong Answer
n = int(input())
s = [input() for _ in range(n)]
az = "abcdefghijklmnopqrstuvwxyz"
counts = {}

for v in az:
    counts[v] = n
    for i in range(n):
        counts[v] = min(counts[v], s[i].count(v))

ans = ""
for k, v in counts.items():
    ans += k*v
print(ans)
# Judge status: Accepted
import sys
import bisect
input = sys.stdin.readline


def readstr():
    return input().strip()


def readint():
    return int(input())


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


def readstrs():
    return input().split()


def main():
    N = readint()
    X = list(readnums())
    xs = sorted(X)
    for i in X:
        d = bisect.bisect_left(xs, i)
        if d >= N // 2:
            print(xs[N // 2 - 1])
        else:
            print(xs[N // 2])


if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
number = int(input())
ans = 0

for i in range(1,number+1):
  if len(str(i)) % 2 != 1:
    ans += 1

print(ans)
# Judge status: Wrong Answer
i = input()
a = i.split(" ")
n = len(i)
if n == 5:
  N = int(a[0])
  A = int(a[1])
  B = int(a[2])
  if A == 0:
    print("0")
  elif N-(A+B) == 0:
    print(A)
  elif A+B != N:
    x = N-(A+B)
    print(A+x)
# Judge status: Accepted
x, n = map(int, input().split())
p = list(map(int, input().split()))

for i in range(x+1):
    if not(x - i) in p:
        print(x - i)
        exit()
    elif not(x + i) in p:
        print(x + i)
        exit()
print(x)
# Judge status: Wrong Answer
x=int(input())
if(x&1000==0):
    print(0)
else:
    print(x%1000)