peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Wrong Answer
line = input()
a, b = [int(n) for n in line.split()]

if a>=b:
    c = a/2
    d = 16-a
    if c>d:
        print(":(")
    else:
        print("Yay!")
else:
    c = b/2
    d = 16 -b
    if c>d:
        print(":(")

    else:
        print("Yay!")
# Judge status: Accepted
x=int(input())
if x%100>(x//100)*5:
  print(0)
else:
  print(1)
# Judge status: Accepted
A,B,C,K = map(int,input().split())

out = min(A,K) - max(0,K-A-B)
print(out)
# Judge status: Accepted
A,B,C = sorted(map(int,input().split()))
K = int(input())

for k in range(K):
  C*=2
  
print(A+B+C)
# Judge status: Wrong Answer
N = input()
tip = "No"
if (N[0] == 7) or (N[1] == 7) or (N[2] == 7):
  tip = "Yes"
print(tip)
# Judge status: Accepted
#n = int(input())
a, b = map(int, input().split())
#l = list(map(int,input().split()))
#l = [list(map(int,input().split())) for i in range(n)]
v = (a+b)//2
mod = (a+b) % 2
if mod == 0:
    print(v)
else:
    print(v+1)
# Judge status: Accepted
n,k=map(int,input().split())
h=[int(x) for x in input().split()]

h=sorted(h)

if len(h) <= k:
    print(0)
else:
    buf=h[0:len(h)-k]
    """for i in range(k):
       del h[-1]"""
    print(sum(buf))
# Judge status: Wrong Answer
n,m=map(int,input().split())
ans=list(range(m))
for i in range(n):
    l=list(map(int,input().split()))[1:]
    ans=list(set(ans)&set(l))
print(len(ans))
# Judge status: Accepted

def resolve():
    N = int(input())
    A = [int(input()) for _ in range(N)] + [0]

    ans = 0
    for i in range(N):
        ans += A[i] // 2
        A[i] %= 2
        if A[i] > 0 and A[i + 1] > 0:
            ans += 1
            A[i] -= 1
            A[i + 1] -= 1

    print(ans)


if __name__ == "__main__":
    resolve()
# Judge status: Wrong Answer
from math import gcd
n=int(input())
r=[1]+list(map(int,input().split()))+[1]
u=r[1]
for i in range(2,n+1):u=gcd(u,r[i])
prefix=r.copy()
suffix=r.copy()
for i in range(2,n+1):
  prefix[i]=gcd(prefix[i-1],r[i])
for i in range(n-1,0,-1):
  suffix[i]=gcd(suffix[i+1],r[i])
m=0
for i in range(1,n+1):
  m=max(m,gcd(prefix[i-1],suffix[i+1]))
print(max(m,u))
# Judge status: Accepted
from math import cos, pi, sqrt

a, b, h, m = map(float, input().split())
x = 30 * (h + m / 60)
y = 360 * m / 60
z = abs(x - y)
z = min(z, 360 - z)
print(sqrt(a * a + b * b - 2 * a * b * cos(pi * z / 180)))
# Judge status: Accepted
x=int(input())
y=x//100
z=x%100
if z<=y*5:
    print(1)
else:
    print(0)
# Judge status: Accepted
n=int(input())
i=1
if n==1:
  print(1)
else:
  while n>=2**i:
  	i+=1
  print(2**(i-1))
# Judge status: Accepted
c=input()
if c=='a' or c=='i' or c=='u' or c=='e' or c=='o':
  print('vowel')
else:
  print('consonant')
# Judge status: Accepted
Sa = list(input())
Sb = list(input())
Sc = list(input())

n = 'a'
while True:
    if n == 'a':
        if not len(Sa):
            ans = 'A'
            break
        n = Sa.pop(0)
    elif n == 'b':
        if not len(Sb):
            ans = 'B'
            break
        n = Sb.pop(0)
    else:
        if not len(Sc):
            ans = 'C'
            break
        n = Sc.pop(0)

print(ans)
# Judge status: Wrong Answer
import math
from functools import reduce

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

def lcm_base(x,y):
  return x*y//math.gcd(x,y)

def lcm(target_list):
  return reduce(lcm_base, target_list)

if reduce(math.gcd, A)%2:
  min_x = int(lcm(A)*0.5)
  ans = m//min_x - m//(2*min_x)
  print(ans)
else:
  print(0)
# Judge status: Accepted
import sys

input = sys.stdin.readline

N, K, S = map(int, input().split())
ans = []

large = 1000000000

if S == large:
    for _ in range(K):
        ans.append(S)
    for _ in range(N - K):
        ans.append(1)  
else:
    for _ in range(K):
        ans.append(S)
    for _ in range(N - K):
        ans.append(large)

print(*ans)
# Judge status: Accepted
import sys


inint = lambda: int(sys.stdin.readline())
inintm = lambda: map(int, sys.stdin.readline().split())
inintl = lambda: list(inintm())
instrm = lambda: map(str, sys.stdin.readline().split())
instrl = lambda: list(instrm())

n, x = inintm()
A = inintl()

A.sort()
ans = 0

for i in range(n-1):
    if x - A[i] >= 0:
        ans += 1
        x -= A[i]

if A[-1] == x:
    ans += 1

print(ans)
# Judge status: Accepted
a,b,c,d=input()
print('Bad' if a==b or b==c or c==d else 'Good')
# Judge status: Accepted
words = list(input())
dic = {}
for word in words:
  if word not in dic:
    dic[word] = 1
  else:
    dic[word] += 1
if all(v % 2 == 0 for v in dic.values()):
  print("Yes")
else:
  print("No")
# Judge status: Accepted
a,b,c,k = map(int,input().split())

if k <= a+b:
    print(min(k,a))
else:
    print(a-(k - (a+b)))
# Judge status: Accepted
import sys
def input(): return sys.stdin.readline().rstrip()

N = input()

if int(N[-1]) in [2,4,5,7,9]:
    print("hon")
elif int(N[-1]) in [0,1,6,8]:
    print("pon")
else:
    print("bon")
# Judge status: Wrong Answer
a, b = [int(x) for x in input().strip().split()]
if a == 0 or b == 0:
  print('Zero')
elif a == b:
  print('Positive')
elif a < 0 and b > 0:
  print('Zero')
elif a > 0:
  print('Positive')
else:
  if b - a % 2:
    print('Negative')
  else:
    print('Positive')
# Judge status: Accepted
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()))

