peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Wrong Answer
r = int(input())
print(3.14159*r)
# Judge status: Accepted
n = int(input())
count = 0

for i in range(n):
  d1,d2 = map(int,input().split())
  if(d1 == d2):
    count += 1
  else:
    count = 0
  if(count == 3):
    print("Yes")
    break

if(count != 3):
  print("No")
# Judge status: Accepted
n = int(input())
S = input()
a = ord('A')
z = ord('Z')
ans = ''
for s in S:
    if ord(s) + n <= 90:
        ans += chr(ord(s) + n)
    else:
        ans += chr(a + ord(s) + n - z - 1)
print(ans)
# Judge status: Accepted
N,A,B,C,D = map(int,input().split())
S = input()

if "##" in S[A-1:C] or "##" in S[B-1:D]:
  print("No")
elif C < D:
  print("Yes")
else:
  if "..." in S[B-2:D+1]:
    print("Yes")
  else:
    print("No")
# Judge status: Accepted
x,y,a,b,c = [int(x) for x in input().split()]
p = [int(x) for x in input().split()]
q = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]

P = sorted(p, reverse=True)
Q = sorted(q, reverse=True)
l = P[:x] + Q[:y] + r
L = sorted(l, reverse=True)

print(sum(L[:(x+y)]))
# Judge status: Accepted
n = input()
if len(n)==6 and n[2]==n[3] and n[4]==n[5]:
	print("Yes")
else:
	print("No")
# Judge status: Accepted
N = int(input())
al = list(map(int,input().split()))
sss=0
pss=0
for i in range(1,N):
    pss+=al[i-1]
    sss+=al[i]*pss
print(sss%1000000007)
# Judge status: Accepted
#!/usr/bin/env python3
n,m = map(int,input().split())
INF = m
ans = INF
# どうしてTLE？？O(root(m))で10**4だからOKでは？ m ** 1/2だとm /2 になる
for i in range(1,int(m**(1/2)) + 1):
    if m % i == 0:
        # i,m//iのうち、n 以上でmaxなものをansに入れる
        if i >= n: ans = min(ans,i)
        if m//i >= n: ans = min(ans,m//i)
