peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
a, b = list(map(int, input().split()))
if a <= 0 <= b:  ### a と b の間に0を含む時
    print("Zero")
elif 0 < a <= b: ### a と b が正の場合
    print("Positive")
elif a <= b < 0: ### a と b が負の場合
    ### a と b の間に数字が偶数個なら正、奇数個なら負
    if (b - a + 1) % 2 == 0:
        print("Positive")
    else:
        print("Negative")
# Judge status: Accepted
S = {c: list(input()) for c in 'abc'}
s = 'a'
while S[s]:
  s = S[s].pop(0)
  
print(s.upper())
# Judge status: Wrong Answer
N = int(input())
print(int((1/2)*N*(N-1)))
# Judge status: Wrong Answer
n,k=map(int,input().split())
s=input()
p2=0
p1=0
if n==1:
  print(0)
  exit()
if s[0]=="L":
  p1+=1
if s[n-1]=="R":
  p1+=1
  
for i in range(1,n):
  if not (s[i]=="L" and s[i-1]=="R"):
    continue
  p2+=1
if k<=p2-1:
  print(n-2*p2-p1+2*k)
elif p2<k<p2+p1:
  print(n-p1+(k-p2))
else:
  print(n-1)
# Judge status: Wrong Answer
string = input()
sub_string = input()

change = 0

for i in range(0, len(sub_string)):
  if sub_string[i] in string:
    if sub_string[i] != string[i]:
      change += 1
  else: 
    change += 1
  
print(change)
# Judge status: Accepted
x, y = map(int, input().split())
ans = 0

while x <= y:
    ans += 1
    x *= 2

print(ans)
# Judge status: Accepted
x,a,b=map(int,input().split())
print("dangerous" if x<b-a else "safe" if a<b else "delicious")
# Judge status: Wrong Answer
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
a_place = a
b_place = b

if w >= v:
    print('No')
else:
    for i in range(1,t):
        a_place += v
        b_place += w
        if a_place == b_place:
            print('Yes')
            break
# Judge status: Accepted
def main():
    N = int(input())
    A = list(map(int, input().split(' ')))
    sum_A = sum(A)
    left, right = sum_A // N, sum_A // N + 1
    loss_1 = sum([(a - left) ** 2 for a in A])
    loss_2 = sum([(a - right) ** 2 for a in A])
    if loss_1 < loss_2:
        print(loss_1)
    else:
        print(loss_2)


if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
n = int(input())
a = [0] * n
b = [0] * n
sa = [0] * n
for i in range(n):
    a[i], b[i] = map(int, input().split())
c = b.copy()
c.sort()
wa = 0
for i in c:
    wa += a[b.index(i)]
    print(wa, b[c.index(i)])
    if wa > b[b.index(i)]:
        print("No")
        exit()
print("Yes")
# Judge status: Accepted
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=[b[0]+(a[0]-b[a[1]-1])]

for i in range(a[1]-1):
  c.append(b[i+1]-b[i])
print(sum(c)-max(c))
# Judge status: Accepted
n,k = map(int, input().split())
ans = 0

while True:
    n //= k
    ans += 1
    if n == 0: break

print(ans)
# Judge status: Wrong Answer
import math
n,m=map(int,input().split())
num=int(math.sqrt(m))
ans=1
if n==1:
    ans=m
else:
    for i in range(1,num+1):
        if m%i==0 and m//i>=n:
            ans=i
print(ans)
# Judge status: Wrong Answer
K,X = map(int,input().split())
if K*500 >= X:
  print("YES")
else:
  print("NO")
# Judge status: Wrong Answer
d,n = map(int,input().split())
ans = 0
if d == 0:
  ans = n
elif d == 1:
  ans = 100 * n
else:
  ans = 10000 * n
if n == 100:
  ans += n
print(ans)
# Judge status: Accepted
a,b,c,k = map(int, input().split())
if k <= a:
    print(k)
else:
    ans = a
    k = k-a
    if k <= b:
        print(ans)
    else:
        k = k-b
        print(ans-k)
# Judge status: Accepted
H, W = map(int, input().split())
if H == 1 or W == 1:
  print(1)