w,h,x,y = iim()
area = w*h/2

f = 1 if w/2 == x and h/2 == y else 0
print(area,f)
# Judge status: Accepted
s = input()
t = input()

import fnmatch

if len(s) < len(t):
    print('UNRESTORABLE')
else:
    l = []
    for  i in range(len(s) - len(t)+1):
        if fnmatch.fnmatch(t, s[i:i+len(t)]):
            x = s[0:i] + t + s[i+len(t):]
            l += [x.replace('?', 'a')]

    else:
        if len(l) == 0:
            print('UNRESTORABLE')
        else:
            l.sort()
            print(l[0])
# Judge status: Accepted
a, b, c = map(int, input().split())


if a % 2 != 0 or b % 2 != 0 or c % 2 != 0:
    print(0)
    exit(0)
if a == b == c and a % 2 == 0:
    print(-1)
    exit(0)

counter = 0
while True:
    counter += 1
    w_a = a / 2
    w_b = b / 2
    w_c = c / 2

    a = w_b + w_c
    b = w_a + w_c
    c = w_b + w_a

    if a % 2 == 1 or b % 2 == 1 or c % 2 == 1:
        print(counter)
        exit(0)
# Judge status: Accepted
a, b = map(int, input().split())
ans = "Possible" if a*b*(a+b) % 3 == 0 else "Impossible"
print(ans)
# Judge status: Accepted
S = input()
if len(S) == 0:
  print('NO')
else:
  if len(S.replace('eraser', '').replace('erase', '').replace('dreamer', '').replace('dream', '')) == 0:
    print('YES')
  else:
    print('NO')
# Judge status: Accepted
(n, m) = map(int, raw_input().split())

res = 0

if n == 1 or m == 1:
    print 1