print(m//ans)
# Judge status: Accepted
n=int(input())
if n<=111:
    print(111)
for i in range(1,10):
    if 111*i<n<=111*(i+1):
        print(111*(i+1))
# Judge status: Accepted
n,k = map(int,input().split())

ab = []
for i in range(n):
  ta,tb = map(int,input().split())
  ab.append([ta,tb])

ab = sorted(ab,key=lambda x:x[0])

count = k
for i in range(n):
  count -= ab[i][1]
  if count <= 0:
    print(ab[i][0])
    break
# Judge status: Accepted
A, B, C = map(int, input().split())
if (A * B * C) % 2 == 0 :
    print(0)
else :
    l = [A, B, C]
    l.sort()
    print(l[0] * l[1])
# Judge status: Accepted
N, x = map(int, input().split())
A = list(map(int, input().split()))
A.sort(reverse=True)

if sum(A) < x:
    print(N-1)
    exit()

A = [1] + A
ans = 0
while A[-1] <= x:
    x -= A[-1]
    A.pop()
    ans += 1
print(ans)
# Judge status: Accepted
N, K = [int(n) for n in input().split()]

a = N - K + 2 + (N + 1)*(N-K+2)*(K+N+1) // 2 - ((N + 1) * (N + 2) * (2 * N + 3) - K * (K - 1) * (2 * K - 1)) // 6

print(a % 1000000007)
# Judge status: Wrong Answer

def Postal_Code(a , b , s):

    ans = "No"

    if s[:a].isdigit() and s[b:].isdigit() and s[a] == '-':
        ans = "Yes"

    return ans

def main():
    a , b = map(int , input().split())
    s = str(input())
    print(Postal_Code(a , b , s))

if __name__ == '__main__':
    main()
# Judge status: Accepted
a,b,c = map(int,input().split())

if b-a == c-b:
    print('YES')
else:
    print('NO')
# Judge status: Accepted
n = int(input())
li = list(map(int,input().split()))
x = 0

for i in range(n):
    if li[i] < 0:
        li[i] *= -1
        x += 1

if x%2 == 0:
    print(sum(li))
else:
    print(sum(li)-min(li)*2)
# Judge status: Wrong Answer
from copy import deepcopy

N = int(input())
X = list(map(int,input().split()))
Y = deepcopy(X)
Y.sort()
med1 = Y[N//2]
med2 = Y[N//2-1]
##print("med1:",med1,"med2",med2)
for i in range(N):
    if i  == N//2 -1 or i == N//2:
        print(med2)
    else:
        print(med1)
# Judge status: Wrong Answer
import sys
input = sys.stdin.buffer.readline


#sys.setrecursionlimit(10**9)
#from functools import lru_cache

def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()

#import numpy as np

def main():
	n=II()
	A=LI()
	A.sort(reverse=True)

	ans=A[0]
	ans+=2*sum(A[1:(n+1)//2-1])

	if n%2:
		ans+=A[n//2]

	print(ans)











if __name__ == "__main__":
	main()
# Judge status: Accepted
a = input()
if(a[0]=='7' or a[1]=='7' or a[2]=='7'):
  print("Yes")
else:
  print("No")
# Judge status: Accepted
x = int(input())

'''
if x <= 6:
    print(1)
'''
judge = x%11
#print(judge)
ans = 0
if judge == 0:
    ans = 2*(x//11)
elif judge > 6:
    ans = 2*(x//11)+2
else:
    ans = 2*(x//11)+1

print(ans)
# Judge status: Wrong Answer
X=input()
a=X
if len(X)<=100000:
    while 'ST' in a:
        a=a.replace('ST','',int(1e5))
    print(len(a))
# Judge status: Accepted
import sys
from fractions import gcd
from functools import reduce
def input(): return sys.stdin.readline().rstrip()

sys.setrecursionlimit(10 ** 9)
def main():
    _, X = input().split()
    x = sorted(map(int, input().split() + [X]))
    min_x = x[0]
    x = map(lambda a: a - min_x, x[1:])
    print(reduce(gcd, x))

if __name__ == '__main__':
    main()
# Judge status: Accepted
N = int(input())
a = list(map(int, input().split()))
x = a[0]
total = sum(a)
y = total - x
ans = abs(x - y)
for i in range(1, N-1):
    x += a[i]
    y -= a[i]
    m = abs(x-y)
    if ans > m:
        ans = m
print(ans)
# Judge status: Accepted
from math import atan,pi

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

if b-x/a**2 <= x/a**2:print(atan((b-x/a**2)/(a/2))*(180/pi))
else:
  y = x/a*2/b
  print(atan(b/y)*(180/pi))
# Judge status: Wrong Answer
import sys
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()


N, P = readnums()
A = map(lambda x: x % 2, readnums())

if not sum(A):
    print(0)
else:
    print(2 ** N // 2)
# Judge status: Accepted
n=int(input())
s=input()
Xmax=0
x=0
for i in range(n):
	if s[i]=="I":
		x+=1
		Xmax=max(Xmax,x)
	else:
		x-=1
print(Xmax)
# Judge status: Wrong Answer
from collections import Counter
n = int(input())
l = []
for i in range(n):
  l.append(input())

d = Counter(l)
m = d.most_common()[0][1]
#print(m)
ans = []
for k, v in d.most_common():
  if v != m:
    break
  ans.append(k)

print("\n".join(ans[::-1]))
# Judge status: Wrong Answer
s = input()
t = input()

for i in range(len(s)):
    if s[i:] + s[:i] == t:
        print("Yes")
    break
else:
    print("No")
# Judge status: Accepted
D,N=map(int,input().split())

if D==0:
  if N!=100:
    print(N)
  else:
    print(101)
elif D==1:
  if N!=100:
    print(N*100)
  else:
    print(10100)
else:
  if N!=100:
    print(N*10000)
  else:
    print(1010000)
# Judge status: Accepted
X, K, D = map(int, input().split())
X = abs(X)
k1 = X // D
if k1 >= K:
    print(abs(X - D * K))
    exit()

k = K - k1
x = X % D

while k > 0:
    x = abs(x - D)
    k -= 1
    if k == 0:
        print(x)
        exit()
    if abs(x) < D:
        if k % 2 == 0:
            print(abs(x))
        else:
            print(D-abs(x))
        exit()
# Judge status: Accepted
import math
from collections import defaultdict
ml=lambda:map(int,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:input()

"""========main code==============="""

t=ii()
x=ii()
y=ii()
z=ii()
k=min(t,x)
print(k*y+(t-k)*z)
# Judge status: Wrong Answer
s = int(input())
count = 0

while s != 1:
  count += 1
  if s % 2 == 0:
    s = s // 2
  else:
    s = 3 * s + 1

print(count + 2)
# Judge status: Accepted
a, b, k = map(int, input().split())


if k <= a:
    print(a-k, b)
elif k <= a + b:
    print(0, b-k+a)
else:
    print(0, 0)
# Judge status: Wrong Answer
K,N = map(int,input().split())
A = list(map(int,input().split()))
ls = []
for i in range(N):
    #print(i)
    if i != N-1:
        ls.append(A[i+1]-A[i])
    else:
        ls.append(abs(A[0]-A[i]))
#print(ls)
print(sum(ls)-max(ls))
# Judge status: Accepted
from collections import defaultdict

def main():
    X,Y = [int(x) for x in input().split()]
    ans = 0
    while X<=Y:
        X *= 2
        ans += 1
    print(ans)


if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
N=int(input())
A=input()

import math


def ans125(N:int,A:str):
    A_list=list(map(int,A.split()))
    most=0
    for i in range(N):
        B_list = list(map(int, A.split()))
        del B_list[i]
        for j in range(N-1):
           if math.gcd(A_list[i],B_list[j])>=most:
               most=math.gcd(A_list[i],B_list[j])

    return most

print(ans125(N,A))
# Judge status: Wrong Answer
import sys

X = int(input())

kyori = 0
count = 0

if X < 3:
    print(X)
else:
    for i in range(1, X+1):
        kyori += i
        count += 1
        if kyori == X:
            print(count)
            sys.exit()
        elif kyori > X:
            a = i
            x = kyori-a
            break
    count = count -2
    ans = count + X-x +1
    print(ans)
# Judge status: Wrong Answer
n, m = map(int, input().split())
if n == 1:
    print(m-2)
elif m == 1:
    print(n-2)
else:
    print((n-2)*(m-2))
# Judge status: Accepted
n = int(input())
lis = list(map(int,input().split()))
lis[0]-=1
for i in range(n-1):
  if lis[i] < lis[i+1]:
    lis[i+1] -= 1
  elif lis[i] > lis[i+1]:
    print("No")
    exit()
print("Yes")
# Judge status: Accepted
s, t = [input() for _ in range(2)]
print("Yes" if "".join(sorted(s)) < "".join(sorted(t, reverse=True)) else "No")
# Judge status: Accepted
vowel = set(['a', 'i', 'u', 'e', 'o'])
c = input()
if c in vowel:
    print('vowel')
else:
    print('consonant')
# Judge status: Accepted
A, B, T = list(map(int, input().split()))
print(T // A * B)
# Judge status: Accepted
n, m = (int(x) for x in input().split())
ab = []
for _ in range(m):
    a, b = (int(x) for x in input().split())
    ab.append([a-1, b-1])

box = [1]*n

red = [0]*n

red[0] = 1

for x,y in ab:
    if 0 < red[x]:
        red[y] = 1
    box[x] -= 1
    box[y] += 1

    if box[x] == 0:
        red[x] = 0
print(sum(red))
# Judge status: Wrong Answer
def main():
    n = int(input())
    def Base_10_to_n(X, n):
        if (int(X/n)):
            return Base_10_to_n(int(X/n), n)+' '+str(X%n)
        return str(X%n)
    P = list(map(int, Base_10_to_n(n, 26).split()))
    ans = [0] * len(P)
    for i, p in enumerate(P):
        ans[i] = chr(96 + p)


    print(''.join(ans))


if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
n = int(input())
b = list(map(int, input().split()))
a = []
if len(b) > 1:
    for i in range(len(b)-1):
        if b[i]<b[i+1]:
            a.append(b[i])
            if b[i]==min(b):
                a.append(b[i])
        else:
            a.append(b[i+1])
    a.append(b[len(b)-1])
else:
    a.append(b[0])
    a.append(b[0])
print(sum(a))
# Judge status: Accepted
k = int(input())
even = 0
odd = 0
for i in range(1, k+1):
    if i % 2 == 0:
        even += 1
    else:
        odd += 1

print(even*odd)
# Judge status: Accepted
import statistics
import math

n = int(input())
A = []
B = []
for _ in range(n):
    a, b = map(int,input().split())
    A.append(a)
    B.append(b)

A_m = statistics.median(A)
B_m = statistics.median(B)
if n%2 == 1:
    num = B_m - A_m +1
elif n %2 ==0:
    num = 2*B_m - 2*A_m +1
print(int(num))
# Judge status: Accepted
N, M = map(int, input().split())
pSs = [list(map(str, input().split())) for _ in range(M)]

#%%

ACs = [False for _ in range(N)]
WAs = [0 for _ in range(N)]

for pS in pSs:
    problem = int(pS[0]) -1
    answer = pS[1]
    if ACs[problem] == True:
        continue
    else:
        if answer == "WA":
            WAs[problem] += 1
        else:
            ACs[problem] = True

num_WA = 0
for i, WA in enumerate(WAs):
    if ACs[i] == True:
        num_WA += WA

print(sum(ACs), num_WA)
# Judge status: Accepted
import sys
from math import ceil
def input(): return sys.stdin.readline().strip()


def main():
    a, b = map(int, input().split())
    print(ceil((a + b) / 2))



if __name__ == "__main__":
    main()
# Judge status: Accepted
D,N=map(int,input().split())
if N==100:
    N+=1
print(N*(100**D))
# Judge status: Wrong Answer
n,a,b,c,d = map(int,input().split())

s=input()

s=list(s)

for i in range(1,n):
    if s[i-1] == '#' and s[i] == '#':
        if a < i-1 and i < max(c,d):
            print('No')
            exit()

if c < d:
    print('Yes')
else:
    for i in range(b-1,d-1):
        if s[i] == s[i+1] == s[i+2] == '.':
            print('Yes')
            exit()
    print('No')
# Judge status: Wrong Answer
from math import factorial as f

n, m = (int(i) for i in input().split())
if n == m:
    print(f(n) * f(m) * 2 % (10 ^ 9 + 7))
elif abs(n - m) == 1:
    print(f(n) * f(m) % (10 ^ 9 + 7)) 
else:
    print(0)
# Judge status: Wrong Answer
a,b,c,d=map(int,input().split())
ans=-10**9

if  b<=0 and d<=0:
    ans=a*c
elif b>0 and d>0:
    ans=b*d
elif b>0 and d<=0:
    ans=a*d
elif b<=0 and d>0:
    ans=b*c

print(ans)
# Judge status: Accepted
A,B,K=map(int,input().split())
A,B=min(A,B),max(A,B)
cnt=0
for i in reversed(range(1,A+1)):
    if A%i==0 and B%i==0:
        cnt+=1
    if(cnt==K):
        print(i)
        exit()
# Judge status: Accepted
def ATCoder(S):
    count = 0
    res = 0
    for i in range(len(S)):
        if S[i] == "A" or S[i] == "C" or S[i] == "G" or S[i] == "T":
            count += 1
            if count > res:
                res = count
        else:
            count = 0
    return res



if __name__ == "__main__":
    S = str(input())
    print(ATCoder(S))
# Judge status: Accepted
d = int(input())
e = 25 - d
print("Christmas"+" Eve"*e)
# Judge status: Accepted
import math

X = int(input())
aa = math.gcd(X, 360)
ans = int(360/aa)

print(ans)
# Judge status: Accepted
N = int(input())
s = [input() for i in range(N)]
for v in ['AC', 'WA', 'TLE', 'RE']:
    print('{} x {}'.format(v, s.count(v)))
# Judge status: Accepted
import math
import fractions

A,B = map(int,input().split())

g = fractions.gcd(A,B)

if g == 1:
    print(1)
    exit()

ans = 1

for i in range(2,math.floor(math.sqrt(g))+1):
    if g % i == 0:
        ans += 1
        while g % i == 0:
            g = g//i
if g != 1:
    ans += 1

print(ans)
# Judge status: Accepted
import math
n,h = map(int ,raw_input().split())
ais = [map(int, raw_input().split()) for _ in range(n)]
ais.sort(key = lambda x: (-x[1],x[0]))
r,m,cumul = h, max(ais)[0],0
for i in range(-1,len(ais)):
	if i >= 0: cumul += ais[i][1]
	r = min(r, i+1 + int(math.ceil(max(0,h - cumul) /  float(m))))
print r
# Judge status: Accepted
D, T, S = map(int, input().split())
print('Yes' if D / S <= T else 'No')
# Judge status: Accepted
n = int(input())
ans = 0
for i in range(1, n+1):
    ans += (i+(n-n%i))*(n//i)//2
print(ans)
# Judge status: Accepted
D = int(input())
C = list(map(int, input().split()))
S = list(list(map(int, input().split())) for i in range(D))

manzoku = 0
yasumi= [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

for day in range(D):
  yasumi = list(map(lambda x: x + 1, yasumi))
  zouka = 0
  for t in range(26):
    if zouka < S[day][t] + C[t] * yasumi[t]:
      zouka = S[day][t] + C[t] * yasumi[t]
      best = t
  manzoku += zouka
  yasumi[best] = 0
  print(best + 1)
# Judge status: Accepted
a,b = map(int,input().split())
A = str(a) * b
B = str(b) * a
x = [A, B]
x.sort()
print(x[0])
# Judge status: Accepted
a,b,c,k=map(int,input().split())
if k<=a:
  print(k)
elif a<k<=a+b:
  print(a)
else:
  print(a-(k-a-b))
# Judge status: Accepted
n, x, y = map(int,input().split())
ls = [0] * n
for u in range(1, n):
    for v in range(u, n+1):
        u2x = abs(u-x)
        v2y = abs(v-y)

        d = min(v-u, u2x + 1 + v2y)
        ls[d] += 1

for k in range(1, n):
    print(ls[k])
# Judge status: Accepted
s=list(input())
t=list(input())
s.sort()
t.sort(reverse=True)
if len(s) < len(t):
  len = len(s)
  flg_s=1
else:
  len = len(t)
  flg_s=0
for i in range(len):
  if ord(s[i]) < ord(t[i]):
    print('Yes')
    exit(0)
  elif ord(s[i]) > ord(t[i]):
    print('No')
    exit(0)
if flg_s == 1:
  print('Yes')
else:
  print('No')
# Judge status: Wrong Answer
import numpy as np
N = int(input())
A = np.array(list(map(int, input().split())))
Q = int(input())
for _ in [0]*Q:
    b, c = map(int, input().split())
    A[A==b] = c
    print(A)
    print(np.sum(A))
# Judge status: Accepted
n=int(input())
dic={}
for i in range(n):
  s=input()
  if s in dic:
    dic[s]+=1
  else:dic[s]=1
sc=[[] for _ in range(n+1)]
mx=0
for i in dic:
  sc[dic[i]].append(i)
  mx=max(mx,dic[i])

for i in sorted(sc[mx]):
  print(i)
# Judge status: Accepted
a,b=map(int,input().split())

if a<=b:
  print(a)
else:
  print(a-1)
# Judge status: Accepted
n, k = map(int, input().split())
a = list(map(int, input().split()))
print(-(-(n - 1) // (k - 1)))
# Judge status: Wrong Answer
n = int(input())

a = int((n**0.5)//1)
for i in range(1,a):
  if n%i==0:
    print(int(i+(n//i)-2))
    exit()
# Judge status: Wrong Answer
n,c,k=map(int,input().split())
t=[]
for _ in range(n):
  t.append(int(input()))
t.sort()
renow=0
cun=0
for i in range(n):
  if t[i]-t[renow]>=k:
    cun+=1
    renow=i
  elif i-renow+1>=c:
    cun+=1
    renow=i+1
if renow>=n:
  print(cun)
else:
  print(cun+1)
# Judge status: Accepted
A, B = map(int, input().split())
cnt = 0
tap = 0
outlet = 1
while outlet < B:
    tap += 1
    outlet -= 1
    outlet += A

print(tap)
# Judge status: Accepted
import math

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

if A>=B:
    print('delicious')
elif B-A>X:
    print('dangerous')
else:
    print('safe')
# Judge status: Wrong Answer
x = input()
s_count = x.count('S')
t_count = x.count('T')
count = 0
l = 0
r = len(x)-1

for i in range(len(x)):
    if s_count == 0 or t_count == 0:
        break
    if x[i]=='S':
        s_count -= 1
        if t_count > 0:
            t_count -= 1
            count += 1
    else:
        t_count -= 1
print(len(x)-count*2)
# Judge status: Accepted
n=int(input())
p=list(map(int,input().split()))
ok=0
for i in range(1,n+1):
  if i!=p[i-1]:
    ok+=1
if ok<=2:
  print('YES')
else:
  print('NO')
# Judge status: Accepted
data = input()
data = data.replace("eraser","").replace("erase","").replace("dreamer","").replace("dream","")
if data:
    print("NO")
else:
    print("YES")
# Judge status: Accepted
from fractions import gcd
n, t = map(int, input().split())
x = list(map(lambda x: int(x) - t, input().split()))
g = x[0]
for i in range(1, n):
    g = gcd(g, x[i])
print(abs(g))
# Judge status: Accepted
def comb(n, r):
    p, q = 1, 1
    for i in range(r):
        p = p * (n - i) % mod
        q = q * (i + 1) % mod
    return p * pow(q, mod - 2, mod) % mod

X, Y = map(int, input().split())
mod = 10 ** 9 + 7
if (X + Y) % 3:
    print(0)
else:
    if 2 * Y - X < 0 or 2 * X - Y < 0:
        print(0)
    else:
        n = (X + Y) // 3
        r = (2 * Y - X) // 3
        print(comb(n, r))
# Judge status: Wrong Answer
s = input()
sc = s[::-1]
n = int(input())
l = [list(input().split()) for i in range(n)]

last = 1

for i in range(n):
    if l[i][0] == '1':
        last = last * -1
    else:
        s = l[i][2] + s
        sc += l[i][2]

if last > 0:
    print(s)
else:
    print(sc)
# Judge status: Wrong Answer
a,b = map(int,input().split())

if a < 0 and b < 0:
  for i in range(a,b+1):
    i += 1
  if i % 2 == 0:
    print('Positive')
  else:
    print('Negative')

elif a>0:
  print('Positive')

else:
  print('Zero')
# Judge status: Accepted
#!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n,time= map(int,input().split())
c = []
t = []
for i in range(n):
    a,b = map(int,input().split())
    c.append(a)
    t.append(b)
ans = 1001
for i in range(n):
    if time >= t[i]:
        if ans >= c[i]: ans = c[i]
if ans == 1001: print("TLE")
else: print(ans)
# Judge status: Accepted
ST = input().split()
s = ""
s += ST[1]
s += ST[0]
print(s)
# Judge status: Accepted
n=int(input())
A=list(map(int,input().split()))
dic={}
ans=0
for i in range(n):
    x=i-A[i]
    y=i+A[i]
    if x in dic:
        ans+=dic[x]
    if y in dic:
        dic[y]+=1
    else:
        dic[y]=1
print(ans)
# Judge status: Accepted
x, y = map(int, input().split())
count = 1
while x <= y:
    x *= 2
    count += 1
print(count-1)
# Judge status: Accepted
S = input()
if S[1] == "B":
    print("ARC")
else:
    print("ABC")
# Judge status: Wrong Answer
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())
#l = list(map(int, input().split()))
#l = [list(map(int,input().split())) for i in range(n)]
#a = [list(input()) for _ in range(n)]
#a = [int(input()) for _ in range(n)]

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

if ( (a*2+b*2) >= c):
    print("Yes")
else:
    print("No")
# Judge status: Accepted
n = int(input())
now = [0, 0, 0]
def ng():
  print('No')
  exit()
for i in range(n):
  t, x, y = map(int, input().split())
  if t % 2 != (x + y) % 2:
    ng()
  if abs(x - now[1]) + abs(y - now[2]) > t - now[0]:
    ng()
  now = [t, x, y]
print('Yes')
# Judge status: Wrong Answer
a, b, c = map(int, input().split())

if (b - a) == (c - b):
    print('YES')
elif (a - b) == (b - c):
    print('YES')
else:
    print('No')
# Judge status: Wrong Answer
ab = input().replace(" ", "")
ab = int(ab)

import numpy as np
s = np.array(range(4,101))
s = s**2
s = list(s)

if ab in s:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
import sys

S = input()
T = input()
lenS = len(S)
lenT = len(T)
ans = ""
for i in range(lenS-lenT,-1,-1):
    for j in range(lenT):
        if S[i+j]!=T[j] and S[i+j]!="?":
            break
    else:
        ans = S[:i]+T+S[i+lenT:]
        ans = ans.replace("?","a")
        print(ans)
        sys.exit()
print("UNRESTORABLE")
# Judge status: Accepted
s = input()
res = 10 ** 100
for i in range(len(s) - 2):
    res = min(res, abs(753 - int(s[i:i + 3])))
print(res)
# Judge status: Wrong Answer
n=input()
if n[0]==9 or n[1]==9:
    print('Yes')
    exit()
else:
    print('No')
# Judge status: Wrong Answer
S=str(bin(abs(int(input()))))
print(S[2:])
# Judge status: Accepted
S = input()
cnt = 1
tf = False
a = S[0]

for i in range(1, len(S)):
    if tf:
        cnt += 1
        a = S[i-1] + S[i]
        tf = False
    else:
        if a == S[i]:
            tf = True
        else:
            cnt += 1
            a = S[i]

print(cnt)
# Judge status: Accepted
import sys
n, a, b, c, d = map(int, input().split())
s = input()
if any(s[i]==s[i+1]=="#" for i in range(a-1, c-2)) or any(s[i]==s[i+1]=="#" for i in range(b-1, d-2)):
    print("No")
elif c<d:
    print("Yes")
else:
    for i in range(b-1, d):
        if s[i-1]==s[i]==s[i+1]==".":
            print("Yes")
            sys.exit()
    print("No")
# Judge status: Wrong Answer
n = int(input())

for i in range(n,999):
    one = i % 10
    ten = i //10 % 10
    hund = i // 100
    if one == ten and ten == hund:
        print(hund*100+ten*10+one)
        break
# Judge status: Accepted
n,m=map(int,input().split())
if n==1 and m==1:
    print(1)
elif n==1:
    print(m-2)
elif m==1:
    print(n-2)
else:
    print(n*m-(2*n+2*m-4))
# Judge status: Accepted
#!/usr/bin/env python3
import sys

def main():
    input = sys.stdin.readline
    n = int(input())
    Z = []
    W = []
    for _ in range(n):
        x, y = map(int, input().split())
        z = x + y
        w = x - y
        Z.append(z)
        W.append(w)
    Z.sort()
    W.sort()
    print(max(abs(Z[0] - Z[-1]), abs(W[0] - W[-1])))



if __name__ == '__main__':
    main()
# Judge status: Accepted
from math import sqrt

def I(): return int(input())
def MI(): return map(int, input().split())
def LMI(): return list(map(int, input().split()))
MOD=10 ** 9 + 7


N = I()
rt = sqrt(N)
if rt.is_integer():
    print(N)
else:
    print(int(rt) ** 2)
# Judge status: Wrong Answer
k = int(input())
s = input()

if len(s) <k:
    print(s)
else:
    print(s[:k]+"...")
# Judge status: Accepted
import sys
import numpy as np

n, m, *lr = map(int, sys.stdin.read().split())
l, r = np.array(lr).reshape(-1, 2).T

def main():
    res = max(0, r.min() - l.max() + 1)
    print(res)

if __name__ ==  '__main__':
    main()