peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Wrong Answer
N = int(input())
X = [list(map(int, input().split())) for i in range(N)]

s = 0

for i in range(0, len(X)-1, 1):
  a = X[i]
  min = a[0] - a[1]
  max = a[0] + a[1]
  for j in range(i+1, len(X), 1):
    b = X[j]
    b_min = b[0] - b[1]
    b_max = b[0] + b[1]
    if min <= b_max and max >= b_min:
      s += 1
    

print(s)
# Judge status: Wrong Answer
a,b=map(int,input().split())
ans=1
while 1:
  if a==0:
    break
  a//=b
  ans+=1
print(ans)
# Judge status: Wrong Answer
if __name__ == '__main__':
    s = input()
    print("no" if s == "AAA" or s == "BBB" else "yes")
# Judge status: Accepted
n,d=list(map(int,input().split()))
a=[list(map(int, input().split())) for i in range(n)]
cnt=0

def f(x,y):
  cal=0
  for i in range(d):
    cal+=abs(x[i]-y[i])**2
  return cal**0.5

for i in range(n-1):
  for j in range(i+1,n):
    if f(a[i],a[j]).is_integer()==True:cnt+=1

print(cnt)
# Judge status: Wrong Answer
N = input()
for i in range(4):
    moji=N.count(N[i])
    if moji>=3:
        print("Yes")
        break
    else:
        pass
if moji<3:
    print("No")
# Judge status: Accepted
N = int(input())
S = sorted([int(input()) for _ in range(N)])
s = sum(S)
if s % 10 != 0:
    print(s)
    exit()

for si in S:
    if si % 10 != 0:
        print(s - si)
        exit()

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

for a in range(201):
  for b in range(-200,201):
    if a**5-b**5==x:
      print(a,b)
      exit()