else:
    res += ((n + 1) / 2) * ((m + 1) / 2)
    res += (n / 2) * (m / 2)
    print res
# Judge status: Accepted
def main():
    n,m=map(int,input().split())
    A=[list(input()) for _ in range(n)]
    B=[list(input()) for _ in range(m)]
    for i in range(n-m+1):
        for j in range(n-m+1):
            tmp=[]
            for k in range(m):
                tmp.append(A[i+k][j:j+m])
            if B==tmp:
                print('Yes')
                return
    print('No')
main()
# Judge status: Accepted
import itertools
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))

x = [tuple(x) for x in itertools.permutations(range(1, N + 1), N)]
x.sort()
a = x.index(P)
b = x.index(Q)
ans = abs(a - b)
print(ans)
# Judge status: Wrong Answer
N = int(input())
T = input()
cnt = 0
#if len(T) / 2 % 1 != 0:
    #print("No")
for i in range(int(len(T) / 2) - 1):
    if T[i] == T[int(len(T) / 2) + i]:
        cnt += 1
if cnt == int(len(T) / 2) - 1:
    print("Yes")
else:
    print("No")
# Judge status: Wrong Answer
a,b,c=map(int,input().split())

if a%2==b%2 and b%2==c%2:
    pass
else:
    a+=(a%2==b%2 or a%2==c%2)
    b+=(b%2==a%2 or b%2==c%2)
    c+=(c%2==a%2 or c%2==b%2)