elif H%2 == 0:
  print(H//2 * W)
elif W%2 == 0:
  print((H//2 + 1) * int(W//2) + int(H//2) * int(W//2))
else:
  print(int(H//2 + 1) * int(W//2 + 1) + int(H//2) * int(W//2))
# Judge status: Accepted
import math

a,b,h,m=map(int,input().split())


h=h*30+0.5*m
m*=6
x=min(abs(h-m),360-abs(h-m))
y=math.cos(math.radians(x))

if x==1:
    print(0)
else:
    print(math.sqrt(a**2+b**2-2*a*b*y))
# Judge status: Wrong Answer
N, K = map(int, input().split())
Alist = list(map(int, input().split()))
if K >= N:
    print(1)
else:
    from math import ceil
    one = Alist.index(1)
    left = N
    right = N - one - 1
    print(ceil(left / K) + ceil(right / K))
# Judge status: Accepted
k,n = map(int, input().split())
lst = list(map(int, input().split()))

maxDis = (k-lst[-1]) + lst[0]
for i in range(n-1):
  if lst[i+1] - lst[i] > maxDis:
    maxDis = lst[i+1] - lst[i]
print(k-maxDis)
# Judge status: Accepted
A = input()
B = int(input())
C = ""
for i in range(B):
    D = input().split()
    if D[0] == "1":
        C,A = A,C
    else:
        if D[1] == "1":
            C += D[2]
        else:
            A += D[2]
C = C[::-1]
print(C+A)
# Judge status: Wrong Answer
n=int(input())
list=input().split()
for f in list:
    f=float(f)
def sec(a, b, c):
    l=[a, b, c]
    l.sort()
    return l[1]
count=1
c=0
for i in range(n-2):
    if sec(list[count], list[count+1], list[count-1])==list[count]:
        c=c+1
    count=count+1
print(c)
# Judge status: Accepted
S = int(input())

v = 10 ** 9
x = (v - S % v) % v
y = (S + x) // v
print("0 0 1000000000 1 {} {}".format(x, y))
# Judge status: Wrong Answer
N,M = map(int, open(0).read().split())
X = int((M-2*N)/2)
print(int((2*N+X)/2))
# Judge status: Accepted
import math
X, Y = map(int, input().split())
c = math.log2(Y // X)
if 2 ** int(c) <= Y // X:
  print(int(c) + 1)
else:
  print(int(c))
# Judge status: Accepted
N=int(input())
ans1=N//11*2
ans2=(0<N%11)+(6<N%11)
print(ans1+ans2)
# Judge status: Wrong Answer
n=input()


n=str(n)
Sum=0
for i in range(len(n)):
    Sum=Sum+int(n[i])

if Sum%9==0:
    print("yes")
else:
    print("no")
# Judge status: Accepted
import sys

sys.setrecursionlimit(10 ** 8)
ni = lambda: int(sys.stdin.readline())
nm = lambda: map(int, sys.stdin.readline().split())
nl = lambda: list(nm())
ns = lambda: sys.stdin.readline().rstrip()

N = ni()
A = nl()


def solve():
    tot = sum(A)
    ans = 1 << 60
    s = 0
    for i, x in enumerate(A):
        if i == N - 1:
            break
        s += x
        a = abs(2 * s - tot)
        ans = min(ans, a)
    return ans


print(solve())
# Judge status: Wrong Answer
a,b = map(int,input().split())
if (a+b > 24):
  print((a+b)-24)
else:
  print(a+b)
# Judge status: Accepted
import sys
import math
import itertools
import bisect
from copy import copy,deepcopy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(map(int,input().split()))
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

N = i()
A = [i() for _ in range(N)]
C = Counter(A)
ans = 0
for c in C.values():
    if c%2 == 1:
        ans += 1
print(ans)
# Judge status: Accepted
import math
N = int(input())
N = math.floor(math.sqrt(N))
print(N**2)
# Judge status: Wrong Answer
k, a, b = map(int, input().split())
if b - a <= 2:
    print(k + 1)
else:
    cnt = k - (a - 1)
    print(max(k + 1, (b - a) * cnt // 2 + 1 * cnt % 2 + a))
# Judge status: Wrong Answer
n,d = map(int,input().split())
l = [list(map(int,input().split()))for _ in range(n)]
ans = 0
for i in range(n):
    for j in range(i+1,n):
        r = 0
        for k in range(d):
            r += (l[i][k]-l[j][k])**2
            r = r**0.5
            if r == int(r):
                ans += 1
print(ans)
# Judge status: Accepted
from collections import *
from heapq import *
N=int(input())
if N==0:
    print(0)
    exit()
num=0
count=0
lst=[]

while N:
    if N%2==1:
        lst.append(1)
        N-=1 * (-1 if count%2 else 1)
    else:
        lst.append(0)
    count+=1
    N//=2
lst=list(reversed(lst))
print("".join([str(i) for i in lst]))
# Judge status: Accepted
#D
n = int(input())
s = input()
s_l = list(s)

a = s_l.count('R') * s_l.count('G') * s_l.count('B')
cnt = 0
#i,j,kがそれぞれ異なり、j-i = k-jであるものを求める
for i in range(n-2):
    for j in range(i,n-1):
        if 2*j - i < n:
            if s_l[i] != s_l[j] and s_l[i] != s_l[2*j-i] and s_l[j] != s_l[2*j-i]:
                cnt += 1
                
print(a - cnt)
# Judge status: Accepted
from collections import Counter
n=int(input())
s=Counter(input())
for i in range(n-1):
    s&=Counter(input())
print("".join(sorted(s.elements())))
# Judge status: Accepted
a,b = map(int,input().split())
s = input()

if s.count('-') == 1:
    S = s.split('-')
    if len('-'.join(S)) == a+b+1 and len(S[0]) == a and len(S[1]) == b:
        print('Yes')
    else:
        print('No')
else:
    print('No')
# Judge status: Accepted
N = int(input())
blue = {}
for i in range(N):
    a = input()
    if a not in blue:
        blue[a] = 1
    else:
        blue[a] += 1
        
M = int(input())
#red = {}
for i in range(M):
    a = input()
    if a not in blue:
        blue[a] = -1
    else:
        blue[a] -= 1
print(max(0, max(blue.values())))
# Judge status: Accepted
A, B = map(int,input().split())
if A == B: print("Draw")  
elif (A-2)%13 < (B-2)%13 : print("Bob")
else: print("Alice")
# Judge status: Wrong Answer
n,m=map(int,input().split())
s=input()

t=str.lower(s[m-1])

print(s.replace(s[m-1],t))
# Judge status: Accepted
def prime(X):
    if X<2:
        return False
    if X==2:
        True
    for i in range(2,X):
        if X%i==0:
            return False
    return True
X=int(input())
p=False
while p==False:
    p=prime(X)
    X+=1
print(X-1)
# Judge status: Wrong Answer
s = int(input())
a = set([s])
p = s
n = 0
cnt = 0
while True:
  if n in a:
    print(cnt)
    exit()
  if p&1:
    n = 3*p +1
  else:
    n = p//2
  cnt += 1
  a.add(n)
  p = n
# Judge status: Accepted
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


x = int(input())
k = 0
while k*(k+1)//2 < x:
    k += 1
ans = k
print(ans)
# Judge status: Wrong Answer
import sys
N = int(input())
T = [list(map(int, input().split())) for i in range(N)]

x, y = 0, 0
for i in range(N):
    t1 = T[i][0]
    x1 = T[i][1]
    y1 = T[i][2]
    if t1 < abs(x1 - x) + abs(y1 - y):
        print('No')
        sys.exit()
    t1 -= abs(x1 - x) + abs(y1 - y)
    if t1 % 2 != 0:
        print('No')
        sys.exit()
print('Yes')
# Judge status: Accepted
from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)
# input = sys.stdin.readline
from math import factorial
import heapq, bisect
import math
import itertools
import queue
from collections import deque
from fractions import Fraction




def main():
    num = int(input())
    ans = num - 1

    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            ans = min(ans, i + num // i - 2)

    print(ans)




if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
n = int(input())
s = input()
ans = s.count("R")*s.count("G")*s.count("B")
for i in range(1,n//2+10):
  j = 0
  while j+2*i <= n-1:
    print([j, j+i, j+2*i])
    if s[j] != s[j+i] and s[j] != s[j+2*i] and s[j+i] != s[j+2*i]:
      ans -= 1
    j += 1
print(ans)
# Judge status: Wrong Answer
N, M = map(int, input().split())
a = [0]*N
for i in range(M):
    s, c = map(int, input().split())
    d = a[s-1]
    if d != 0:
        a[s-1] = min(c, d)
    else:
        a[s-1] = c
if a[0] != 0:
    print(*a, sep="") 
else:
    print("-1")
# Judge status: Accepted
n,l=map(int,input().split())
ls=[]
for i in range(1,n+1):
  ls.append(abs(l-1+i))
mi=ls.index(min(ls))
print(n*(l-1)+sum(range(1,n+1))-l-mi)
# Judge status: Wrong Answer
n, m = map(int, input().split())

from collections import defaultdict

cb = defaultdict(int)

for a in input().split():
    cb[int(a)] += 1

for _ in range(m):
    b, c = map(int, input().split())
    cb[c] += b

cbl = sorted(cb.items())

res = n

ans = 0

while res > 0:
    c, b = cbl.pop()
    ncount = min(res, b)
    ans += c * ncount
    res -= ncount

ans
# Judge status: Accepted
n = input()
s_flg = 0
for i in range(len(n)):
    if n[i] == '7':
        s_flg = 1
if s_flg:
    print('Yes')
else:
    print('No')
# Judge status: Wrong Answer
import math

def comb_count(n, r):
    return math.factorial(n) // math.factorial(r) * math.factorial(n - r)

S = input()[::-1]
ans = 0

mods = [0] * 2019 #余りが0~2018
mods[0] = 1
current = 0
tmp = 1

for i in range(len(S)):
    current = int(S[i]) * tmp + current % 2019
    mod = current % 2019
    mods[mod] += 1
    tmp = tmp * 10

for mod in mods:
    if mod > 1:
        ans += comb_count(mod, 2)
print(ans)
# Judge status: Accepted
import math
N,D = map(int,input().split())
k = []
ans_2 = 0
ans_1 = 0
now = 0
for i in range(N):
    k.append(list(map(int,input().split())))
for i in range(0,N):
    for j in range(i+1,N):
        for _ in range(D):
            now += (k[i][_]-k[j][_])**2
        ans_1 = math.sqrt(now)
        if ans_1%1 == 0:
            ans_2 += 1
        now = 0
        ans_1 = 0
print(ans_2)
# Judge status: Accepted
s = input()

for i in range(26):
    x = chr(i + 97)
    if not x in s:
        print(x)
        exit()
print('None')
# Judge status: Accepted
n = int(input())
t, a = map(int, input().split())
H = list(map(int, input().split()))
ans = []
for i in range(n):
    average_tmp = t - H[i] * 0.006
    diff = abs(a - average_tmp)
    ans.append(diff)
print(ans.index(min(ans)) + 1)
# Judge status: Accepted
n = int(input())

while not (n%10 == (n//10)%10 == n//100):
    n += 1
    
print(n)
# Judge status: Accepted
n = int(input())
a = [int(x) for x in input().split()]

ans = 1000

for i in range(n-1):
  ans += (ans//a[i])*max(0, (a[i+1]-a[i]))

print(ans)
# Judge status: Wrong Answer
n = int(input())

c = ord("a")
l = ""
while n > 26:
    a = n % 26
    n = (n-a)//26
    l = l+chr(c+a-1)
l = l+chr(c+n-1)
print(l[::-1])
# Judge status: Wrong Answer

A, B = input().split()

M = (int(A) + int(B)) / 2

print(round(M))
# Judge status: Accepted
A = []
for _ in range(3):
  A += list(map(int,input().split()))
n = int(input())
ans = [0]*9
for _ in range(n):
  b = int(input())
  if b in A:
    i = A.index(b)
    if i != -1:
      ans[i] = 1
bingo = [0b111000000,0b000111000,0b000000111,0b100100100,0b010010010,0b001001001,0b100010001,0b001010100]
f = 0
sheet = 0
for i in range(9):
  sheet += ans[i] * 2 ** (8 - i)
for i in range(8):
  ansb = sheet & bingo[i]
  if (ansb & bingo[i]) in bingo:
    f = 1
    break
if f == 1:
  print('Yes')
else:
  print('No')
# Judge status: Wrong Answer
n=int(input())

a=input()

def c(x):
    return (x.count('1')),(x.count('2')),(x.count('3')),(x.count('4'))

print(max(c(a)))
print(min(c(a)))
# Judge status: Accepted
x=int(input())
for a in range(-10**3,10**3):
    for b in range(-10**3,10**3):
        if a**5-b**5==x:
            print(a,b)
            exit()
# Judge status: Accepted
from collections import Counter

N = int(input())
L = list(map(int, input().split()))

c = Counter(L)
L = list(set(list(L)))

L.sort()

res = 0

for i in range(len(L) - 2):
  k = i
  for j in range(i + 1, len(L) - 1):
    while k < len(L) and L[k] < L[i] + L[j]:
      k += 1
    #print(i, j, k)
    for p in range(j + 1, k):
      res += c[L[i]] * c[L[j]] * c[L[p]]

print(res)
# Judge status: Accepted
n = int(input())
s = [input() for _ in range(n)]

ss = set(s)
ans = len(ss)
print(ans)
# Judge status: Accepted
N,P = map(int,input().split())
A = list(map(int,input().split()))
odd = 0 
for i in range(N):
  if A[i]%2 != 0:
    odd += 1

if odd == 0:
  if P == 0:
    ans = 2**N
  else:
    ans = 0
else:
  ans = 2**(N-1)
  
print(ans)
# Judge status: Wrong Answer
a, b = map(int, input().split())

result = 0
result += a
cnt = 1

while b < result:
    result += a - 1
    cnt += 1

print(cnt)
# Judge status: Accepted
s = int( input() )
mod = 10 ** 9 + 7

fact = [ 1, 1 ]
inv = [ 1, 1 ]
inv_fact = [ 1, 1 ]

for k in range( 2, 2000 ):
    fact.append( fact[ k-1 ] * k % mod )
    inv_k = ( - inv[ mod % k ] * ( mod // k ) % mod ) % mod
    inv.append( inv_k )
    inv_fact.append( inv_fact[ k - 1 ] * inv_k % mod )

# print( inv_fact[:5] )

ans = 0
for k in range( 1, s // 3 + 1 ):
    comp = fact[ s - 2 * k - 1 ] * inv_fact[ s - 3 * k ] % mod
    comp = comp * inv_fact[ k - 1 ] % mod
    ans = ( ans + comp ) % mod

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

N = int(input())
A = list(map(int, input().split()))
b = [x[1] - x[0] for x in enumerate(A,1)]
mean = sum(b) // N
c = [(x-mean)**2 for x in b]
disp1 = math.floor(math.sqrt(sum(c)/N))
disp2 = math.ceil(math.sqrt(sum(c)/N))
disp3 = disp1 * (-1)
disp4 = disp2 * (-1)
c1 = [abs(x-disp1) for x in b]
c2 = [abs(x-disp2) for x in b]
c3 = [abs(x-disp3) for x in b]
c4 = [abs(x-disp4) for x in b]
cm = [abs(x-mean) for x in b]
print(min(sum(c1),sum(c2),sum(c3),sum(c4),sum(cm)))
# Judge status: Accepted
K=int(input())
A,B=map(int,input().split())
if (A-1)//K == B//K:
  print('NG')
else:
  print('OK')
# Judge status: Accepted
n = int(input())
a = list(map(int, input().split()))

cnt = 0
if n == 1:
  print (1)
  exit()
c = 0
for i in range(n-1):
  if c == 2 and a[i+1] < a[i]:
    cnt += 1
    c = -1
  elif c == 1 and a[i+1] > a[i]:
    cnt += 1
    c = -1
  else:
    if c < 1:
      if a[i+1] > a[i]:
        c = 2
      elif a[i+1] == a[i]:
        c = 0
      else:
        c = 1
print (cnt+1)
# Judge status: Accepted
n=int(input())
p=list(map(int, input().split()))
ans=0
for i in range(1, n-1):
  if (p[i]-p[i-1])*(p[i+1]-p[i])>0:
    ans+=1
print(ans)
# Judge status: Accepted
l, r = [int(x) for x in input().split()]

ans = 2200
for i in range(l, r):
    if i % 2019 == 0:
        ans = 0
        break
    else:
        for j in range(i+1, r+1):
            if i == j:
                continue
            elif j % 2019 == 0:
                ans = 0
                break
            else:
                tmpans = (i * j) % 2019
            ans = min(ans, tmpans)


print(ans)
# Judge status: Accepted
from sys import stdin
import sys
import math

# A, B, C = [int(x) for x in stdin.readline().rstrip().split()]
A = list(map(int, input().split()))

# U = input().split()
for i,v in enumerate(A):
    if v==0:
        print(i+1)
# Judge status: Wrong Answer
N = int(input())
L_list = list(map(int, input().split()))

L_list = sorted(L_list)

count = 0
for i in range(N-2):
    for j in range(i+1, N-1):
        for k in range(j+1, N):
            if L_list[i] + L_list[j] > L_list[k]:
                print(L_list[i], L_list[j], L_list[k])
                count += 1
            else:
                break

print(count)
# Judge status: Accepted
def kangaru(x):
    count = 0
    i = 0
    while count < x:
        count += i
        i += 1
#    while count != x:
#        if count + (i * 2 + 1) <= x:
#            count += i
#        elif count + i == x:
#            count += i
#        i += 1
    return i - 1

def main():
    x = int(input())
    print(kangaru(x))

if __name__ == '__main__':
    main()
# Judge status: Accepted
import fractions
from functools import reduce

def gcd_list(numbers):
    return reduce(fractions.gcd, numbers)

def myAnswer(N:int,X:int,x:list) -> int:
   ans = []
   for a in x:
      ans.append(abs(a-X))
   return gcd_list(ans)

def modelAnswer():
   return
def main():
   N,X = map(int,input().split())
   x = list(map(int,input().split()))
   print(myAnswer(N,X,x[:]))
if __name__ == '__main__':
   main()
# Judge status: Accepted
N,M = map(int,input().split())
if N == 1 and M == 1:
    print(1)
else:
    print(abs((N-2)*(M-2)))
# Judge status: Accepted
n=int(input())
A=[int(input()) for i in range(n)]
l=[-A[0],1]#-にして小さい順から並ぶようにする
from bisect import *
for a in A[1:]:
    idx=bisect_left(l,-a+1)
    p=-l[idx]
    if p==-1:
        l[-1]=-a
        l.append(1)
    else:
        l[idx]=-a
print(len(l)-1)
# Judge status: Wrong Answer
s = input()[::-1]
n = len(s)
words = ['maerd', 'remaerd', 'esare', 'resare']
p = 1
while p <= n:
    if s[:p] in words:
        s = s[p:]
    p += 1
print('NO' if s else 'YES')
# Judge status: Wrong Answer
import math
X = int(input())
print((int(math.sqrt(X)))**2)
# Judge status: Accepted
import sys
import math  # noqa
import bisect  # noqa
import queue  # noqa


def input():
    return sys.stdin.readline().rstrip()


def main():
    S = input()
    T = input()

    if S == T[:-1]:
        print("Yes")
    else:
        print("No")


if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
c = [[0, 0, 0] for _ in range(3)]
for i in range(3):
    c[i] = list(map(int, input().split()))

a = [0, 0, 0]
b = [0, 0, 0]

for a1 in range(min(c[0])+1):
    b = [c[i][0] - a1, c[i][1] - a1, c[i][2] - a1]
    if c[1][0] - b[0] == c[1][1] - b[1] == c[1][2] - b[2]:
        if c[2][0] - b[0] == c[2][1] - b[1] == c[2][2] - b[2]:
            print("Yes")
            exit()
print("No")
# Judge status: Wrong Answer
from collections import defaultdict
N, K, Q = map(int,input().split())
d = defaultdict(int)
for _ in range(Q):
  a = int(input())
  d[a]+=1
for i in range(1,N+1):
  if K-Q+d[i]>=0:
    print('Yes')
  else:
    print('No')
# Judge status: Accepted
import math

N = int(input())
min_move_count = 10**13

for i in range(1, int(math.sqrt(N)) + 1):
    if N % i == 0:
        move_count = i + (N // i) - 2
        if move_count < min_move_count:
            min_move_count = move_count

ans = min_move_count
print(ans)
# Judge status: Wrong Answer
a=input()
b=input()
c=input()
from collections import deque
da=deque(list(a))
db=deque(list(b))
dc=deque(list(c))
now=da.popleft()
while (1):
  if now=="a":
    if da:
      now=da.popleft()
    else:
      break
  elif now=="b":
    if db:
      now=db.popleft()
    else:
      break
  elif now=="c":
    if dc:
      now=dc.popleft()
    else:
      break
print(now)
# Judge status: Accepted
a, b, c = map(int, input().split())
ans = 0
if a == b == c and a % 2 == 0:
    print(-1)
else:
    while a % 2 == 0 and b % 2 == 0 and c % 2 == 0:
        total = a + b + c
        a = (total - a) / 2
        b = (total - b) / 2
        c = (total - c) / 2
        ans += 1
    print(ans)
# Judge status: Wrong Answer
n = int(input())
a = list(map(int, input().split()))
cnt = 0
for i in range(1, len(a), 2):
    if a[i]%2 == 1:
        cnt += 1

print(cnt )
# Judge status: Accepted
N, M = map(int, input().split())
load = []
for i in range(M):
    load.append(input().split())

num = [0] * N
for j in range(N):
    for k in range(M):
        if str(j+1) == load[k][0] or str(j+1) == load[k][1]:
            num[j] += 1
    print(num[j])
# Judge status: Accepted
n=int(input())
a=[1]
b=2
s=1
def pr(x):
  for i in range(len(x)):
    print(x[i])
while s<=n:
  a.append(b)
  s+=b
  b+=1
if s==n:
  pr(a)
else:
  c=s-n
  a.remove(c)
  pr(a)
# Judge status: Accepted
a,b = map(int,input().split())
if a >= 13: print(b)
elif 6 <= a:print(b//2)
else:print(0)
# Judge status: Accepted
S=list(map(str,input().split()))
print("A"+S[1][0]+"C")
# Judge status: Accepted
#!/usr/bin/env python3
n, t, a, *h = map(int, open(0).read().split())
h = list(map(lambda x: abs(a-(t-x*0.006)), h))
a = list(enumerate(h))
a.sort(key=lambda x: x[1])
print(a[0][0]+1)
# Judge status: Wrong Answer
from collections import Counter

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

ans = 0
amin = min(a)
amax = max(a)
for x in range(amin, amax+1):
   if x == 0:
      continue
   ans = max(ans, c[x-1]+c[x]+c[x+1])

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

ans = [0]*10001

for a in range(1,101):
    for b in range(1,101):
        for c in range(1,101):
            x = a**2+b**2+c**2+a*b+b*c+a*c
            if x<10001:
                ans[x] += 1
            else:
                break

for i in range(1,n+1):
    print(ans[i])
# Judge status: Accepted
n = int(input())
A = list(map(int, input().split()))
count = 0
while all(a % 2 == 0 for a in A):
    A = [a / 2 for a in A]
    count += 1
print(count)
# Judge status: Wrong Answer
import math

line1 = int(input())
line2 = str(input()).split(" ")
for index in range(len(line2)):
    line2[index] = int(line2[index])

keepTrack = dict()
keys = []
for element in line2:
    if element in keys:
        keepTrack[element] += 1
    else:
        keepTrack[element] = 1
        keys.append(element)
sum = 0
for key in keys:
    ##sum += abs()
    sum += min(abs(key - keepTrack[key]), keepTrack[key])
print(sum)