# Judge status: Accepted
n,d = map(int,input().split())
print((n + d * 2) // (d * 2 + 1))
# Judge status: Accepted
n,k=list(map(int,input().split()))
n=n%k
m=k-n
print(min(m,n))
# Judge status: Accepted
import collections

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

count = collections.Counter(A)
c = []
for i in count:
    c.append([count[i],i])

c.sort()

l = len(c)
ans = 0
for i in range(0,max(0,l-K),1):
    ans += c[i][0]

print(ans)
# Judge status: Wrong Answer
n = int(raw_input())
count = 0
res = 0
ais = map(int , raw_input().split())

for i,a in enumerate(ais):
	
	if a == i +1:
		count += 1
	else:
		#flush the count
		res += (count+1)/2# + 1
		count = 0
		
if count:
	res +=  count/2 +1
print res
# Judge status: Accepted
from itertools import accumulate

input()
a = list(map(int, input().split()))
b = list(accumulate(a))
c = [abs(y * 2 - b[-1]) for y in b][:-1]
print(min([abs(y * 2 - b[-1]) for y in b][:-1]))
# Judge status: Accepted
a, b, c, d, e = map(int, input().split())
if a==0:
	print(1)
elif b==0:
	print(2)
elif c==0:
	print(3)
elif d==0:
	print(4)
else:
	print(5)
# Judge status: Accepted
a = [list(map(int, input().split())) for i in range(3)]
n = int(input())
for _ in range(n):
	x = int(input())
	for i in range(3):
		for j in range(3):
			if a[i][j] == x: a[i][j] = -1

flag = 0
for i in range(3):
	if a[i][0] == -1 and a[i][1] == -1 and a[i][2] == -1:
		flag = 1
	if a[0][i] == -1 and a[1][i] == -1 and a[2][i] == -1:
		flag = 1

if a[0][0]+a[1][1]+a[2][2] == -3 or a[0][2]+a[1][1]+a[2][0] == -3:
	flag = 1

print("No" if flag == 0 else "Yes")
# Judge status: Wrong Answer
#abc114 a
x=int(input())
medetai=[7,5,3]
if x in medetai:
    print("YES")
else:
    print("No")
# Judge status: Wrong Answer
import sys

n = int(input())

seven = 7

if n < 7:
  print(-1)
  sys.exit()

for i in range(n):
  if seven % n == 0:
    print(i + 1)
    sys.exit()
  seven = seven * 10  + 7
print(-1)
# Judge status: Accepted
N=int(input())
AB=[list(map(int,input().split())) for i in range(N)][::-1]
plus=0
for j in range(N):
    AB[j][0]+=plus
    if AB[j][0]%AB[j][1]!=0:
        a=AB[j][1]-(AB[j][0]%AB[j][1])
        AB[j][0]+=a
        plus+=a
print(plus)
# Judge status: Accepted
from bisect import bisect_left,bisect
 
n = int(input())
p = [-1*int(input())]
for i in range(n-1):
    now = -1*int(input())
    if now >= p[-1]:
        p.append(now)
    else:
        p[bisect(p,now)] = now
print(len(p))
# Judge status: Accepted
n = int(input())
p = list(map(int, input().split()))

ans = 0
for i in range(n-1):
    if p[i]-1 == i:
        p[i], p[i+1] = p[i+1], p[i]
        ans += 1

if p[-1] == n:
    ans+=1

print(ans)
# Judge status: Wrong Answer
n=int(input())
a=[int(input())-1 for i in range(n)]
c,x=1,0
for i in range(n):
  x=a[x]
  if x==2:
    print(i+1)
    break
else:
  print(-1)
# Judge status: Wrong Answer
n=int(input())
b=[10**18]+list(map(int,input().split()))+[10**18]
a=[0]*n
for i in range(n):
  a[i]=min(b[i],b[i+1])
print(a)
print(sum(a))
# Judge status: Accepted
#!/usr/bin/env python3

import sys

input = iter(sys.stdin.read().splitlines()).__next__

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

P = [0]
for d in L:
   P.append(P[-1] + d)

res = len( [1 for x in P if x <= X] )
print(res)
# Judge status: Accepted
n,W = map(int,input().split())
w,v = [0]*n, [0]*n
for i in range(n):
    w[i], v[i] = map(int,input().split())

dp = [[0]*(W+1) for _ in range(n+1)]
for i in range(n):
    for j in range(W+1):
        if j-w[i]>=0:
            dp[i+1][j] = max(dp[i+1][j], dp[i][j-w[i]]+v[i])
        dp[i+1][j] = max(dp[i+1][j],dp[i][j])
print(dp[n][W])
# Judge status: Wrong Answer
import bisect
N,M=map(int, input().split() )
A=list(map(int, input().split() ))
B=[0]*M
C=[0]*M
for i in range(M):
  B[i],C[i]=map(int, input().split() )
A.sort()
summ=sum(A)

for i in range(M):
  p=bisect.bisect_left(A,C[i])
  q=min(p,B[i])
  A= [C[i]]*q+ A[q:]
  
print(sum(A))
# Judge status: Accepted
import math
n = int(input())
ans = 0

for i in range(1,n+1):
    N = math.floor(n / i)
    l = i * N
    s = N / 2 * (i + l)
    ans += s

print(int(ans))
# Judge status: Accepted
S = input()
ans = 'NO'

n = len(S)
if S == 'keyence':
  ans = 'YES'
for i in range(n):
  for j in range(i,n):
    T = S[:i]+S[j:]
    if T == 'keyence':
      ans = 'YES'
print(ans)
# Judge status: Accepted
x = int(input())
ans = x // 11
x -= ans * 11
ans *= 2
if x > 6:
    ans += 2
elif x > 0:
    ans += 1
print(ans)
# Judge status: Accepted
import math
import fractions

if __name__ == '__main__':
    h = int(input())
    n = math.floor(math.log2(h))
    print(2 ** (n + 1) - 1)
# Judge status: Accepted
n,k = map(int,input().split())
a = list(map(int,input().split()))
count =0
while True:
    count += 1
    n -= (k)
    if n <= 0:
        break
    n += 1
print(count)
# Judge status: Accepted
n, a, b = (int(i) for i in input().split());

res = a * (n // (a + b));

curr = n % (a + b);

res += min(a, curr);

print(res);
# Judge status: Accepted
H, N = map(int, input().split())
a_list = list(map(int, input().split()))
if sum(a_list) >= H:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
import heapq
n, m, *a = map(int, open(0).read().split())
a = list(map(lambda x: -x, a))

heapq.heapify(a)
for i in range(m):
    b = -heapq.heappop(a)
    heapq.heappush(a, -(b >> 1))

print(-sum(a))
# Judge status: Wrong Answer
d=int(input())
if d==25:
  print("Christmas")
elif d==24:
  print("Christmas Eve")
else:
  print("Christmas Eve Eve")
# Judge status: Wrong Answer
n = int(input())
lis = list(map(int,input().split()))
cnt = 0
two = 0
for i in lis:
    if i % 4 == 0:
        cnt += 1
    elif i == 2:
        two += 1

if n//2 <= cnt:
    print("Yes")
elif two >= 2 and (n-(two-1))//2 <= cnt:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
n = int(input())
A = sorted(list(map(int, input().split())), reverse=True)
alc = 0
bb = 0
for i in range(n):
    if i % 2 == 0:
        alc += A[i]
    else:
        bb += A[i]
print(alc - bb)
# Judge status: Accepted
n=int(input())
a = 0

for i in range(1,n+1):
  if 0 <=  i  <= 9 :
    a+=1
  if 100 <= i <= 999 :
    a+=1
  if 10000 <= i <= 99999 :
    a+=1
  
print(a)
# Judge status: Accepted
K,X=map(int,input().split())
if 500*K>=X:print("Yes")
else: print("No")
# Judge status: Accepted
x,y,z=map(int,input().split())
w=y+2*z
ans=1
while w<=x-(y+z):
    w+=y+z
    ans+=1
print(ans)
# Judge status: Accepted
a, b = input().split()
print(a*int(b) if a < b else b*int(a))
# Judge status: Wrong Answer
getList = lambda: list(map(int, input().split()))
a,b,x = getList()
if abs(a - x) < abs(b - x):
  print("A")
else:
  print("B")
# Judge status: Accepted
n=int(input())
if n<105:
    print(0)
    exit()
ans=0
for i in range(105,n+1,2):
    c=0
    for j in range(1,i+1):
        if i%j==0:
            c+=1
    if c==8:
        ans+=1
print(ans)
# Judge status: Accepted
a,b,c,d = map(int,input().split())
ok = False
dist = abs(a-c)
if dist <= d: ok = True
else:
    d1 = abs(a-b)
    d2 = abs(b-c)
    if d1 <= d and d2 <= d: ok = True
if ok: print('Yes')
else: print('No')
# Judge status: Accepted
w, h, x, y = map(int, input().split())
s = w * h / 2
t = 0
if 2 * x == w and 2 * y == h:
    t = 1
print(s, t)
# Judge status: Accepted
N=int(input())
work=[]
for i in range(0,N):
    a,b=map(int,input().split())
    work.append([b,a])

work.sort()

now=0
for i in range(0,N):
    b,a=work[i]
    now+=a
    if now>b:
        print('No')
        exit()

print('Yes')
# Judge status: Wrong Answer
A,B,C,X,Y = map(int, input().split())

n = min(X,Y)

sum = 0

sum = min(n*2*C, A*n+B*n)

if X>Y:
    n = X-n
    sum = sum + n*A
else:
    n = Y - n
    sum = sum + n*B

sum_ab = X*A + Y*B

sum_a_b = 2*(X+Y)*C


print(min(sum,sum_ab,sum_a_b))
# Judge status: Wrong Answer
N = input()
Pn = input().split()
Pn_2 = []
result = 0
for ii in Pn:
    if N >= ii:
        Pn_2.append(ii)

last = Pn_2[0]  # 初期化

for i in Pn_2:
    if int(last) >= int(i):
        result += 1
    last = int(i)

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

a.sort()

a_1 = []
for i in range(N,3*N):
  a_1.append(a[i])

P = []
for i in range(2*N):
  if i%2 == 0:
    P.append(a_1[i])
    
print(sum(P))
# Judge status: Wrong Answer
n = int(input())
A = list(map(int, input().split()))

now = 1
hit = 0
for a in A:
    if a != now:
        hit += 1
    else:
        now += 1
print(hit)
# Judge status: Accepted
X = int(input())

def is_prime(n):
  if n ==2:
    return 2
  for i in range(2,n):
    if n % i ==0:
      return False
    elif i**2 > n:
      return True

while 1:
  if is_prime(X):
    print(X)
    break
  else:
    X += 1
# Judge status: Wrong Answer
N = int(input())
A = [int(i) for i in input().split()]
ave = sum(A) // len(A)

ans1 = len(list(filter(lambda x: x == ave or x+1 == ave or x-1 == ave, A)))
ans2 = len(list(filter(lambda x: x == ave+1 or x+1 == ave+1 or x-1 == ave+1, A)))

print(max(ans1, ans2))
# Judge status: Accepted
_ = int(input())
S = str(input())
x = 0
ans = 0
for c in S:
  if c == 'I': x += 1
  else: x -= 1
  ans = max(x, ans)
print(ans)
# Judge status: Wrong Answer
S = list(input())

num = 0
for i in range(len(S)):
    if i % 2 == 0:
        if S[i] == "L":
            num += 1
    else:
        if i == "R":
            num += 1

if num != 0:
    print("No")
else:
    print("Yes")
# Judge status: Wrong Answer
def xy(A):
    ans = 1
    mod = 10**9+7
    for i in range(1,A+1):
        ans *= i % mod

    return ans

def main():
    A = int(input())
    print(xy(A))

if __name__ == '__main__':
    main()
# Judge status: Accepted
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    X = int(readline())

    if X in (7, 5, 3):
        print('YES')
    else:
        print('NO')

    return


if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
n=int(input())
s=[input() for i in range(n)]
m=int(input())
t=[input() for j in range(m)]
l=list(set(s))
print(l)
print(max(0,max(s.count(l[i])-t.count(l[i]) for i in range(len(l)))))
# Judge status: Accepted
import sys
input = sys.stdin.readline

n=int(input())
a=sorted(list(map(int,input().split())),reverse = 1)
print(sum(a[::2]) - sum(a[1::2]))
# Judge status: Wrong Answer
n = (int)(input())
a = list(map(int, input().split(" ")))
xor = []
ans = 0
for i in range(1, 2 * (10 ** 5 + 1)):
    xor = []
    test = 1
    for j in range(n):
        xor.append(a[0] ^ i)
    for j in range(n - 1):
        test *= xor[j]
    if test == xor[-1]:
        ans = i
        break
#print(ans)
txt = ""
for i in range(n):
    txt += (str)(a[i] ^ ans)
    if i != n - 1:
        txt += " "
print(txt)
# Judge status: Accepted
N = int(input())
B = 0
for i in range(N):
  A = 0
  n = int((i+1)**(1/2))
  for j in range(n):
     if (i+1) % (j+1) == 0:
        A += 1
  if A == 4 and (i+1) % 2 == 1:
    B += 1
print(B)
# Judge status: Accepted
if input() in "aiueo":
  print("vowel")
else:
  print("consonant")
# Judge status: Accepted
import sys
readline = sys.stdin.buffer.readline
a,b,c,k =list(map(int,readline().rstrip().split()))
if k <= a:
  print(k)
elif k > a and k <= a + b:
  print(a)
else:
  print(a -(k-(a+b)))
# Judge status: Wrong Answer
N=int(input())
for i in range(N):
  if (i**2)>N:
    break
print((i-1)**2)
# Judge status: Accepted
n, h = map(int, input().split())
a = []
b = []
for _ in range(n):
    x, y = map(int, input().split())
    a.append(x)
    b.append(y)

a = max(a)
b.sort(reverse=True)
ans = 0
for i in b:
    if i<=a:
        ans += (h+a-1)//a
        print(ans)
        break
    h -= i
    ans += 1
    if h<=0:
        print(ans)
        break
else:
    ans += (h+a-1)//a
    print(ans)
# Judge status: Wrong Answer
N, K = map(int, input().split())
P = map(int, input().split())

PP = sum(sorted([(1 + pp) / 2 for pp in P], reverse=True)[:3])
print(PP)
# Judge status: Wrong Answer
n = int(input())
a = [0] * n
b = [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)]
    if wa > i:
        print("No")
        exit()
print("Yes")
# Judge status: Wrong Answer
n=int(input())
a=int(input())
if n%500<a:
    print('Yes')
else:
    print('No')
# Judge status: Wrong Answer
from math import gcd, ceil
from functools import reduce
import sys

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

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

N, M = map(int, input().split())
a = [int(i) for i in input().split()]

if N == 1:
    print((M-a[0]//2)//a[0])
    sys.exit()

A = []
for x in a:
    if x//2%2 == 0:
        print(0)
        sys.exit()
    A.append(x//2)
lcm = lcm_list(A)
print(ceil(M//lcm/2))
# Judge status: Wrong Answer
def main():
    k, a, b = map(int, input().split())
    cookie = 1
    if b <= a + 2:
        cookie += k
    else:
        cookie += b
        k -= a + 1
        cookie += (b - a) * max(0, k // 2)
        cookie -= (k + 1) % 2
    print(cookie)


if __name__ == '__main__':
    main()
# Judge status: Accepted
n,x = map(int,raw_input().split())
l = map(int,raw_input().split())
d1=0
bou = 1
for i in xrange(n):
    d1 += l[i]
    
     
    if d1 > x:
        break
    else:
        bou += 1
print bou
# Judge status: Accepted
N, M, X, Y = map(int, input().split())
x = list(map(int, input().split()))
y = list(map(int, input().split()))

x = max(x)
y = min(y)

if (x < y) and (X < y) and (Y >= y):
    print("No War")
else:
    print("War")
# Judge status: Accepted
k, a, b = map(int, input().split())


if b - a < 2:
    print(k + 1)
else:
    t = k - a + 1
    if t >= 2 and t % 2 == 0:
        ans = (b - a) * (t // 2) + a
    else:
        ans = (b - a) * (t // 2) + a + 1
    print(ans)
# Judge status: Accepted
import fractions
a, b = map(int, input().split())
print(a * b // fractions.gcd(a, b))
# Judge status: Accepted
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[k - 1])
# Judge status: Accepted
# coding: utf-8

def main():
    N, A, B = map(int, input().split())
    quo = N // (A + B)
    rem = N % (A + B)

    if (rem > A): rem = A
    ans = quo * A + rem

    print(ans)

if __name__ == "__main__":
    main()
# Judge status: Accepted
N=int(input())
S=input()
T=input()

ans=2*N
i=N
while i:
    if S[-i:]==T[:i]:
        ans-=i
        break
    i-=1

print(ans)
# Judge status: Wrong Answer
n,m,x,y=map(int,input().split())

x=list(map(int,input().split()))
y=list(map(int,input().split()))

if max(x)<=min(y):
    print("No War")
else:
    print("War")
# Judge status: Wrong Answer
n = int(input())
divs = []
for i in range(1, int(n ** 0.5) + 1):
  if n % i == 0:
    divs.append(i)
    if i != n // i:
      divs.append(n // i)
sdivs = sorted(divs)
lsdivs = len(sdivs)
a = sdivs[lsdivs // 2 - 1]
b = sdivs[lsdivs // 2]
print(a + b - 2)
# Judge status: Wrong Answer
x,y = map(int,input().split())

X = abs(x)
Y = abs(y)

ans = 0

if X > Y:
  if y > x:
    ans = min((y - x),abs(y - x) + 1)
  else:
    ans = abs(y - x) + 1
    if y > 0: # 符号再変換
      ans += 1
  
elif Y > X:
  if y > x:
    ans = min((y - x),abs(y - x) + 1)
  else:
    ans = abs(y - x) + 1
    if x > 0: # 符号再変換
      ans += 1
  
elif X == Y:
  if x == y:
    ans = 0
  else:
    ans = 1
    
print(ans)
# Judge status: Wrong Answer
a, b, c = sorted(map(int, input().split()))
if a == b + c:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
from collections import deque

s = deque(input())
q = int(input())

rev = False
for i in range(q):
    query = input().split()
    if query[0] == "1":
        rev ^= True
    else:
        if (query[1] == "1" and not rev) or (query[1] == "2" and rev):
            s.appendleft(query[2])
        else:
            s.append(query[2])

if rev:
    print("".join(list(s)[::-1]))
else:
    print("".join(list(s)))
# Judge status: Wrong Answer
a, b = map(int, input().split())
if a >= 8 and b >= 8:
  print('Yay!')
else:
  print(':(')
# Judge status: Accepted
N = int(input())

numberdict = dict()
for i in range(N):
    A_i = int(input())
    if A_i in numberdict:
        numberdict[A_i] += 1
    else:
        numberdict[A_i] = 1
ans = 0
for j in numberdict.keys():
    if numberdict[j] % 2 == 1:
        ans += 1
print(ans)
# Judge status: Accepted
N,M,X,Y = map(int,input().split())
x = list(map(int,input().split()))
x.sort()
y = list(map(int,input().split()))
y.sort()
if max(X,x[-1]) < min(Y,y[0]):
    print("No War")
else:
    print("War")
# Judge status: Accepted
n = int(input())
l = list(map(int,input().split()))
s = sum(l)
ans = 10**15
a = l[0]
ans = min(ans,abs((s-a)-a))
for i in range(1,n-1):
  a += l[i]
  ans = min(ans,abs((s-a)-a))
print(ans)
# Judge status: Wrong Answer
N = int(input())
A = list(map(int, input().split()))

import numpy as np

ans = 0
for i in range(N):
    if A.count(A[i]) == N:
        ans = 0
        break
        break
    c = [j for j in A[i]/np.array(A) if j.is_integer() ]
    if len(c) == 1:
        ans += 1
print(ans)
# Judge status: Wrong Answer
N = int(input())
candies_i = list(map(int, input().split()))
candies_j = list(map(int, input().split()))

l = []

for i in range(N):
    total_li = sum(candies_i[:i])
    total_lj = sum(candies_j[i:])
    total = ( total_li + total_lj )
    l.append(total)

print(max(l))
# Judge status: Accepted
S=input()
for c in S:
    if S.count(c)>1:
        print("no")
        break
else:
    print("yes")
# Judge status: Accepted
N = int(input())
S = input()
ans = ''
for letter in S:
  ans += chr((ord(letter)+N-ord('A'))%26 + ord('A'))
print(ans)
# Judge status: Wrong Answer
n = int(input())
t,a = map(int,input().split())
ans = []

l = list(map(int,input().split()))
    
for i in l:
    ans.append(a - (t - (i * 0.006)))

print(ans.index(min(ans))+1)
# Judge status: Wrong Answer
S = input()
T = input()
t = len(T)

for i in range(len(S)-t, -1, -1):
    print(i)
    for j in range(t):
        k = S[i+j]
        if k != T[j] and k != "?":
            break
    else:
        print((S[:i]+T+S[i+t:]).replace("?", "a"))
        exit()
print("UNRESTORABLE")
# Judge status: Accepted
A, B, C = map(int, input().split())
if A + C == B * 2:
    print('YES')
else:
    print('NO')
# Judge status: Accepted
def resolve():
    import math
    n = int(input())
    res = math.ceil(n / 1.08)
    if str(res)[-2:] == '.0':
        print(int(res))
    elif str(res * 1.08).split('.')[0] == str(n):
        print(int(str(res).split('.')[0]))
    else:
        print(':(')

resolve()
# Judge status: Accepted
A,B,C = list(map(int,input().split()))

if A == B == C:
    print('No')
elif A == B and B != C:
    print('Yes')
elif A != B and A == C:
    print('Yes')
elif A != B and B ==C:
    print('Yes')
elif A != B and A != C:
    print('No')
else:
    print('No')
# Judge status: Accepted
S = input()

if 'a' in S and 'b' in S and 'c' in S:
    print('Yes')
else:
    print('No')
# Judge status: Wrong Answer
a,b,c=map(int,input().split())
num = a
if (a % 2 == 1 and c % 2 == 0) or (a % 2 == 0 and c % 2 == 1):
  print('No')
else:
  while True:
    if a % b == c:
      print('YES')
      break
    a += num
# Judge status: Accepted



N,M = map(int, input().split())
xy = [tuple(map(int, input().split())) for _ in range(M)]

prob = [False] * N
prob[0] = True
cnts = [1] * N

for x,y in xy:
    cnts[x-1] -= 1
    cnts[y-1] += 1
    if prob[x-1] == True:
        prob[y-1] = True
    if cnts[x-1] == 0:
        prob[x-1] = False

ans = 0
for i in range(N):
    if prob[i]:
        ans += 1

print(ans)
# Judge status: Wrong Answer
a,b=map(int,input().split())
if (2*b-a)%3!=0 or (2*a-b)%3!=0:
  print(0)
else:
  n=(2*b-a)//3
  m=(2*a-b)//3
  p = 10**9+7
  def nCr(n,r):
    if r*2>n:
        return nCr(n,n-r)
    else:
        a = b = 1
        for i in range(r):
            a = a * (n - i) % p
            b = b * (r - i) % p
        return (a * pow(b,p-2,p)) % p

  print(nCr((m+n),m))
# Judge status: Wrong Answer
#-*-coding:utf-8-*-
import sys
input=sys.stdin.readline

def main():
    boards=[]
    n = int(input())
    boards=list(map(int,input().split()))
    data=sum(boards)
    count=0

    if data%2!=0:
        print(count)
        exit()

    while True:
        if data%2==0:
            data=data//2
            count+=1
        else:
            break

    print(count)


if __name__=="__main__":
    main()
# Judge status: Wrong Answer
n =int(input())
li =list(map(int,input().split()))
count =0
for i in range(1,len(li),2):
    if li[i] % 2 !=0:
        count +=1
    

print(count)
# Judge status: Accepted
N = int(input())
As = []
Bs = []

for _ in range(N):
  a,b = map(int,input().split())
  As.append(a)
  Bs.append(b)
  
As.sort()
Bs.sort()

if N%2 == 1:
  ma = As[N//2]
  mb = Bs[N//2]
  print(mb-ma+1)
else:
  ma = (As[N//2-1] + As[N//2])/2
  mb = (Bs[N//2-1] + Bs[N//2])/2
  print(int((mb-ma)*2)+1)
# Judge status: Accepted
def main():
    N = int(input())
    W_before = input()
    W_list = set()
    W_list.add(W_before)
    for i in range(N-1):
        W_after = input()
        if W_before[-1] != W_after[0]:
            print('No')
            return
        if W_after in W_list:
            print('No')
            return
        W_list.add(W_after)
        W_before = W_after
    print('Yes')

if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
import math
a = int(input())
print(a*math.pi)
# Judge status: Wrong Answer
n = int(input())
L = sorted(list(map(int, input().split())))
count = 0
i = n-1
for a in L[::-1]:
    j = 0
    for b, c in zip(L[:i-1], L[1:i]):
        if a < b + c:
            count += (i-j-1)*(i+j)//2
            break
        j += 1
    i -= 1
print(count)
# Judge status: Accepted
year=int(input())

if year==3 or year==5 or year==7:
  print("YES")
  
else:
  print("NO")
# Judge status: Accepted
# B - Sum of Three Integers

k,s = map(int,input().split())
c = 0
min_limit = s - k

for i in range(k+1):
    for j in range(k+1):
        if i + j <= s and i + j >= min_limit:
            c += 1
print(c)
# Judge status: Wrong Answer
a = int(input())
b = int(input())

if a == 1 and b == 2:
  print(3)
  
elif a == 2 and b == 3:
  print(1)
  
elif a == 3 and b == 1:
  print(2)
# Judge status: Wrong Answer
c=str(input())
if c in "aiueo":
  print("YES")
else:
  print("NO")
# Judge status: Wrong Answer
n = int(input())
a = list(map(int,input().split()))

total = sum(a)
s = 0
i = 0
ans = total + 1
for i in range(n):
    s += a[i]
    total -= a[i]
    ans = min(ans, abs(s - total))
    i += 1
print(ans)
# Judge status: Accepted
import statistics
N = int(input())
A = list(map(int,input().split()))
s = 0
X = []

for i in range(N):
  A[i] -= i + 1

b = statistics.median(A)

for i in range(1,N+1):
  s += abs(A[i-1] - int(b))

print(s)