x=sorted([a,b,c])
print((x[2]-x[1])//2+(x[2]-x[0])//2+1)
# Judge status: Wrong Answer
n = int(input())
arr = list(map(int, input().split()))
q = int(input())
b = []
c = []
for i in range(0,q):
  bi, ci = list(map(int, input().split()))
  b.append(bi)
  c.append(ci)
for i in b:
  if i in arr:
    ind1 = arr.index(i)
    ind2 = b.index(i)
    arr[ind1] = c[ind2]
    print(sum(arr))
# Judge status: Accepted
import sys
input = sys.stdin.readline

N, Q = map(int, input().split())
S = input()[:-1]
acc = [0]

for i in range(N-1):
    if S[i]=='A' and S[i+1]=='C':
        acc.append(acc[-1]+1)
    else:
        acc.append(acc[-1])

acc.append(acc[-1])

for _ in range(Q):
    l, r = map(int, input().split())
    print(acc[r-1]-acc[l-1])
# Judge status: Accepted
s = input()
k = int(input())

if s[0] != "1":
    print(s[0])
    exit()
else:
    cnt = 0
    not_1 = 0
    for i in range(len(s)):
        if s[i] == "1":
            cnt += 1
        else:
            not_1 = i
            break
    if cnt >= k:
        print(1)
        exit()
    else:
        print(s[not_1])
# Judge status: Accepted
N = int(input())
nums = list(map(int, input().split()))
upper = True
lower = True
before = nums[0]
answer = 0
for i, num in enumerate(nums):
  if before < num:
    lower = False
  elif before > num:
    upper = False
  before = num
  if not upper and not lower:
    answer += 1
    upper = True
    lower = True
print(answer+1)
# Judge status: Wrong Answer
from collections import defaultdict

s = input()
t = input()

AL = "abcdefghijklmnopqrstuvwxyz"
S = defaultdict(int)
T = defaultdict(int)

for al in s:
  S[al] += 1

for al in t:
  T[al] += 1

ans_s = ""
for al in AL:
  ans_s += al*S[al]

ans_t = ""
for al in reversed(list(al)):
  ans_t += al*T[al]

if ans_s < ans_t:
  print("Yes")
else:
  print("No")
# Judge status: Wrong Answer
dic_lst={}
lst_a=input().split()
lst_b=list(map(int,input().split()))
wd=input()
for i in range(2):
    dic_lst[lst_a[i]]=lst_b[i]
if wd in dic_lst.keys():
    dic_lst[wd]-=1
print(*dic_lst.values())
# Judge status: Wrong Answer
import re

S_ = input().replace('?', '.')
T = input()
flag = True
for i in range(len(S_)-len(T), 0, -1):
    angou = re.compile(S_[i:i+len(T)])
    mo = angou.search(T)
    if mo != None:
        S_ = S_[:i] + mo.group() + S_[i+len(T) + 1:]
        flag = False
        break
S = S_.replace('.', 'a')

if flag:
    print('UNRESTORABLE')
else:
    print(S)
# Judge status: Accepted
a=list(map(int,input().split()))
a.sort()
print(a[0]*a[1]*(-(-a[2]//2)-a[2]//2))
# Judge status: Accepted
N = int(input())

dp = [0]*(10**5+1)
for i in range(1, 10**5+1):
	dp[i] = dp[i-1]+1
	cnt = 0
	while 6**cnt<=i:
		dp[i] = min(dp[i], dp[i-6**cnt]+1)
		cnt += 1
	cnt = 0
	while 9**cnt<=i:
		dp[i] = min(dp[i], dp[i-9**cnt]+1)
		cnt += 1
print(dp[N])
# Judge status: Accepted
import sys


def main(argv):
    n, m = [int(i) for i in sys.stdin.readline().rstrip("\n").split(" ")]
    a = [int(i) for i in sys.stdin.readline().rstrip("\n").split(" ")]
    s = sum(a)
    items = list(filter(lambda i: True if i >= s / (4 * m) else False, a))
    print("Yes" if len(items) >= m else "No")
    return 0
    
    
if __name__ == "__main__":
    sys.exit(main(sys.argv))
# Judge status: Accepted
n = input()

ans = n.find('7')

if ans == -1:
    print('No')
else:
    print('Yes')
# Judge status: Accepted
N = int(input())
A = list(map(int, input().split()))
Q = int(input())
BC = [list(map(int, input().split())) for _ in range(Q)]

cnt = [0] * (100001)
s = sum(A)
for a in A:
    cnt[a] += 1

for b, c in BC:
    cnt[c] += cnt[b]
    s += cnt[b] * (c-b)
    cnt[b] = 0
    print(s)
# Judge status: Accepted
n = int(input())
xy = [list(map(int,input().split())) for _ in range(n)]

xy1 = []
xy2 = []

for x,y in xy:
    xy1.append(x+y)
    xy2.append(x-y)

xy1.sort()
xy2.sort()

print(max(xy1[-1] - xy1[0], xy2[-1] - xy2[0]))
# Judge status: Wrong Answer
K=int(input())
count=0
n=7
if n%K==0:
    print('1')

while True:
    if K%2==0:
        print('-1')
        break
    count+=1
    n=7*10**count+n
    if n%K==0:
        print(count+1)
        break
# Judge status: Accepted
s = input()
if len(s)%2 == 1:
    s_0 = s[0:(len(s)//2)+1]
    m = s[::-1]
    s_1 = m[0:(len(s)//2)+1]
    
else:
    s_0 = s[0:(len(s)//2)]
    m = s[::-1]
    s_1 = m[0:(len(s)//2)]

ans = 0

for i in range(len(s_1)):
    if s_1[i] != s_0[i]:
        ans += 1
print(ans)
# Judge status: Wrong Answer
n=int(input())
a=list(map(int,input().split()))

from collections import Counter
a=Counter(a).most_common()

li=[] #2本以上あるもの
li4=[] #4本以上あるもの

for x,y in a:
  if  y>=4:
    li4.append(x)
  elif y>=2:
    li.append(x)

li.sort()
li4.sort()

x=0
y=0

if li4:
  x=li4[-1]**2
if len(li)>=2:
  y=li[-1]*li[-2]

print(max(x,y))
# Judge status: Wrong Answer
X, Y = map(int, input().split(' '))
result = False
for i in range(1,X+1):
    if 2*i + 4*(X-i) == Y:
        result = True
        print('Yes')
if not(result):
    print('No')
# Judge status: Wrong Answer
n = int(input())
# n < 100000
res = n

for i in range(n):
    c = 0
    t = i
    while t > 0:
        c += t % 6
        t //= 6
    t = n - i
    while t > 0:
        c += t % 9
        t //= 9
    if res > c:
        res = c

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

ans = "AC"

if S[0] != "A" :
    ans = "WA"

if S[2:-1].count("C") != 1 :
    ans = "WA"

T = S[1:].replace("C","c",1)

if not T.islower() :
    ans = "WA"

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

answer = a * b

print(answer)
# Judge status: Accepted
N=input()
L=len(N)
ans=[[0 for e in range(2)] for f in range(L)]
ans[0][0]=int(N[L-1])
ans[0][1]=10-int(N[L-1])
if L>1:
 for i in range(1,L):
  ans[i][0]=min(ans[i-1][0]+int(N[L-1-i]),ans[i-1][1]+int(N[L-1-i])+1)
  ans[i][1]=min(ans[i-1][0]+10-int(N[L-1-i]),ans[i-1][1]+10-int(N[L-1-i])-1)
print(min(ans[L-1][0],ans[L-1][1]+1))
# Judge status: Accepted
N = int(input())
R = list(map(int,input().split()))

min = 100000000
for i in range (100):
    sum = 0
    for j in range (N):
        sum += (R[j] - i)**2

    if sum <= min:
        min = sum
    
print(min)
# Judge status: Accepted
S,T=map(str,input().split())
print(T+S)
# Judge status: Wrong Answer
x, y = map(int, input().split())

if (y/2 - x) > x:
  print('No')
else:
  print('Yes')
# Judge status: Wrong Answer
N=int(input())
A=[list((input().split())) for i in range(N)]
for num in range(N):
  A[num].append(num+1)
from operator import itemgetter
A.sort(key=itemgetter(1,0))
for num in range(N):
  A[num].append(num+1)
A.sort(key=itemgetter(2))
for num in range(N):
  print(A[num][3])
# Judge status: Accepted
from collections import Counter

n = int(input())
A = list(map(int, input().split()))
A_dic = Counter(A)

set_A = sorted((set(A)), reverse=True)
tmp = 0
for a in set_A:
    if A_dic[a] >= 4:
        print(max(tmp*a, a*a))
        exit()
    if A_dic[a] >= 2:
        ans = tmp * a
        if ans != 0:
            print(ans)
            exit()
        tmp = a
print(0)
# Judge status: Accepted
from sys import stdin
n,a,b = map(int,stdin.readline().rstrip().split())
c = n//(a+b)
d = n%(a+b)
if d > a:
    print(a*(c+1))
else:
    print(a*c+d)
# Judge status: Accepted
import sys
import numpy as np

from collections import deque 
from functools import reduce

# input = sys.stdin.readline

x = int(input())

m500 = x // 500
x %= 500
m5 = x // 5

print((m500*1000)+m5*5)
# Judge status: Accepted
from itertools import combinations_with_replacement

def main():
    n, m, q = map(int, input().split())
    abcd = [[int(i) for i in input().split()] for _ in range(q)]
    s = 0
    for p in combinations_with_replacement(range(1, m + 1), n):
        t = 0
        for a, b, c, d in abcd:
            t += d * (p[b - 1] - p[a - 1] == c)
        s = max(s, t)
    print(s)

if __name__ == '__main__':
    main()
# Judge status: Accepted
N=int(input())
S=input()
A=S.count('R')*S.count('G')*S.count('B')
for i in range(N-2):
    for j in range(i+1,N-1):
        if 2*j-i < N:
            if S[i] != S[j] and S[i] != S[2*j-i] and S[j] != S[2*j-i]:
                A-=1
print(A)
# Judge status: Wrong Answer
X = int(input())


def ans165(X: int):
    cash = 100  # 当初の預金額
    count = 0
    while True:
        cash = int(cash * 1.01)  # 元本に１パーセントの利子をつけ小数点以下切り捨て
        count += 1  # 利子をつける回数だけcountを増やす
        if cash >= X:  # cashがXの値以上になったらループ終了
            break
    return count


print(ans165(X))
# Judge status: Accepted
a, b ,k = map(int, input().split())
ans = []
for i in range(1, max(a,b)+1):
    if a%i == b%i == 0:
        ans.append(i)
print(ans[-k])
# Judge status: Wrong Answer
H = int(input())
count = 0
enemy = 1
while H >= 1:
  count += enemy
  H //= 2
print(count)
# Judge status: Wrong Answer
import collections

n, *a = map(int, open(0).read().split())
c = collections.Counter(a)
length_l = list(c.keys())
length_l.sort(reverse = True)
side1 = 0
ans = 0
for l in length_l:
    cnt = c[l]
    if cnt >= 4:
        ans = cnt*2
        break
    elif cnt >= 2:
        if side1 != 0:
            ans = side1*l
            break
        else:
            side1 = l
print(ans)
# Judge status: Accepted
a = int(input())
count = 0
count += (a // 500) * 1000
b = a % 500
count += (b // 5) * 5
print(count)
# Judge status: Accepted
from collections import defaultdict

n, x, y = map(int, input().split())
x -= 1
y -= 1

d = defaultdict(int)
for i in range(n-1):
    for j in range(i+1, n):
        path = min([j-i, abs(x-i)+abs(y-j)+1, abs(x-j)+abs(y-i)+1])
        d[path] += 1

for i in range(1, n):
    print(d[i])
# Judge status: Wrong Answer
h,a = map(int,input().split())
ans=0
if a>1:
    ans= h//a+1
elif a==1:
    ans=h
print(ans)
# Judge status: Accepted
K = int(input())
S = input()

if len(S) <= K:
    ans = S
else:
    ans = S[:K] + '...'
print(ans)
# Judge status: Accepted
def main():
    n = int(input())
    s = list(input())

    ans = s.count("R")*s.count("G")*s.count("B")
    for i in range(n):
        for j in range(i+1, n):
            k = j + j - i
            if k < n and s[i] != s[j] and s[j] != s[k] and s[k] != s[i]:
                ans -= 1
    print(ans)


if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
n=int(input())
a = list(map(int,input().split()))
c=1
for i in range(n):
    c=c*a[i]
    if c>1000000000000000000:
        print("-1")
        break
    
if c<=1000000000000000000:
    print(c)
# Judge status: Accepted
A,B= list(map(int,input().split())) 

print(A*B)
# Judge status: Accepted
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    X, Y = LI()

    ans = 0
    num = X
    while num <= Y:
        ans += 1
        num *= 2

    print(ans)

if __name__ == '__main__':
    resolve()
# Judge status: Accepted
s = input()
t = input()
ans = len(t)
for i in range(len(s) - len(t) + 1):
    ans = min(ans, sum(si != ti for si, ti in zip(s[i:], t)))
print(ans)
# Judge status: Accepted
people,point,quiz = map(int,input().split())
an = [int(input()) for _ in range(quiz)]
each_p = [point-quiz] * people

for x in an:
    each_p[x-1] += 1

for y in each_p:
    if y <= 0:
        print("No")
    else:
        print("Yes")
# Judge status: Accepted
a, b = map(int, input().split())

if a % b == 0:
    print(-1)
else:
    for i in range(1, a*b+1):
        if (a * i) % b != 0:
            print(a * i)
            break
# Judge status: Accepted
S = set(input())
print('Yes' if len(S)==2 else 'No')
# Judge status: Accepted
n = int(input())
a = []
for i in range(n):
	a.append(int(input()))
a_max = max(a)
a_second = sorted(a)[-2]
for i in range(n):
	print(a_max if a[i] != a_max else a_second)
# Judge status: Accepted
N,T=map(int,input().split())
ans=1001
for i in range(N):
  c,t=map(int,input().split())
  if t<=T:
    ans=min(ans,c)
if ans==1001:
  print("TLE")
else:
  print(ans)
# Judge status: Accepted
n,m = map(int, input().split())

diff=abs(n-m)
if diff < -1 or diff > 1:
    print(0)
    exit()

def factmod(n,mod):
    result=1
    for i in range(1,n+1):
        result*=i
        result = result % mod
    return result % mod

from math import factorial
res =  factmod(n,7+10**9)*factmod(m,7+10**9)
if diff==0:
    res*=2
res = res%(7+10**9)
print(res)
# Judge status: Accepted
i = int(input())
k = 10 - int((i / 200))
print(k)
# Judge status: Accepted
x = str(input())
print("YES" if x in "753" else "NO")
# Judge status: Accepted
a, b = list(map(int, input().split()))
if a == b:
  my_result = a + b
elif a > b:
  my_result = 2 * a - 1
else:
  my_result = 2 * b - 1
print(my_result)
# Judge status: Wrong Answer
A,B,K=map(int, input().split())
cnt=0
for i in range(A,A+K):
    if i<=B:
        print(i)
        cnt=i
    else:
        break
        
if B-K>A:
    for i in range(max(B-K+1,cnt+1),B+1):
        print(i)
# Judge status: Accepted
import collections
N = int(input())
lsA = list(map(int,input().split()))
counterA = collections.Counter(lsA)
ans = 0
for X in range(1,10**5+1):
    b1 = counterA[X-1]
    b2 = counterA[X]
    b3 = counterA[X+1]
    ans = max(ans,sum([b1,b2,b3]))
print(ans)
# Judge status: Accepted
K = int(input())
a = []

def DFS(n):
    if n > 3234566667:
        return
    a.append(n)
    l = n % 10
    if l == 0:
        DFS(10 * n)
        DFS(10 * n + 1)
    elif l == 9:
        DFS(10 * n + 9)
        DFS(10 * n + 8)
    else:
        DFS(10 * n + l)
        DFS(10 * n + l + 1)
        DFS(10 * n + l - 1)

for i in range(1, 10):
    DFS(i)

a = sorted(a)
print(a[K-1])
# Judge status: Accepted
n = int(input())
A = list(map(int, input().split()))
total = sum(A)

x = 0
y = total
B = []
for i in range(n-1):
    x += A[i]
    y -= A[i]
    B.append(abs(x - y))
print(min(B))
# Judge status: Accepted
import sys


def input():
    return sys.stdin.readline()[:-1]


N = int(input())

plus = []
minus = []
for _ in range(N):
    x, y = map(int, input().split())
    plus.append(x+y)
    minus.append(x-y)

print(max(max(plus)-min(plus), max(minus)-min(minus)))
# Judge status: Accepted
X = int(input())

for i in range(-200, 201, 1):
    for j in range(-200, 201, 1):
        if i**5 - j**5 == X:
            print(i, j)
            exit(0)
# Judge status: Accepted
n,m = map(int,input().split())
a = [input() for i in range(n)]
b = [input() for i in range(m)]

def is_same(i,j):
  for l in range(m):
    for k in range(m):
      if a[i+l][j+k] != b[l][k]:
        return False
  return True
  
for i in range(n-m+1):
  for j in range(n-m+1):
    if is_same(i,j):
      print('Yes')
      exit()
print('No')
# Judge status: Accepted
a,b,c=map(int,input().split(' '))
a,b,c=c,a,b
print(str(a)+" "+str(b)+" "+str(c))
# Judge status: Accepted
# Python3 (3.4.3)
import sys
input = sys.stdin.readline

# -------------------------------------------------------------
# function
# -------------------------------------------------------------


# -------------------------------------------------------------
# main
# -------------------------------------------------------------
A,B = map(int,input().split())

print((A+B)%24)
# Judge status: Wrong Answer
def solve(n, m):

    ans = len([i for i in range(n, m+1) if i // 1000 == i % 100])
    return ans

if __name__ == "__main__":
    n, m = [int(i) for i in input().split()]
    print(solve(n, m))
# Judge status: Wrong Answer
n,p = map(int,input().split())
a = list(map(lambda x:int(x)%2,input().split()))
cnt0 = a.count(0)
cnt1 = n-cnt0
if cnt0==n and p==0:
    print(2**n)
elif cnt0==0 and p==1:
    print(0)
else:
    print(2**(n-1))
# Judge status: Wrong Answer
import math
if __name__ == "__main__":
    N = int(input())

    X = []
    Y = []
    for i in range(N):
        Xi, Yi = map (float, input().split())
        X.append(Xi)
        Y.append(Yi)

    fac = math.factorial(N)
    NN = (fac * (N -1 )) / N

    Z  = 0
    for i in range(N):
        Z += ((math.sqrt((X[i - 1] - X[i])**2 + (Y[i -1] - X[i])**2 ) ) * NN) 
    
    print(Z / fac)