Harryxun/stf_run huggingface dataset:
n = int(input())
a = list(map(int,input().split()))
a.sort()
mx = a[-1]
c = [0 for _ in range(mx+1)]
ans = 0
if a[0] == 1:
  if a[1] == 1:
    print(0)
    exit()
  else:
    print(n)
    exit()
i = 0
while i < n:
  if c[a[i]] == 0:
    p = a[i]
    for _ in range(2,mx//a[i]+1):
      p += a[i]
      c[p] = 1
    flag = True
    while i+1 < n and a[i+1] == a[i]:
      i += 1
      flag = False
    if flag:
      ans += 1
  i += 1
print(ans)
      
   
      


### FIXED CODE ###

n = int(input())
a = list(map(int,input().split()))
a.sort()
mx = a[-1]
c = [0 for _ in range(mx+1)]
ans = 0
if a[0] == 1:
  if n == 1:
    print(1)
    exit()
  if a[1] == 1:
    print(0)
    exit()
  else:
    print(1)
    exit()
i = 0
while i < n:
  if c[a[i]] == 0:
    p = a[i]
    for _ in range(2,mx//a[i]+1):
      p += a[i]
      c[p] = 1
    flag = True
    while i+1 < n and a[i+1] == a[i]:
      i += 1
      flag = False
    if flag:
      ans += 1
  i += 1
print(ans)
a=str(input())
if a[0] or a[1] or a[2]==7:
    
    print("Yes")
elif :
    print("No")

### FIXED CODE ###

a=str(input())
if a[0] =='7' or a[1] =='7' or a[2]=='7':
    print("Yes")
else:
    print("No")
N = int(input())
nodes = [[[], -1] for _ in range(N + 1)]

for i in range(N - 1):
    u, v, w = [int(_) for _ in input().split()]
    nodes[u - 1][0].append((v - 1, w))
    nodes[v - 1][0].append((u - 1, w))


def f(i, c):
    if nodes[i][1] >= 0: return
    nodes[i][1] = c
    for n in nodes[i][0]:
        f(n[0], (c + (n[1] % 2)) % 2)

# print(nodes)
f(0,0)
for i in range(N):
    print(nodes[i][1])


### FIXED CODE ###

import sys
sys.setrecursionlimit(10**6)

N = int(input())
nodes = [[[], -1] for _ in range(N + 1)]

for i in range(N - 1):
    u, v, w = [int(_) for _ in input().split()]
    nodes[u - 1][0].append((v - 1, w))
    nodes[v - 1][0].append((u - 1, w))


def f(i, c):
    if nodes[i][1] >= 0: return
    nodes[i][1] = c
    for n in nodes[i][0]:
        f(n[0], (c + (n[1] % 2)) % 2)

# print(nodes)
f(0, 0)
for i in range(N):
    print(nodes[i][1])
N, M = map(int, input().split())
A = list(map(int, input().split()))

A.sort(reverse=True)
if A[M] < 1/(4*M):
  print('Yes')
else:
  print('No')


### FIXED CODE ###

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

A.sort(reverse=True)
if A[M - 1] >= sum(A)/(4*M):
  print('Yes')
else:
  print('No')
p=input()

a="p"

b=a%10
c=a%100
d=a%1000
e=a%10000


if a%10==0:
print(5)
elif (a-b)%100==0:
print(4)
elif (a-c)%1000==0:
print(3)
elif (a-d)%10000==0:
print(2)
else:
print(1)

### FIXED CODE ###

import math
from collections import deque
from collections import defaultdict
import itertools as it
 
#自作関数群
def readInt():
 return int(input())
def readInts():
 return list(map(int, input().split()))
def readChar():
 return input()
def readChars():
 return input().split()
def factorization(n):
 res = []
 if n%2==0:
  res.append(2)
 for i in range(3,math.floor(n//2)+1,2):
  if n%i==0:
   c = 0
   for j in res:
    if i%j==0:
     c=1
   if c==0:
    res.append(i)
 return res
def fact2(n):
 p = factorization(n)
 res = []
 for i in p:
  c=0
  z=n
  while 1:
   if z%i==0:
    c+=1
    z/=i
   else:
    break
  res.append([i,c])
 return res
def fact(n):#階乗
 ans = 1
 m=n
 for _i in range(n-1):
  ans*=m
  m-=1
 return ans
def comb(n,r):#コンビネーション
 if n<r:
  return 0
 l = min(r,n-r)
 m=n
 u=1
 for _i in range(l):
  u*=m
  m-=1
 return u//fact(l)
def combmod(n,r,mod):
 return (fact(n)/fact(n-r)*pow(fact(r),mod-2,mod))%mod
def printQueue(q):
 r=copyQueue(q)
 ans=[0]*r.qsize()
 for i in range(r.qsize()-1,-1,-1):
  ans[i] = r.get()
 print(ans)
class UnionFind():
 def __init__(self, n):
  self.n = n
  self.parents = [-1]*n
 
 def find(self, x): # root
  if self.parents[x]<0:
   return x
  else:
   self.parents[x] = self.find(self.parents[x])
   return self.parents[x]
 
 def union(self,x,y):
  x = self.find(x)
  y = self.find(y)
 
  if x==y:
   return
 
  if self.parents[x]>self.parents[y]:
   x,y = y,x
 
  self.parents[x]+=self.parents[y]
  self.parents[y]=x
 
 def size(self,x):
  return -1*self.parents[self.find(x)]
 
 def same(self,x,y):
  return self.find(x)==self.find(y)
 
 def members(self,x): # much time
  root = self.find(x)
  return [i for i in range(self.n) if self.find(i)==root]
 
 def roots(self):
  return [i for i,x in enumerate(self.parents) if x<0]
 
 def group_count(self):
  return len(self.roots())
 
 def all_group_members(self):
  return {r: self.members(r) for r in self.roots()} # 1~n
def bitArr(n):#ビット全探索
 x = 1
 zero = "0"*n
 ans = []
 ans.append([0]*n)
 for i in range(2**n-1):
  ans.append(list(map(lambda x:int(x),list((zero+bin(x)[2:])[-1*n:]))))
  x+=1
 return ans;
def arrsSum(a1,a2):
 for i in range(len(a1)):
  a1[i]+=a2[i]
 return a1
def maxValue(a,b,v):
 v2 = v
 for i in range(v2,-1,-1):
  for j in range(v2//a+1): #j:aの個数
   k = i-a*j
   if k%b==0:
    return i
 return -1
def copyQueue(q):
 nq = queue.Queue()
 n = q.qsize()
 for i in range(n):
  x = q.get()
  q.put(x)
  nq.put(x)
 return nq
def get_sieve_of_eratosthenes(n):
 #data = [2]
 data = [0,0,0]
 for i in range(3,n+1,2):
  data.append(i)
  data.append(0)
 for i in range(len(data)):
  interval = data[i]
  if interval!=0:
   for j in range(i+interval,n-1,interval):
    data[j] = 0
 #ans = [x for x in data if x!=0]
 ans = data[:]
 return ans
 
x = readInts()
 
for i in range(1,6):
 if x[i-1]!=i:
  print(i)
S = int(input.())

h = (S =/ 60 * 60)
m = (S =/ 60)
s = S

print(h + ':' + m + ':' + s)

### FIXED CODE ###

S = int(input())

h = S // 3600
m = S // 60 % 60
s = S % 60

print('{0}:{1}:{2}'.format(h, m, s))
s1=int(input())
s2=int(input())
s3=int(input())

S=[s1,s2,s3]
S.count(1)

### FIXED CODE ###

s = input()
count = 0 
if s[0] == '1':
    count += 1
if s[1] == '1':
    count += 1
if s[2] == '1':
    count += 1
print(count)
a = input(int()).split()
sort_a = sorted(a)
ans = sort_a[-1]-sort_a[0]

### FIXED CODE ###

a = list(map(int, input().split()))
a.sort()
ans = a[-1]-a[0]
print(ans)
def f(x,y,z):
    n=x**2 + y**2 + z**2 + x*y + y*z + z*x
    return n

N=int(input())

if N>=9000:
  print(aaa)

anslist=[0]*60100

for x in range(1,100):
    for y in range(1,100):
        for z in range(1,100):
            n= f(x,y,z)
            anslist[n-1]+=1

for i in range(N):
    print(anslist[i])


### FIXED CODE ###

def f(a,b,c):
    n=(a+b+c)**2 -a*b -b*c -c*a
    return n

N=int(input())

anslist=[0]*1000005

for x in range(1,100):
    for y in range(1,100):
        for z in range(1,100):
            n= f(x,y,z)
            anslist[n-1]+=1

for i in range(N):
    print(anslist[i])
import math
import numpy as np

N, K = map(int,input().split())
P = list(map(int,input().split()))
C = list(map(int,input().split()))
for i in range(len(P)): #Pの中身は次の動く先の位置なのでデクリメントする
    P[i] -= 1

ans = -99999999999999

for i in range(N):
    x = i
    total = 0
    s=[]
    while(1):#サイクルごとに長さをまず求める，
        x = P[x]
        s.append(C[x])
        total += C[x]
        if x == i:
            break
    l = len(s)#サイクルの長さ
    t = 0
    for i in range(l):#サイクルの中でどこで終わるのがベストか探す
        t += s[i]
        if i+1> K:#Kがサイクルより短かったらそこで終わる
            break
        now = t
        if total > 0:
            cycle = int((K-i-1)/l)
            now += total*cycle

        ans = max(ans, now)

print(ans)


### FIXED CODE ###

#import math
#import numpy as np

N, K = map(int,input().split())
P = list(map(int,input().split()))
C = list(map(int,input().split()))
#for i in range(len(P)): #Pの中身は次の動く先の位置なのでデクリメントする
#    P[i] -= 1

ans = -99999999999999

for i in range(N):
    x = i
    total = 0
    s=[]
    while(1):#サイクルごとに長さをまず求める，
        x = P[x]-1
        s.append(C[x])
        total += C[x]
        if x == i:
            break
    l = len(s)#サイクルの長さ
    t = 0
    for i in range(l):#サイクルの中でどこで終わるのがベストか探す
        t += s[i]
        if i+1> K:#Kがサイクルより短かったらそこで終わる
            break
        now = t
        if total > 0:
            cycle = int((K-i-1)/l)
            now += total*cycle

        ans = max(ans, now)

print(ans)
import sys
readline = sys.stdin.readline
from collections import Counter 

def calc(A):
    s = sum(A)
    ma = max(A)
    if 2*ma > s:
        return s - ma
    return s//2

def check():
    candi = [[] for _ in range(N)]
    for l in L[:0:-1]:
        p = P[l]
        if candi[l]:
            x = sum(candi[l]) - candi[l]
            y = A[l] - x
            if 0 <= y <= calc(candi[l]):
                return 'NO'
        else:
            x = 0
            y = A[l]
    x = sum(candi[0]) - candi[0]
    y = A[0] - x
    if candi[0]:
        if not 0 <= sum(candi[0]) - A[0] <= calc(candi[0]):
                return 'NO'
    if y:
        return 'NO'
    return 'YES'

def parorder(Edge, p):
    N = len(Edge)
    par = [0]*N
    par[p] = -1
    stack = [p]
    order = []
    visited = set([p])
    ast = stack.append
    apo = order.append
    while stack:
        vn = stack.pop()
        apo(vn)
        for vf in Edge[vn]:
            if vf in visited:
                continue
            visited.add(vf)
            par[vf] = vn
            ast(vf)
    return par, order

def getcld(p):
    res = [[] for _ in range(len(p))]
    for i, v in enumerate(p[1:], 1):
        res[v].append(i)
    return res


N = int(readline())
A = list(map(int, readline().split()))
Edge = [[] for _ in range(N)]
for _ in range(N-1):
    a, b = map(int, readline().split())
    a -= 1
    b -= 1
    Edge[a].append(b)
    Edge[b].append(a)

P, L = parorder(Edge, 0)
C = getcld(P)
print(check())

### FIXED CODE ###

import sys
readline = sys.stdin.readline
from collections import Counter 

def calc(A):
    s = sum(A)
    ma = max(A)
    if 2*ma > s:
        return s - ma
    return s//2

def check():
    candi = [[] for _ in range(N)]
    for l in L[:0:-1]:
        p = P[l]
        if candi[l]:
            x = sum(candi[l]) - A[l]
            y = A[l] - x
            if not 0 <= x <= calc(candi[l]):
                return 'NO'
        else:
            x = 0
            y = A[l]
        candi[p].append(y)
    x = sum(candi[root]) - A[root]
    y = A[root] - x
    if candi[root]:
        if not 0 <= x <= calc(candi[root]):
            return 'NO'
    if y:
        return 'NO'         
    return 'YES'

def parorder(Edge, p):
    N = len(Edge)
    par = [0]*N
    par[p] = -1
    stack = [p]
    order = []
    visited = set([p])
    ast = stack.append
    apo = order.append
    while stack:
        vn = stack.pop()
        apo(vn)
        for vf in Edge[vn]:
            if vf in visited:
                continue
            visited.add(vf)
            par[vf] = vn
            ast(vf)
    return par, order

def getcld(p):
    res = [[] for _ in range(len(p))]
    for i, v in enumerate(p[1:], 1):
        res[v].append(i)
    return res


N = int(readline())
A = list(map(int, readline().split()))
Edge = [[] for _ in range(N)]
Dim = [0]*N
for _ in range(N-1):
    a, b = map(int, readline().split())
    a -= 1
    b -= 1
    Edge[a].append(b)
    Edge[b].append(a)
    Dim[a] += 1
    Dim[b] += 1

if N == 2:
    ans = 'YES' if A[0] == A[1] else 'NO'
else:
    root = Dim.index(max(Dim))
    P, L = parorder(Edge, root)
    C = getcld(P)
    ans = check()

print(ans)
N = int(input())
H = [int(i) for i in  input().split()]
length = len(H)
h = [0]*length
def z_counter(start):
  cnt = 0
  for i in range(start+1, length):
    if H[i] <= H[i-1]:
      cnt += 1
    else:
      break
  return cnt
for i in range(1, length):
  h[i] = z_counter(i)
  ans = max(h)

print(ans)

### FIXED CODE ###

N=int(input())
H=list(map(int,input().split()))
h=[0]*N
count=0
for i in range(1,N):
    if H[i-1]>=H[i]:
        count+=1
    else:
        count=0
    h[i]=count
print(max(h))
global MOD,facts,inv
MOD = 998244353

def nCr(n,r):
    return ((facts[n] * inv[r]) % MOD) * (inv[n-r] % MOD)

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

facts = [0]*(N+10)
facts[0] = facts[1] = 1
for i in range(2,N+1):
    facts[i] = (facts[i-1] * i) % MOD
inv = [0]*(N+10)
inv[N] = pow(facts[N],MOD-2,MOD)
for i in range(N,0,-1):
    inv[i-1] = (inv[i] * i) % MOD

ans = 0
for i in range(N+1):
    bal = K - (i * A)
    m,f = bal % B,bal // B
    if m == 0 and f + i <= 2*N:
        ans = (ans + (nCr(N,i) * nCr(N,f))) % MOD
        
print(ans)

### FIXED CODE ###

global MOD,facts,inv
MOD = 998244353

def nCr(n,r):
    global facts,inv
    return (facts[n] * inv[r]) % MOD * inv[n-r] % MOD

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

facts = [0]*(N+10)
facts[0] = facts[1] = 1
for i in range(2,N+1):
    facts[i] = (facts[i-1] * i) % MOD
inv = [0]*(N+10)
inv[N] = pow(facts[N],MOD-2,MOD)
for i in range(N,0,-1):
    inv[i-1] = (inv[i] * i) % MOD

ans = 0
for i in range(N+1):
    bal = K - (i * A)
    m,f = bal % B,bal // B
    if m == 0 and f <= N and f >= 0:
        ans = (ans + (nCr(N,i) * nCr(N,f))) % MOD
        
print(ans)
#239423 29392 39299 394239932
x,a=map(int,input()split())
if	x<a
	l=0
if x>=a
	l=10
print (l)   

### FIXED CODE ###

x, a=map(int, input().split())
if	x < a:
	l = 0
else:
	l = 10
print(l)
n = input()
m = n.split()
for i in range(0, len(m)):
    m[i] = int(m[i])
a = m[0]
b = m[1]
m = m[2:]

p = 0
for i in range(a-b,a):
    p = p + int(c[i])
print(int(p))

### FIXED CODE ###

n = input()
m = n.split()
a = [input() for l in range(0,1)]
b = a[0].split()
for i in range(0, len(b)):
    b[i] = int(b[i])
c = sorted(b, reverse=True)
p = 0
for i in range(int(m[0]) - int(m[1]),int(m[0])):
    p = p + int(c[i])
print(p)
n=int(input())
x=input()
chk0=chk1=chk2=0
b=x.count("1")
if b==1 and x=="1":
    print(0)
    exit()
elif b==1 and x[-1]=="1":
    for i in range(n-1):
        print(2//0)
    print(0)
    exit()
elif b==1:
    for i in range(n):
        if i=="0": print(1//0)
        else: print(0//0)
    exit()
for i,j in enumerate(x[::-1]):
    if j=="1":
        chk1+=pow(2,i,b+1)
        if b>1: chk2+=pow(2,i,b-1)
        else: chk2=0
l=[]
for i,j in enumerate(x[::-1]):
    if b: a1=pow(2,i,b+1)
    else: a1=1
    if b>1: a2=pow(2,i,b-1)
    else: a2=1
    if j=="0":
        t=chk1+a1
    else:
        if b>1: t=chk2+b-1-a2
        else: t=0
    ans,f=0,1
    while t:
        if f:
            if j=="0": t%=(b+1)
            else: t%=(b-1)
            f=0
        else:
            t%=bin(t).count("1")
        ans+=1
    l.append(ans)
for i in l[::-1]:
    print(i)

### FIXED CODE ###

n=int(input())
x=input()
chk0=chk1=chk2=0
b=x.count("1")
if b==1 and x=="1":
    print(0)
    exit()
elif b==1:
    for i in range(n):
        if i==n-1: print(2)
        elif x[i]=="0": print(1)
        else: print(0)
    exit()
for i,j in enumerate(x[::-1]):
    if j=="1":
        chk1+=pow(2,i,b+1)
        if b>1: chk2+=pow(2,i,b-1)
        else: chk2=0
l=[]
for i,j in enumerate(x[::-1]):
    if b: a1=pow(2,i,b+1)
    else: a1=1
    if b>1: a2=pow(2,i,b-1)
    else: a2=1
    if j=="0":
        t=chk1+a1
    else:
        if b>1: t=chk2+b-1-a2
        else: t=0
    ans,f=0,1
    while t:
        if f:
            if j=="0": t%=(b+1)
            else: t%=(b-1)
            f=0
        else:
            t%=bin(t).count("1")
        ans+=1
    l.append(ans)
for i in l[::-1]:
    print(i)
A,B,K=int(input().split())
listAB=[]
for i in range(min(A,B)):
    if A%(i+1)==0 and B%(i+1)==0:
        listAB.append(i+1)
listAB.sort(reverse=1)
if A==1 and B==1:
    print(1)
else :
    print(listAB[K-1])

### FIXED CODE ###

A,B,K=map(int,input().split())
listAB=[]
for i in range(min(A,B)):
    if A%(i+1)==0 and B%(i+1)==0:
        listAB.append(i+1)
listAB.sort(reverse=1)
if A==1 and B==1:
    print(1)
else :
    print(listAB[K-1])
width, height, x, y = map(float,　input().split())

center_x = width/2
center_y = height/2

label = 0
if x === center_x && y === center_y:
    s = width * height/2
    label = 1

print(s, label)


### FIXED CODE ###

width, height, x, y = map(float,input().split())

center_x = width/2
center_y = height/2

s = width * height/2
label = 0
if x == center_x and y == center_y:
    label = 1

print(s, label)
A,B,C = map(int,input().split())
if C-A+B>0:
    print(C=A+B)
else:
    print(0)


### FIXED CODE ###

A,B,C = map(int,input().split())
if C-A+B>0:
    print(C-A+B)
else:
    print(0)
N = input()
sum_digit = 0
for i in range(len(N)):
  sum_digit += int(N[i])
if N%sum_digit == 0:
  print('Yes')
else:
  print('No')


### FIXED CODE ###

N = input()
sum_digit = 0
for i in range(len(N)):
  sum_digit += int(N[i])
if int(N)%sum_digit == 0:
  print('Yes')
else:
  print('No')
from itertools import accumulate
import numpy as np
N, K = list(map(int, input().split()))
A = np.array(list(map(int, input().split())))
A = (A+1)/2

B = np.insert(A,0,0)
B = list(accumulate(B))
answer = []
for i in range(N-K):
    answer.append(B[i+K]-B[i])

print(max(answer))

### FIXED CODE ###

from itertools import accumulate
import numpy as np
N, K = list(map(int, input().split()))
A = np.array(list(map(int, input().split())))
A = (A+1)/2

B = np.insert(A,0,0)
B = list(accumulate(B))
answer = []
for i in range(N-K+1):
    answer.append(B[i+K]-B[i])

print(max(answer))
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,M = I()
keta = [-1]*(N)
for i in range(M):
    s,c = I()
    if keta[s-1] == -1 or keta[s-1] == c:
        keta[s-1] = c
    else:
        print(-1)
        exit()
if len(keta) == 1 and keta[0] == 0:
    print(0)
    exit()
if keta[i] == -1:
    keta[i] = 1
for i in range(N):
    if keta[i] == -1:
        keta[i] = '0'
    else:
        keta[i] = str(keta[i])
if ''.join(keta) != str(int(''.join(keta))):
    print(-1)
else:
    print(''.join(keta))

### FIXED CODE ###

N,M = list(map(int,input().split()))
A = ['a']*N
for i in range(M):
  s,c = list(map(int,input().split()))
  if A[s-1] != 'a' and A[s-1] != str(c):
    print('-1')
    exit()
  else:
    A[s-1] = str(c)
if A[0] == '0' and len(A) != 1:
  print('-1')
  exit()
elif A[0] == 'a' and len(A) != 1:
  A[0] = '1'
for i in range(N):
      if A[i] == 'a':
        A[i] = '0'
print(''.join(A))
import math
n=int(input())
SN = 0
for i in range(1,math.ceil(math.log(n,10))+1):
#  print(math.floor(n%(10**i)/(10**(i-1))))
  SN = SN + math.floor(n%(10**i)/(10**(i-1)))
if n%SN==0:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

S=str(input())
total = 0
for i in range(len(S)):
  total = total + int(S[i])
if int(S)%total==0:
  print('Yes')
else:
  print('No')
w,h,x,y = map(int, input().split())
ans_1 = w*h/2
ans_2 = 0
if (x==w/2) and (h == y/2):
    ans_2 = 1
print(" ".join([ans_1,ans_2]))

### FIXED CODE ###

w,h,x,y = map(int, input().split())
ans_1 = w*h/2
ans_2 = 0
if (x==(w/2)) and (y == (h/2)):
    ans_2 = 1
print(" ".join(map(str, [ans_1,ans_2])))
n = input()

for i in (len(n) - 1):
    if n[i] == h and n[i+1] ==i:
        print("Yes")
    else:
        print("No")

### FIXED CODE ###

S = str(input())
 
S1 = S.replace("hi", "")
if S1 == "":
  print("Yes")
else:
  print("No")
k=int(input())
a,b=int(input().split())

if b-a>=k-1:
  print('OK')
else:
  print('NG')

### FIXED CODE ###

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

i=0

while True:
  if (a+i)%k==0:
    print('OK')
    break
  
  if  a+i==b:
    print('NG')
    break
  
  i+=1
import sys
N, M, *PS = sys.stdin.read().strip().split()
N = int(N)
ac = [0] * N
wa = [0] * N
for p, s in zip(*[iter(PS)] * 2):
  p = int(p) - 1
  if s == "AC":
    ac[p] = 1
  elif ac[p] == 0:
    wa[p] += 1
penalties = sum(w * a else 0 for a, w in zip(ac, wa))
print(sum(ac), penalties)

### FIXED CODE ###

N, M = map(int, input().split())
PS = [list(map(str, input().split())) for _ in range(M)]
ac = [False] * N # index means p
wa = [0] * N # index means p
wa_cnt = 0
for ps in PS:
  p = int(ps[0]) - 1 # index starts from 0
  s = ps[1]
  if not ac[p] and s == "AC":
    wa_cnt += wa[p]
    ac[p] = True
  elif s == "WA":
    wa[p] += 1
print(ac.count(True), wa_cnt)
n, m = map(int, input().split())
sc = [list(map(int, input().split())) for _ in range(m)]

for i in range(1000):
    ans = str(i)
    for s, c in sc:
        print(s, c, ans)
        if int(ans[s-1]) != c:
            break
    else:
        print(ans)
        exit()

print(-1)

### FIXED CODE ###

n, m = map(int, input().split())
sc = [list(map(int, input().split())) for _ in range(m)]

for i in range(1000):
    ans = str(i)
    if len(ans) != n:
        continue
    for s, c in sc:
        if int(ans[s-1]) != c:
            break
    else:
        print(ans)
        exit()

print(-1)
def sequence(i):
  return 26 * (pow(26, i) - 1) // 25

n = int(input())
group = 1
while(n > sequence(group)):
  group += 1
  
at = n - sequence(group - 1)

name = ''
alph = 'abcdefghijklmnopqrstuvwxyz'

for i in range(group):
    base = n // pow(26, group - 1 - i)
    name += alph[base-1]
    n -= base * pow(26, group - 1 -i)

print(name)


### FIXED CODE ###

alph = 'abcdefghijklmnopqrstuvwxyz'
def acc_seq(i):
  return 26 * (pow(26, i) - 1) // 25

def name_dog(digit, at, name):
  if digit ==1:
    return name + alph[at]
  else:
    group = at // pow(26, digit - 1)
    at -= pow(26, digit - 1) * group
    name += alph[group]
    return name_dog(digit-1, at, name)

n = int(input())
digit = 1
while(n > acc_seq(digit)):
  digit += 1

at = abs(n - acc_seq(digit - 1) - 1)
print(name_dog(digit, at, ''))
N, M =map(int, input())
if('Yes' if N==M else 'No')

### FIXED CODE ###

N, M =map(int, input().split())
print('Yes' if N==M else 'No')
print(["No","Yes"][((int(input())-int(input())))%500==0]

### FIXED CODE ###

n = int(input())
a = int(input())
n = (n % 500)
print(["No", "Yes"][n <= a])
N = float(input())

q = N
r_s = []
while q!=1:
  hoge = (q-1) / (-2)
  if hoge.is_integer():
    r = int(1)
    q = float(hoge)
  else:
    r = int(0)
    q = float(q/(-2))
  
  r_s.append(r)
r_s.append(1)
r_s = r_s[::-1]

for i in range(len(r_s)):
  print(r_s[i], end="")

### FIXED CODE ###

N, K = map(int, input().split())
r = N % K
if r == 0:
  print(0)
else:
  print(1)
N,M = map(int,input().split())
L_list = []
R_list = []
for o in range(M):
    L,R = map(int,input().split())
    L_list.append(L)
    R_list.append(R)

count = list(range(L_list[0],R_list[0]+1))
for i in range(1,M):
    count = list(count)
    if L_list[i] > count[0]:
        sta = L_list[i]
    else:
        sta = count[0]
    if R_list[i] > count[-1]:
        fin = count[-1]
    else:
        fin = R_list[i]
    count = set(count) & set(range(sta,fin+1))

ans = len(count)
print(ans)

### FIXED CODE ###

N,M = map(int,input().split())
L_list = []
R_list = []
for o in range(M):
    L,R = map(int,input().split())
    L_list.append(L)
    R_list.append(R)
L_max = max(L_list)
R_min = min(R_list)
    
if L_max <= R_min:
    ans = R_min - L_max + 1
else:
    ans = 0
print(ans)
C = []
for i in range(3):
    C.append(list(map(int, input().split())))
if ((C[0][0]-C[1][0])==(C[0][1]-C[1][1])==(C[0][2]-C[1][2]) and\
 (C[1][0]-C[2][0])==(C[1][1]-C[2][1])==(C[1][2]-C[2][2]) and\
 (C[2][0]-C[0][0])==(C[2][1]-C[0][1])==(C[2][2]-C[0][2]) and\
 (C[0][0]-C[0][1])==(C[1][0]-C[1][1])==(C[2][0]-C[2][1]) and\
 (C[0][1]-C[0][2])==(C[1][1]-C[1][2])==(C[2][1]-C[2][2]) and\
 (C[0][2]-C[0][0])==(C[1][2]-C[1][0])==(C[2][2]-C[2][0])):
    print('Yes')
else:
    print('No')


### FIXED CODE ###

N = int(input())
A = int(input())
if N%500 <= A:
    print('Yes')
else:
    print('No')
N, X = map(int, input().split())
l =list(map(int, input().split()))

d=[0]
for v in l:
    d.append(d[-1]+v)

print(len([_ for v in d if v <= X]))

### FIXED CODE ###

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

d=[0]
for v in l:
    d.append(d[-1]+v)

print(len([v for v in d if v <= X]))