peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
s = input()
flag = [0] * 4
for i in range(len(s)):
  if s[i] == "N":
    flag[0] = 1
  elif s[i] == "S":
    flag[1] = 1
  elif s[i] == "W":
    flag[2] = 1
  else:
    flag[3] = 1
if flag[0] == flag[1] and flag[2] == flag[3]:
  print("Yes")
else:
  print("No")
# Judge status: Wrong Answer
a,b = map(int, input().split())
print(a+b/2)
# Judge status: Accepted
α=input()
abc=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
if α in abc:
  print("a")
else:
  print("A")
# Judge status: Wrong Answer
line = input()
X, Y = [int(n) for n in line.split()]

broken_steps = set()
for _ in range(Y):
    line = input()
    broken_steps.add(int(line))

if 1 in broken_steps:
    stairs = [0]
else:
    stairs = [1]

if 2 in broken_steps:
    stairs.append(0)
else:
    stairs.append(2)

for i in range(2, X):
    number_of_steps = 0
    if i+1 not in broken_steps:
        number_of_steps = stairs[i - 1] + stairs[i-2]
    stairs.append(number_of_steps)
predicted_value = stairs[X-1]
print(predicted_value % 1000000007)
# Judge status: Accepted
s = int(input())
if s >= 30: print('Yes')
else: print('No')
# Judge status: Accepted
n = int(input())
a=[]
for x in range(n):
    a.append(int(input()))
numlist = sorted(a)
t = a[0]
m = [0]
p = 0
for x in numlist:
    if t == x:
        m[-1] += 1
    else:
        m.append(1)
        t=x
for x in m:
    if x % 2 == 1:
        p += 1
print(p)
# Judge status: Accepted
n = int(input())
w = [input() for _ in range(n)]

ans = 'Yes'
for i in range(1, n):
    if (w[i] in w[:i]) or (w[i][0] != w[i - 1][-1]):
        ans = 'No'
        break
print(ans)
# Judge status: Accepted
#!/usr/local/bin python
# -*- coding: utf-8 -*-
#
# ~/PycharmProjects/atcoder/B-BetweenAandB.py
#

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

print(b//x - (a-1)//x)
# Judge status: Accepted
N = int(input())
div = N//15
print(800*N-200*div)
# Judge status: Accepted
n,m=map(int,input().split())
a=[]
for _ in range(n):
    a.append([int(i) for i in input().split()])
a.sort()
ans=0 ; ind=-1 ; p=0
while ans<m:
    ind+=1
    ans+=a[ind][1]
for i in range(ind):
     p+=a[i][1]*a[i][0]
p+=a[ind][0]*(a[ind][1]-(ans-m))
print(p)
# Judge status: Accepted
S=input()
for i in range(len(S)-1):
  if S[i]==S[i+1]:
    print('Bad')
    exit()
print('Good')
# Judge status: Wrong Answer
def resolve():
	S = list(input())
	T = list(input())
	lenT = len(T)
	res = lenT
	for i in range(len(S)-lenT):
		tmp = lenT
		for j in range(lenT):
			if S[i+j] == T[j]:
				tmp -= 1
		res = min(res, tmp)
	print(res)
resolve()
# Judge status: Accepted
x = int(input())

cnt = 0
s = 0

for i in range(1, x+1):
    cnt += 1
    s += i
    if s >= x:
        break

print(cnt)
# Judge status: Wrong Answer
A=int(input())
B=int(input())
C=int(input())
D=int(input())
E=int(input())
count=0
lis=[[A,A%10],[B,B%10],[C,C%10],[D,D%10],[E,E%10]]
lis.sort(key=lambda x:x[1], reverse=True)
#print(lis)

for i in range(len(lis)):
    if not(i==len(lis)-1):
        count=count+lis[i][0]+(10-lis[i][1])%10
    else:
        count=count+lis[i][0]
print(count)
# Judge status: Accepted
N,K=map(int,input().split())
A=list(map(int,input().split()))
cnt=0
for i in range(10**5+1):
    N-=K
    cnt+=1
    if N<=0:
        break
    else:
        N+=1
print(cnt)
# Judge status: Wrong Answer
n,r=list(map(int,input().split()))

if n<10:
  r=r-100*(10-n)
  
print(r)
# Judge status: Wrong Answer
n=int(input())
l=list("abcdefghijklmnopqrstuvwxyz")
name=""
while n>=1:
    name=(l[n%26-1])+name
    n//=26
print(name)
# Judge status: Accepted
from itertools import *
N,K = map(int,input().split())
D = list(map(int,input().split()))

num = []

for i in range(10):
  if i not in D:
    num.append(str(i))
ans = 10**18
for i in product(num,repeat=len(str(N))):
  money = int(''.join(list(i)))
  if N <= money :
    ans = min(ans,money)
if ans == 10**18:
  for i in product(num,repeat=len(str(N))+1):
    money = int(''.join(list(i)))
    if N <= money :
      ans = min(ans,money)
print(ans)
# Judge status: Accepted
a,b = map(int,input().split())
ab = str(a)*b
ba = str(b)*a
print(min(ab,ba))
# Judge status: Wrong Answer
import sys
from collections import Counter
input = sys.stdin.readline
h=input()[:-1]
c=Counter(h)
num=min(c["0"],c["1"])
num1=max(c["0"],c["1"])
print(num if num!=0 else num1//2)
# Judge status: Accepted
A,B,C,D=map(int,input().split())
if C<=A and A<=D and D<=B:
    print(D-A)
elif C<=A and B<=D:
    print(B-A)
elif A<=C and C<=B and B<=D:
    print(B-C)
elif A<=C and D<=B:
    print(D-C)
else:
    print(0)
# Judge status: Wrong Answer
n = int(input())

a = 0

for i in range(1, n):
    for j in range(1, n):
        if str(i)[0] == str(j)[-1] and str(i)[-1] == str(j)[0]:
            a += 1
print(a)
# Judge status: Accepted
n = input()
ans = [str(i)*3 for i in range(0,10)]
print('Yes' if n[:3] in ans or n[1:] in ans else 'No')
# Judge status: Wrong Answer
s=input()
rs=s[::-1]
ans=0
for i in range (len(s)):
  if s[i] != rs[i]:
    ans+=1
print(ans)
# Judge status: Accepted
S=input()
n=('N' in S)
s=('S' in S)
w=('W' in S)
e=('E' in S)
if not n^s and not w^e:
  print('Yes')
else:
  print('No')
# Judge status: Accepted

import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline

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

print(len(set(abc)))
# Judge status: Accepted
import itertools


min_time = 1000000
D = [int(input()) for _ in range(5)]
for p in itertools.permutations(D):
    time = 0
    for i in range(5):
        d = p[i]
        if i < 4:
            for _ in range(9):
                if d%10 == 0:
                    break
                d += 1
        time += d
    min_time = min(min_time, time)
print(min_time)
# Judge status: Wrong Answer
a=list(map(str,input().split()))
b=[]
c=len(a)
for k in range(1,c):
  if a[k]=="1":
    b.append("1")
  elif  a[k]=="0":
    b.append("0")
  else:
    del b[k-1]
f=" ".join(b) 
print(f)
# Judge status: Accepted
pqr = list(map(int,input().split()))
pqr = sorted(pqr)
print(sum(pqr[:2]))
# Judge status: Wrong Answer
import sys
input = sys.stdin.readline
INF = 10 ** 10
MOD = 10 ** 9 + 7
from functools import lru_cache
sys.setrecursionlimit(100000000)

def main():
    n = int(input())
    ans = 0
    before = 0
    for _ in range(n):
        a = int(input())
        ans += a//2
        if (a%2) and before :
            ans += 1
            before = 0
        else:
            before = a%2
    print(ans)

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

for i in range(a):
    if (i*b+c)%a == 0:
        print('YES')
        break
else:
    print('NO')
# Judge status: Wrong Answer
a = input()
all_list = []
for i in range(1, 10):
    for j in range(1, 10):
        all_list.append(int(i * j))

if int(a) in all_list:
    print('Yes')
else:
    print('No')
# Judge status: Wrong Answer
A,B=map(int,input().split())
if (A+B)%2 == 0:
  print((A+B)/2)
else:
  print('IMPOSSIBLE')
# Judge status: Accepted
a, b = map(int, input().split())
if (a+b)%2 == 0:
  print(int((a+b)/2))
else:
  print("IMPOSSIBLE")
# Judge status: Accepted
from collections import Counter
m1=0
N=int(input())
A=Counter(list(map(int,input().split())))
key=sorted(A.keys(),reverse=True)
for i in key:
  if A[i]>1 and m1==0:
    m1=i
    if A[i]>3:
      print(i**2)
      exit()
  elif m1!=0 and A[i]>1:
    print(m1*i)
    exit()
print(0)
# Judge status: Wrong Answer
N = int(input())
mozi = input()
mozi2 = list(mozi)
a = len(mozi2)
num_w = mozi2.count("W")
list_w = mozi2[(a-num_w+1):]
list_r = mozi2[:(a-num_w+1)]
if "W" in list_w:
    print(list_r.count("W"))
else:
    print(num_w)
# Judge status: Wrong Answer
n = int(input())
a = list(map(int,input().split()))
r = [0 for _ in range(max(a)+2)]
for i in range(n):
    r[a[i]] += 1
ans = 0
for i in range(len(r)-2):
    ans = max(ans,sum(r[i:i+3]))
print(ans)
# Judge status: Accepted
A,B,C,D = map(int,input().split())
if B<=C or A>=D:
    print(0)
elif A<C<B<D:
    print(B-C)
elif C<A<D<B:
    print(D-A)
else:
    print(min(D-C,B-A))
# Judge status: Accepted
def lcm(X,Y):
    x=X
    y=Y
    if y>x:
        x,y=y,x
    while x%y!=0:
        x,y=y,x%y
    return X*Y//y

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

LCM = A[0]
for i in range(0,N-1,1):
    LCM = lcm(LCM,A[i+1])
B = [0 for i in range(0,N,1)]
for i in range(0,N,1):
    B[i]= (LCM%MOD)*pow(A[i],MOD-2,MOD)%MOD

ans = 0
for i in range(0,N,1):
    ans = (B[i] + ans)%MOD

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

ans = 0

for i in range(1,int(m**0.5)+1):
    if m%i == 0 and i <=m//n:
        ans = max(ans,i)
print(ans)
# Judge status: Wrong Answer
import math

N = input()
As = map(int, input().split())
Fs = map(lambda a: math.log2(a) if a % 2 == 0 else 0, As)

print(int(min(Fs)))
# Judge status: Accepted
X = int(input())

if X >= 30:
  print('Yes')
else:
  print('No')
# Judge status: Wrong Answer
H,N = map(int,input().split())
A = list(map(int,input().split()))
if H-sum(A) < 0:
  print('Yes')
else:
  print('No')
# Judge status: Wrong Answer
def func(n):
    div = 0 
    for i in range(1, int(n**0.5)+1):
        if(n%i == 0):
            div += 1
            if(i != n //i):
                div += 1
    return div

def main():
    N = int(input())

    ans = 0
    for i in range(1, N+1):
        ans += i*func(i)
    print(ans)
# Judge status: Accepted
s = input()
dict = {"SUN":7,"MON":6,"TUE":5,"WED":4,"THU":3,"FRI":2,"SAT":1}
print(dict[s])
# Judge status: Accepted
A, B, K = map(int, input().split())
list = range(A, B+1) #上限下限を先に決めておく
set1 = set(list[:K])
set2 = set(list[-K:])
print(*sorted(set1|set2), sep='\n')
# Judge status: Accepted
N, K= map(int,input().split())
a = list(map(int,input().split()))
p=0
while p<K:
  B=[0]*(N+1)
  for i in range(N):
    t = a[i]
    B[max(i-t,0)] +=1
    B[min(i+t+1,N)] -=1
  for i in range(N):
    B[i+1] += B[i]
  a=B[:N]        
  if min(a)==N:
    break
  p+=1
print(*a)
# Judge status: Accepted
a=[0]*5
a[0]=int(input())
a[1]=int(input())
a[2]=int(input())
a[3]=int(input())
a[4]=int(input())
time=0
ama=0
  
for i in range(5):
  tmp=10-a[i]%10
  if tmp==10:
    tmp=0
  a[i]+=tmp
  if ama<tmp:
    ama=tmp
    
print(sum(a)-ama)
# Judge status: Accepted
n=int(input())
if n==0:
  print(2)
elif n==1:
  print(1)
else:
  pre1,pre2=1,2
  ans=0
  for i in range(n-1):
    ans=pre1+pre2
    pre1,pre2=ans,pre1
  print(ans)
# Judge status: Wrong Answer
n = int(input())
a = list(map(int, input().split()))
cnt = [0]*(10**5)
for i in range(0,10*5):
    cnt[i] = a.count(i+1)
s = sum(a)
q = int(input())
for _ in range(q):
    b, c = map(int, input().split())
    s += (c-b)*cnt[b-1]
    cnt[c-1]+=cnt[b-1]
    cnt[b-1]=0
    print(s)
# Judge status: Wrong Answer
X = input()

tright = X.rfind('T')
print(len(X) - 2 * X[0:tright].count('S'))
# Judge status: Accepted
n = int(input())
i = 1
a,b = 1,n
while i*i <= n:
    if n % i == 0:
        a = i
        b = n//i
    i += 1


print(a+b-2)
# Judge status: Accepted
import collections
def main():
    x,y,z=map(int, input().split())
    k = y+z+z
    res = 1
    while((k<x)):
        k+=(z+y)
        if(k>x):
            break
        res+=1
    print(res)

if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
X = int(input())
n = 360
while(1):
  if n%X == 0:
    print(int(360/X))
    break
  n = n + 360
# Judge status: Accepted
a,b,c,k = map(int,input().split())
if(a>=k):
  print(k)
else:
  if(a+b>=k):
    print(a)
  else:
    print(a-(k-(a+b)))
# Judge status: Accepted
N = int(input())

"""
4k = N - 7n
"""
for i in range(15):
    k = (N-(7*i)) / 4
    if k % 1 == 0 and k >= 0:
        print("Yes")
        break
    if i == 14:
        print("No")
# Judge status: Accepted
n = int(input())
A = list(map(int,input().split()))

four = 0
two = 0
other = 0

for a in A:
    if a%4 == 0:
        four += 1
    elif a%2 == 0:
        two += 1
    else:
        other += 1
        
if two:
    if (other+1) <= four+1:
        print("Yes")
    else:
        print("No")
else:
    if other <= four+1:
        print("Yes")
    else:
        print('No')
# Judge status: Accepted
n=int(input())
s=str(input())
s=list(s)
import collections
c=collections.Counter(s)
values, counts = zip(*c.most_common())
temp=list(counts)
l=len(temp)
ans=1
for i in range(l):
  ans=ans*(temp[i]+1)
print((ans-1)%(10**9+7))
# Judge status: Wrong Answer
K = int(input())
S = str(input())

SK = S[0 : (K)]

if len(S) <= K:
    answer = S
else:
    print(SK + '...')
# Judge status: Accepted
a = int(input())
b = int(input())
c = int(input())
x = int(input())
cnt = 0
for i in range(a+1):
  for j in range(b+1):
    for k in range(c+1):
      if 500*i + 100*j + 50*k == x:
        cnt += 1
 
print(cnt)
# Judge status: Accepted
n=int(input())
a=list(map(int,input().split()))
ans=10**9
ab=0
for i in range(-100,101):
    count=0
    for j in range(n):
        count+=abs(a[j]-i)**2
    if ans>count:
        ans=count
        ab=i
print(ans)
# Judge status: Accepted
H = int(input())
ans = 0

l = []
n = 1

while n <= H:
    l.append(n)
    n *= 2
print(sum(l))
# Judge status: Accepted
ans=""
for i in list(input()):
    if ans and i=="B":ans=ans[:-1]
    else:ans=ans+i if i!="B" else ans
print(ans)
# Judge status: Accepted
N, M = map(int,input().split())
def make_divisors(n):
    lower_divisors , upper_divisors = [], []
    i = 1
    while i*i <= n:
        if n % i == 0:
            lower_divisors.append(i)
            if i != n // i:
                upper_divisors.append(n//i)
        i += 1
    return lower_divisors + upper_divisors[::-1]
D = sorted(make_divisors(M))[::-1]

for e in D:
    if N*e <= M:
        print(e)
        exit(0)
# Judge status: Accepted
import numpy as np
N, x = map(int, input().split())
A = np.array(sorted(list(map(int, input().split()))))
cumsum = A.cumsum()

if cumsum[-1] < x:
    print(N - 1)
    exit()

ans = 0
for i in range(N):
    if cumsum[i] <= x:
        ans = i + 1
print(ans)
# Judge status: Accepted
N=int(input())
ans=0
for i in range(1,N+1):
  Y=N//i
  ans+=Y*(Y+1)*i//2
print(int(ans))
# Judge status: Accepted
N=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))

asum=sum(a)
bsum=sum(b)
if bsum<asum:
    print("No")
    exit()

ab=0
ba=0

for i in range(N):
    if a[i]<b[i]:
        ab+=(b[i]-a[i])//2
    else:
        ba+=a[i]-b[i]

if ab>=ba:
    print("Yes")
else:
    print("No")
# Judge status: Wrong Answer
n = int(input())
p = list(map(int, input().split()))
 
ans = 0
for i in range(1, n-1):
  if p[i] >= p[i-1] and p[i] <= p[i+1]: ans += 1

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

if a != 1:
    for i in range(int(b)-1):
        aa = aa + a
if b != 1:
    for j in range(int(a)-1):
        bb = bb + b

if a < b:
    print(aa)
else:
    print(bb)
# Judge status: Wrong Answer
x,y = map(int, input().split())

num = y/x
count = 0

while num>=1:
    num /=2
    count += 1

print(count)
# Judge status: Accepted
import math
 
N,D = map(int, input().split())
X = [list(map(int, input().split())) for _ in range(N)]
 
ans = 0
 
for i in range(N-1):
    for j in range(i+1, N):
        d = 0
        for k in range(D):
            d += (X[i][k] - X[j][k])**2
        ans += math.sqrt(d).is_integer()
print(ans)
# Judge status: Wrong Answer
N, L = map(int, input().split())
S = []
for x in range(N):
    S.append(input())

S = sorted(S)
for x in range(N):
    print(S[x], end=" ")
# Judge status: Accepted
n = int(input())
a = [int(input()) for _ in range(n)]

ans = -1
visited = set()
count = 0
btn = 0
for i in range(n):
  if btn in visited:
    break
  visited.add(btn)
  btn = a[btn]-1
  count += 1
  if btn == 1:
    ans = count
    break

print(ans)
# Judge status: Accepted
a, b, c = map(int, input().split())
if(sum([a, b, c]) >= 22):
    print("bust")
else:
    print("win")
# Judge status: Wrong Answer
n = int(input())

for i in range(n+1):
    tmp = n
    now = i*(i+1)//2
    tmp -= now
    if tmp < i:
        break

for j in range(1,i):
    print(j)
    
print(n-(i-1)*i//2)
# Judge status: Wrong Answer
# B - String Palindrome

S = input()

ans = 'No'

N = len(S)
left1 = S[:(N - 1) // 2]
right1 = S[((N + 3) // 2) - 1:]
if left1 == right1:
    N = len(left1)
    left2 = left1[:(N - 1) // 2]
    right2 = left1[((N + 3) // 2) - 1:]
    if 1 < N and left2 == right2:
        N = len(right1)
        left3 = right1[:(N - 1) // 2]
        right3 = right1[((N + 3) // 2) - 1:]
        if 1 < N and left3 == right3:
            ans = 'Yes'

print(ans)
# Judge status: Accepted
import sys
import collections
sys.setrecursionlimit(10**6)


def main(input, print):
    n = int(input())
    ans = 0
    for i in range(1, n+1):
        ans += i * ((n//i)*(n//i+1)//2)
    print(ans)


if __name__ == '__main__':
    main(sys.stdin.readline, print)
# Judge status: Wrong Answer
x = int(input())

ans = 360 / x

if ans - int(ans) != 0:
    print(int(ans) + 1)
else:
    print(int(ans))
# Judge status: Accepted
def read():
    N, K = map(int, input().split())
    A = list(map(int, input().split()))
    return N, K, A

def solve(N, K, A):
    for i in range(N-K):
        if A[i] < A[i+K]:
            print("Yes")
        else:
            print("No")


if __name__ == '__main__':
    inputs = read()
    solve(*inputs)
# Judge status: Accepted
n, k, q = map(int, input().split())
a = [int(input()) for _ in range(q)]
sc = {i : 0 for i in range(1, n+1)}
sc[0] = 0

for s in a:
  sc[s] += 1

del sc[0]
for s in sc.values():
  print("Yes" if (k-q+s)>0 else "No")
# Judge status: Accepted
N,W = [int(i) for i in input().rstrip().split()]
F = [[int(i) for i in input().rstrip().split()] for _ in range(N)]

DP = []
for w,v in F:
    if DP == []:
        DP = [0]*w+[v]*(W-w+1)
    else:
        dp = DP[::]
        for w2 in range(w,W+1):
            dp[w2] = max(DP[w2-w] + v, DP[w2])
        DP = dp
    #print(DP)
print(DP[-1])
# Judge status: Accepted
S = input()

c = 0
bs = ''
ns = ''
for i in range(len(S)):
    ns = ns + S[i]
    if bs == ns:
        continue
    else:
        bs = ns
        c += 1
        ns = ''
        # print(bs)
print(c)
# Judge status: Wrong Answer
pn=[2];A=50000
for L in range(3,A):
    chk=True
    for L2 in pn:
        if L%L2 == 0:chk=False
    if chk==True:pn.append(L)
      
ln=[]
for i in range(len(pn)):
  for j in range(10):
    ln.append(pn[i]**j)
mn=sorted(list(set(ln)))

n=int(input())

if n==1:
  print(0)
  exit()

count=0
for k in range(1,len(mn)):
  if n%mn[k]==0:
    n=n//mn[k]
    count+=1
    if n==1:
      break
if count==0:
  print(1)
  exit()
print(count)
# Judge status: Accepted
a,b=map(int,input().split())
s=input()
print('Yes' if s[a]=='-' and s.count('-')==1 and len(s)==a+b+1 else 'No')
# Judge status: Accepted
A, B, C = map(int,input().split())

counter = 1
possible_remainders = []


while counter >= 0:
  remainder = (A*counter)%B
  if remainder in possible_remainders:
    break
  else:
    possible_remainders.append(remainder)
    counter += 1

if C in possible_remainders:
  print("YES")
else:
  print("NO")
# Judge status: Accepted
a,b,t = map(int, input().split())
print(t // a * b)
# Judge status: Wrong Answer
N = int(input())
a = [int(x) for x in input().split()]
cnt4 = 0
cnt2 = 0
for x in a:
    if x % 4 == 0:
        cnt4 += 1
        continue
    if x % 2 == 0:
        cnt2 += 1
cnt2 = cnt2//2*2
if N-cnt2 > 2*cnt4:
    print('No')
else:
    print('Yes')
# Judge status: Accepted
x, n = map(int, input().split())
banned = set()
if n:
    banned |= set(map(int, input().split()))
l = x
r = x
while l in banned and r in banned:
    l -= 1
    r += 1

if l not in banned:
    print(l)
elif r not in banned:
    print(r)
# Judge status: Accepted
s = input()
n = len(s)
ans = ""
for i in range(n):
  if s[i] == "?":
    ans += "D"
  else:
    ans += s[i]
print(ans)
# Judge status: Wrong Answer
S=str(input())
if 'a'.count == 1 and 'b'.count == 1 and 'c'.count == 1:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
def main():
    n = int(input())

    ans = 0
    for i in range(1, n + 1):
        k = n // i
        ans += i * k * (k + 1) // 2

    print(ans)


if __name__ == '__main__':
    main()
# Judge status: Accepted
n = int(input())
s = input()
ans = 0
for i in range(1,n):
    p = s[:i]
    q = s[i:]
    
    res = 0
    for i in range(26):
        c = chr(i+ord('a'))
        if c in p and c in q:res += 1
    ans = max(res,ans)
print(ans)
# Judge status: Accepted
#Macで実行する時
import sys
import os
if sys.platform=="darwin":
	base = os.path.dirname(os.path.abspath(__file__))
	name = os.path.normpath(os.path.join(base, '../atcoder/input.txt'))
	#print(name)
	sys.stdin = open(name)

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

c = int(a/b)

if a%b!=0:
    c+=1

print(c)
# Judge status: Accepted
S=list(input());c=i=0
while i<len(S):c+=1*(S[i]!=S[-i-1]);i+=1
print(c//2)
# Judge status: Wrong Answer
x = int(input())
q, mod = divmod(x, 11)
ans = q*2+1 if mod <= 6 else q*2+2
print(ans)
# Judge status: Accepted
n=int(input())
list=list(map(int,input().split()))
ans=set()
temp=0
for i in list:
    if i>=3200:temp+=1
    else:ans.add(i//400)
print(max(1,len(ans)),len(ans)+temp)
# Judge status: Accepted
s=input()

st=[[]]
cnt=0
left=0
for i in range(1,len(s)+1):
    if s[left:i] == st[-1]:
        continue
    else:
        st.append(s[left:i])
        left=i
        cnt+=1
print(cnt)
# Judge status: Accepted
N = int(input())
a = int(N/2)

if N % 2 ==0:
  print(a**2)
else:
  print(a*(a+1))
# Judge status: Accepted
import sys
from collections import defaultdict
from heapq import heappop, heappush
N, M = map(int, sys.stdin.readline().split())
A = defaultdict(list)
for line in sys.stdin:
    a, b = map(int, line.split())
    if a <= M:
    	A[M-a].append(b)

ans = 0
q = []
for i, B in sorted(A.items()):
    for b in B:
        heappush(q, b)
        ans += b
    while len(q) > i+1:
        b = heappop(q)
        ans -= b
print(ans)
# Judge status: Accepted
mod = 10**9+7
n = int(input())
s = input()
d = {}
for i in s:
    if i in d:
        d[i] += 1
    else:
        d[i] = 1
result = 1
for i, j in d.items():
    result = (result*(j+1))%mod

print((result-1)%mod)
# 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()

men=min(A*B,B*C,C*A)
print(men)
# Judge status: Accepted
import sys
readline = sys.stdin.readline

N,M = map(int,readline().split())
B = [1] * N
possible = {0}
for i in range(M):
  x,y = map(int,readline().split())
  x,y = x - 1,y - 1
  B[x] -= 1
  B[y] += 1
  if x in possible:
    possible.add(y)
  if x in possible and B[x] == 0:
    possible.remove(x)

print(len(possible))
# Judge status: Wrong Answer
s=input()
t=input()
if s==t:
    print("Yes")

else:
    flag=True
    for i in range(1,len(s)-1):
        if s[0:i]==t[len(t)-i:len(t)] and s[i:len(s)]==t[0:len(t)-i]:
            print("Yes")
            flag=False
            exit()

    if flag:
        print("No")
# Judge status: Accepted
a = {
    "Sunny": "Cloudy", 
    "Cloudy": "Rainy",
    "Rainy": "Sunny"
}
s = input()
print(a[s])
# Judge status: Wrong Answer
S = list(input())
ans = 'AC'
if not S[0] == 'A':
    ans = 'WA'
if not 'C' in (S[2:-2]):
    ans = 'WA'
if ans == 'AC':
    S.remove('A')
    S.remove('C')
    if not S == [s.lower() for s in S]:
        ans = ('WA')
print(ans)
# Judge status: Wrong Answer
n=input().split()
A=int(n[0])
B=int(n[1])
C=int(n[2])

if B>=A*C:
    print(A*C)
else:
    print(int(B/A))
# Judge status: Accepted
s = input()
check = 'keyence'

if s[0] != 'k' and s[-1] != 'e':
    print('NO')
else:
    if s[:7] == check or s[-7:] == check:
        print('YES')
        exit()
    else:
        for i in range(1, 7):
            if s[:i] + s[-(7 - i):] == check:
                print('YES')
                exit()
                # print(s[:i], s[-(7 - i):])
    print('NO')
# Judge status: Accepted
# coding: utf-8

n = int(input().rstrip())

guzai = list(sorted(map(int, input().rstrip().split(" "))))

ans = guzai[0]

for i in range(1, n):
    ans = (ans + guzai[i]) / 2

print(ans)
# Judge status: Accepted
n = int(input())
s = input()
l=0
r=0
for i in s:
    if i ==')' and l==0:
        r+=1
    elif i==')':
        l-=1
    elif i=='(':
        l+=1
s1 = '('*r
s2 = ')'*l
s=s1+s+s2
print(s)