CodeEff/ECCO huggingface dataset:
# Original solution
N, K, Q = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(Q)]
P = [K]* N
def calc(n):
    return n - 1

for i in range(Q):
  P = list(map(calc, P))
  P[A[i] - 1] += 1

for p in P:
  if p > 0:
    print("Yes")
  else:
    print("No")

# Optimized solution
N, K, Q = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(Q)]
P = [K - Q]* N

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

for p in P:
  if p > 0:
    print("Yes")
  else:
    print("No")
# Original solution
Input = list(map(int,input().split()))

point =[]
for i in range(Input[0]):
    point.append(Input[1])

for i in range(Input[2]):
    aa = int(eval(input()))-1
    
    for k in range(Input[0]):
        point[k] -= 1
    
    point[aa] += 1
gouhi =[]
for i in range(Input[0]):
    bb = 0
    if point[i] > 0:
        bb = "Yes"
    else:
        bb = "No"
    gouhi.append(bb)
print(("\n".join(gouhi)))

# Optimized solution
Input = list(map(int,input().split()))

point =[]
for i in range(Input[0]):
    point.append(0)

for i in range(Input[2]):
    aa = int(eval(input()))
    point[aa-1] +=1
gouhi =[]
for i in range(Input[0]):
    bb = 0
    if Input[1]-Input[2]+point[i] > 0 :
        bb = "Yes"
    else:
        bb = "No"
    gouhi.append(bb)
print(("\n".join(gouhi)))
# Original solution
N, K, Q = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(Q)]
point = [K] * N
for i in A:
    point[i-1] = point[i-1] + 1
    point=list([x-1 for x in point])
    
for i in range(N):
    if point[i] <= 0:
        print('No')
    else:
        print('Yes')

# Optimized solution
N, K, Q = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(Q)]
point = [K-Q] * N
for i in A:
    point[i-1] = point[i-1] + 1
 
for i in range(N):
    if point[i] <= 0:
        print('No')
    else:
        print('Yes')
# Original solution
from sys import stdin
n,k,q = list(map(int, stdin.readline().split()))
a = [int(stdin.readline()) for _ in range(q)]
points = list([x-q for x in [k for i in range(n)]])
for i in set(a):
    points[i-1] += a.count(i)
for i in points:
  if i <= 0:
    print('No')
  else:
    print('Yes')

# Optimized solution
n,k,q=list(map(int,input().split()))
a=[k-q]*n
for i in range(q):
    point=int(eval(input()))
    a[point-1] += 1
for i in range(len(a)):
    if a[i] > 0:
        print("Yes")
    else:
        print("No")
# Original solution
from collections import deque
n,k,q = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(q)]
start = [k-q]*n
points = deque(start)
for i in set(a):
    points[i-1] += a.count(i)
for _ in range(len(points)):
  x = points.popleft()
  if x <= 0:
    print('No')
  else:
    print('Yes')

# Optimized solution
from collections import deque
n,k,q=list(map(int,input().split()))
a=deque([k-q]*n)
for i in range(q):
    point=int(eval(input()))
    a[point-1] += 1
for _ in range(len(a)):
  if a.popleft() > 0:
      print("Yes")
  else:
      print("No")
# Original solution
N, K, Q = list(map(int, input().split()))

la = list()
for i in range(Q):
    la.append(int(eval(input())))

for i in range(1,N+1):
    if Q-la.count(i) < K:
        print("Yes")
    else:
        print("No")


# Optimized solution
N, K, Q = list(map(int, input().split()))

la = list()
for i in range(Q):
    la.append(int(eval(input())))

lcount = [0] * N
for i in range(Q):
    lcount[la[i]-1] += 1

for i in range(N):
    if K+lcount[i]-Q > 0:
        print("Yes")
    else:
        print("No")
# Original solution
n,k,q = list(map(int,input().split()))
point = [k for i in range(n)]

for _ in range(q):
  ans = int(eval(input()))
  for i in range(n):
    if ans - 1 != i:
      point[i]-=1

for i in range(n):
  if point[i] > 0:
    print("Yes")
  else:
    print("No")

# Optimized solution
n,k,q = list(map(int,input().split()))
point = [0 for i in range(n)]

for _ in range(q):
  ans = int(eval(input()))
  point[ans-1] += 1
  
for i in range(n):
  if k + point[i] - q > 0:
    print("Yes")
  else:
    print("No")
# Original solution
n,k,q=list(map(int,input().split()))
a=[int(eval(input()))for _ in range(q)]

w=k-q

for i in range(n):
  if a.count(i+1)+w>0:
    print("Yes")
  else:
    print("No")

# Optimized solution
n,k,q=list(map(int,input().split()))
a=[int(eval(input()))for _ in range(q)]

w=k-q
e=abs(w)
b=[w]*n

if w>0:
  for _ in range(n):
    print("Yes")
  exit()

for i in a:
  b[i-1]+=1

for j in range(n):
  if b[j]>0:
    print("Yes")
  else:
    print("No")
# Original solution
N,K,Q = list(map(int,input().split()))
a = [K]*N

for i in range(Q):
    a=list([x-1 for x in a])
    a[int(eval(input()))-1]+=1
for i in range(N):
    if a[i]>0:
        print('Yes')
    else:
        print('No')

# Optimized solution
N,K,Q = list(map(int,input().split()))
a = [K]*N

for i in range(Q):
    a[int(eval(input()))-1]+=1
a=list([x-Q for x in a])
for i in range(N):
    if a[i]>0:
        print('Yes')
    else:
        print('No')
# Original solution
from collections import Counter

N, K, Q = list(map(int, input().split()))
ctr = Counter(int(eval(input())) for _ in range(Q))

for i in range(1, N + 1):
    if K - Q + ctr[i] > 0:
        print("Yes")
    else:
        print("No")


# Optimized solution

N, K, Q = list(map(int, input().split()))
X = [int(eval(input())) for _ in range(Q)]

cnt = [0] * N
for q in X:
    cnt[q - 1] += 1

for i in range(N):
    if Q - cnt[i] >= K:
        print("No")
    else:
        print("Yes")
# Original solution
n, k, q = list(map(int,input().split()))
b = list()
for i in range(q):
    a = int(eval(input()))
    b.append(a)
for j in range(1,n+1):
    c = b.count(j)
    if c < q-k+1:
        print('No')
    else:
        print('Yes')

# Optimized solution
n, k, q = list(map(int,input().split()))
a = []
for i in range(q):
    b = int(eval(input()))
    a.append(b)
pnt = [0] * n
for x in a:
    pnt[x-1] += 1
for j in range(n):
    if pnt[j] > q-k:
        print('Yes')
    else:
        print('No')
# Original solution
def resolve():
    n,k,q=list(map(int, input().split()))
    a=k-q
    l=[int(eval(input())) for i in range(q)]
    for i in range(1,n+1):
        if a+l.count(i)>0:
            print('Yes')
        else:
            print('No')
resolve()

# Optimized solution
def resolve():
    n,k,q=list(map(int, input().split()))
    l=[int(eval(input())) for i in range(q)]
    a=[k-q for i in range(n)]
    for i in l:
        a[i-1]+=1
    for i in range(n):
        if a[i]<=0:
            print('No')
        else:
            print('Yes')
resolve()
# Original solution
n,k,q=list(map(int,input().split()))
l=[k for i in range(n)]
for i in range(q):
    l[int(eval(input()))-1]+=1
for i in range(n):
    print(('Yes' if l[i]-q>0 else 'No'))

# Optimized solution
n,k,q=list(map(int,input().split()))
l=[0 for i in range(n)]
for i in range(q):
    l[int(eval(input()))-1]+=1
print(('\n'.join('Yes' if l[i]-q+k>0 else 'No' for i in range(n))))
# Original solution
import sys
input = sys.stdin.readline
n,k,q = list(map(int,input().split()))
a = [int(eval(input())) for i in range(q)]
for j in range(1,n+1):
  print(('Yes' if (k + a.count(j) - q)>0 else 'No'))


# Optimized solution
import sys
input = sys.stdin.readline
n,k,q = list(map(int,input().split()))
a = [int(eval(input())) for i in range(q)]
ip = [k-q]*(n+1)
for j in a:
  ip[j] += 1
ans = '\n'.join('Yes' if p > 0 else 'No' for p in ip[1:])
print(ans)
# Original solution
def main():
    N, K, Q = list(map(int, input().split()))
    
    lst_miss = [Q] * N
    for _ in range(Q):
        A = int(eval(input()))
        lst_miss[A - 1] -= 1
    
    for miss in lst_miss:
        ans = "Yes" if miss < K else "No"
        print(ans)


if __name__ == "__main__":
    main()

# Optimized solution
def main():
    N, K, Q = list(map(int, input().split()))
    lst_A = [int(eval(input())) for _ in range(Q)]
    lst_miss = [K - Q] * N


    for A in lst_A:
        lst_miss[A - 1] += 1
    
    for miss in lst_miss:
        ans = "Yes" if miss > 0 else "No"
        print(ans)


if __name__ == "__main__":
    main()
# Original solution
n,k,q = list(map(int,input().split()))
a_list = [int(eval(input())) for i in range(q)]

scores = [a_list.count(i+1) for i in range(n)]


for i,score in enumerate(scores):
    if k-q+score > 0:
        print('Yes')
    else:
        print('No')

# Optimized solution
n,k,q = list(map(int,input().split()))

scores = {}
for i in range(n):
    scores[i+1] = k-q
for elem in [int(eval(input())) for i in range(q)]:
    scores[elem] += 1

for k,v in list(scores.items()):
    if v > 0:
        print('Yes')
    else:
        print('No')
# Original solution
N, K, Q = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(Q)]
pt = [K - Q]*(N + 1)

for i in range(Q):
  for n in range(len(pt)):
    if n == A[i]:
      pt[n] += 1

for n in range(1, len(pt)):
  if pt[n] > 0:
    print("Yes")
  else:
    print("No")


# Optimized solution
n,k,q = list(map(int,input().split()))
ans = [0]*n
for i in range(q):
    idx = int(eval(input())) -1
    ans[idx] += 1
for i in ans:
    print(('Yes' if q-k<i else 'No'))
# Original solution
n, k, q = [int(i) for i in input().split()]
a = [int(eval(input())) for i in range(q)]
out = [k] * n
for i in a:
    out = [i-1 for i in out]
    out[i-1] += 1
for i in out:
    print(("Yes" if i > 0 else "No"))

# Optimized solution
n, k, q = [int(i) for i in input().split()]
a = [int(eval(input())) for i in range(q)]
out = [k-q] * n
for i in a:
    out[i-1] += 1
for i in out:
    print(("Yes" if i > 0 else "No"))
# Original solution
n, k, q = input().split()
N = int(n)
K = int(k)
Q = int(q)
Q_list = []
for i in range(Q):
    Q_list.append(int(eval(input())))

for i in range(N):
    p = K - (Q - Q_list.count(i + 1))
    if p <= 0:
        print("No")
    else:
        print("Yes")

# Optimized solution
n, k, q = input().split()
N = int(n)
K = int(k)
Q = int(q)
Q_list = [0] * N
for i in range(Q):
    num = int(eval(input()))
    Q_list[num - 1] += 1

for i in range(N):
    p = K - (Q - Q_list[i])
    if p <= 0:
        print("No")
    else:
        print("Yes")
# Original solution
N,K,Q=list(map(int, input().split()))  #複数数値入力　「A B」みたいなスペース空いた入力のとき
a=[]
for q in range(Q):
    a.append(int(eval(input())))

cnt=0
for n in range(N):
    if K - (Q - a.count(n+1)) > 0:    
        print('Yes')
    else:
        print('No')

# Optimized solution
N,K,Q=input().split()
N=int(N)
K=int(K)
Q=int(Q)

a=[]
for q in range(Q):
    a.append(int(eval(input())))

cnt=[0]*N
for q in range(Q):
    cnt[int(a[q])-1]+=1

for n in range(N):
    if K - (Q - cnt[n]) > 0:    
        print('Yes')
    else:
        print('No')
# Original solution
# ABC141
from collections import Counter


def main():
    N, K, Q, *A = map(int, open(0).read().split())
    C = Counter(A)
    ans = []
    for i in range(1, N + 1):
        x = "Yes" if K - Q + C[i] > 0 else "No"
        ans.append(x)
    print(*ans, sep="\n")


if __name__ == "__main__":
    main()


# Optimized solution
# ABC141
from collections import Counter


def main():
    N, K, Q, *A = list(map(int, open(0).read().split()))
    C = Counter(A)
    ans = []
    for i in range(1, N + 1):
        x = "Yes" if K - Q + C[i] > 0 else "No"
        ans.append(x)
    print(("\n".join(ans)))


if __name__ == "__main__":
    main()
# Original solution
# ABC141
from collections import Counter


def main():
    N, K, Q, *A = list(map(int, open(0).read().split()))
    C = Counter(A)
    ans = []
    for i in range(1, N + 1):
        x = "Yes" if K - Q + C[i] > 0 else "No"
        ans.append(x)
    print(("\n".join(ans)))


if __name__ == "__main__":
    main()

# Optimized solution
# ABC141C - Attack Survival  (w/o Counter)
def main():
    N, K, Q, *A = list(map(int, open(0).read().split()))
    ans, C = [], [0] * (N + 1)
    for i in A:
        C[i] += 1
    for i in C[1:]:
        x = "Yes" if K - Q + i > 0 else "No"
        ans.append(x)
    print(("\n".join(ans)))


if __name__ == "__main__":
    main()
# Original solution
NKQ = list(map(int,input().split()))
point = [NKQ[1]]*NKQ[0]

for i in range(NKQ[2]):
    A = int(eval(input()))
    for j in range(NKQ[0]):
        if j != A-1:
            point[j] -= 1

for k in range(NKQ[0]):
    if point[k] > 0:
        print('Yes')
    else:
        print('No')

# Optimized solution
NKQ = list(map(int,input().split()))
point = [0]*NKQ[0]

for i in range(NKQ[2]):
    A = int(eval(input()))
    point[A-1] += 1

for j in range(NKQ[0]):
    if NKQ[1] - NKQ[2] + point[j] > 0:
        print('Yes')
    else:
        print('No')
# Original solution
n,k,q = list(map(int,input().split()))
a = [0]*q
score = [k]*n
for i in range(q):
    a[i] = int(eval(input()))
    for j in range(n):
        if j != a[i]-1:
            score[j] -= 1

for i in range(n):
    if score[i] <= 0:
        print('No')
    else:
        print('Yes')

# Optimized solution
n,k,q = list(map(int,input().split()))
a = [0]*q
# score = [k]*n
count = [0]*n
for i in range(q):
    a[i] = int(eval(input()))
    count[a[i]-1] += 1

g = k-q

for i in range(n):
    if g > 0:
        print('Yes')
    else:
        if count[i] > abs(g):
            print('Yes')
        else:
            print('No')
# Original solution
#!/usr/bin/env python
# coding: utf-8

# In[13]:


N,K,Q = map(int, input().split())
point = [K]*N
for _ in range(Q):
    A = int(input())
    point = [point[i]-1 if i != A-1 else point[i] for i in range(len(point))]
ans = [print("Yes") if point[i]>0 else print("No") for i in range(len(point))]


# In[ ]:






# Optimized solution
#!/usr/bin/env python
# coding: utf-8

# In[14]:


N,K,Q = map(int, input().split())
point = [0]*N
for _ in range(Q):
    A = int(input())
    point[A-1] += 1 
ans = [print("Yes") if point[i] > Q-K else print("No") for i in range(len(point))]


# In[ ]:
# Original solution
n,k,q=list(map(int,input().split()))
a=[]
for i in range(q):
  a.append(int(eval(input())))
#p=[k for _ in range(n)]
w=q-k+1
for i in range(n):
  if a.count(i+1) >= w:
    print('Yes')
  else:
    print('No')


# Optimized solution
n,k,q=list(map(int,input().split()))
a=[0 for _ in range(n)]
for i in range(q):
  x=int(eval(input()))
  a[x-1] += 1
w=q-k+1
for i in range(n):
  if a[i] >= w:
    print('Yes')
  else:
    print('No')
# Original solution
N, K, Q = list(map(int, input().split(' ')))
score = [K for player in range(N)]
answers = [int(eval(input())) - 1 for q in range(Q)]

for answer in answers:
    for i in range(N):
        if i != answer:
            score[i] = score[i] - 1

for result in score:
    if result > 0:
        print('Yes')
    else:
        print('No')


# Optimized solution
N, K, Q = list(map(int, input().split(' ')))
score = [K for player in range(N)]
answers = [int(eval(input())) - 1 for q in range(Q)]

for answer in answers:
    score[answer] = score[answer] + 1

score = [point - Q for point in score]

for result in score:
    if result > 0:
        print('Yes')
    else:
        print('No')
# Original solution
N,K,Q=list(map(int, input().split()))
m=max(N,Q)
A=[0]*m
for i in range(0,Q):
  A[i]=int(eval(input()))
S=[0]*m
T=[0]*m
for k in range(Q,m):
  A[k]=-1
  S[k]=-1
  T[k]=-1
  
for i in range(0,N):
  S[i]=A.count(i+1)
  T[i]=Q-S[i]
  if T[i]>=K:
    print("No")
  else:
    print("Yes")

# Optimized solution
N,K,Q=list(map(int, input().split()))
A=[0]*Q
for i in range(0,Q):
  A[i]=int(eval(input()))

Score_list=[K]*N
Sum_list=[0]*N
for i in range(0,Q):
  Sum_list[A[i]-1]+=1
 
for i in range(0,N):
  if Q-Sum_list[i]>=K:
    print("No")    
  else:
    print("Yes")
# Original solution
n,k,q=list(map(int,input().split()))
A=[int(eval(input())) for i in range(q)]

tensu=[]
for i in range(n):
    tensu.append(k)

for i in range(q):
    for j in range(n):
        if j!=A[i]-1:
            tensu[j]=tensu[j]-1

for i in range(n):
    if tensu[i]>0:
        print("Yes")
    else:
        print("No")

# Optimized solution
n,k,q=list(map(int,input().split()))
A=[int(eval(input())) for i in range(q)]

tokuten=[0]*n

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

for i in range(n):
    if tokuten[i]>q-k:
        print("Yes")
    else:
        print("No")
# Original solution
N, K, Q = list(map(int, input().split()))
A = []
for i in range(Q):
    a = int(eval(input()))
    A.append(a)

for i in range(N):
    if K - (Q - A.count(i+1))> 0:
        print('Yes')
    else:
        print('No')

# Optimized solution
N, K, Q = list(map(int, input().split()))
A = [K-Q]*N
for i in range(Q):
    a = int(eval(input()))
    A[a-1] += 1

for i in range(N):
    if A[i]> 0:
        print('Yes')
    else:
        print('No')
# Original solution
def update_points(points, current_ansewr):
    return list(
        map(
            lambda x: x[1] if (x[0] + 1) == current_ansewr else x[1] - 1,
            enumerate(points),
        )
    )


N, K, Q = [int(i) for i in input().split()]
points = [K] * N
for _ in range(Q):
    answer = int(eval(input()))
    points = update_points(points, answer)
for p in points:
    print(("Yes" if p > 0 else "No"))


# Optimized solution
N, K, Q = [int(i) for i in input().split()]
points = [(K - Q)] * N
for _ in range(Q):
    answer = int(eval(input()))
    points[answer - 1] += 1
for p in points:
    print(("Yes" if p > 0 else "No"))
# Original solution
a = list(map(int,input().split()))
results = [int(eval(input())) for i in range(a[2])]

points = [a[1]] * a[0]

for result in results:
    points = list([x - 1 for x in points])
    points[result - 1] = points[result - 1] + 1


for point in points:
    if point > 0:
        print('Yes')
    else:
        print('No')
    

# Optimized solution
a = list(map(int,input().split()))
results = [int(eval(input())) for i in range(a[2])]

points = [a[1]] * a[0]
points = list([x - a[2] for x in points])

for result in results:
    points[result - 1] = points[result - 1] + 1


for point in points:
    if point > 0:
        print('Yes')
    else:
        print('No')
# Original solution
n,k,q=list(map(int,input().split()))
ls=[k]*n
for _ in range(q):
  a=int(eval(input()))
  
  for i in range(n):
    if i+1==a:
      ls[i]+=1
      break
    
for i in ls:
  if i<=q:
    print("No")
  else:
    print("Yes")

# Optimized solution
n,k,q=list(map(int,input().split()))
ls=[0]*n

for _ in range(q):
  a=int(eval(input()))
  ls[a-1]+=1
  
for i in ls:
  print(("Yes"if k+i>q else "No"))
# Original solution
def resolve():
    N,K,Q = list(map(int,input().split()))
    A = [eval(input()) for i in range(Q)]
    P = [K for i in range(N)]

    def calc(n):
        return n-1

    for i in range(Q):
        P = list(map(calc,P))
        P[int(A[i])-1] += 1

    for i in range(N):
        if P[i] <= 0:
            print("No")
        else:
            print("Yes")
resolve()

# Optimized solution
def resolve():
    N,K,Q = list(map(int,input().split()))
    A = [eval(input()) for i in range(Q)]
    P = [K] * N

    def calc(n):
        return n-Q

    for i in range(Q):
        P[int(A[i])-1] += 1

    P = list(map(calc, P))

    for i in range(N):
        if P[i] <= 0:
            print("No")
        else:
            print("Yes")
resolve()
# Original solution
n,k,q = list(map(int,input().split()))
a = [int(input()) for i in range(q)]
t = ["No"]*(n-max(a))
if k - q > 0:
        print(*["Yes"]*n,sep="\n")
        exit()
for i in range(1,max(a)+1):
    if k + a.count(i) - q > 0 :
        print("Yes")
    else:
        print("No")
print(*t,sep="\n")


# Optimized solution
n,k,q = list(map(int,input().split()))
t = [0]*n
for i in range(q):
    t[int(input())-1] += 1

print(*["Yes" if k + i - q > 0 else "No" for i in t],sep="\n")
# Original solution
n, k, q = list(map(int, input().split()))
a = [int(eval(input())) for i in range(q)]
p = [k - q] * n
'''
p = []
for i in range(n):
    p.append(k)
for i in range(q):
    for j in range(n):
        if(j + 1 == a[i]):
            pass
        else:
            p[j] = p[j] - 1
#print(p)
for i in range(n):
    if(p[i] > 0):
        print('Yes')
    else:
        print('No')
'''
for i in range(q):
    for j in range(n):
        if(j + 1 == a[i]):
            p[j] += 1
for i in range(n):
    if(p[i] > 0):
        print('Yes')
    else:
        print('No')


# Optimized solution
n, k, q = list(map(int, input().split()))
a = [int(eval(input())) for i in range(q)]
p = [k - q] * n
for i in range(q):
    p[a[i] - 1] += 1
for i in range(n):
    if(p[i] > 0):
        print('Yes')
    else:
        print('No')
# Original solution
N,K,Q = list(map(int, input().split()))

a = []

for i in range(0,Q):
    x = int(eval(input()))
    a.append(x)

l = [K] * N

for i in a:
    for n in range(0,N):
        if n == (i-1):
            pass
        else:
            l[n] -= 1

for n in range(0, N):
    if l[n] <= 0:
        print("No")
    else:
        print("Yes")

# Optimized solution
N,K,Q = list(map(int, input().split()))

a = []

for i in range(0,Q):
    x = int(eval(input()))
    a.append(x)

l = [0] * N

for i in a:
    l[i-1] += 1

for n in range(0, N):
    if l[n] >= (Q-K+1):
        print("Yes")
    else:
        print("No")
# Original solution
n,k,q = list(map(int, input().split()))
l=[int(eval(input())) for x in range(q)]
x=k-q
if x>=1:
    for i in range(n):
        print("Yes")
elif x<1:
    bd=abs(x)+1
    for i in range(n):
        if l.count(i+1)>=bd:
            print("Yes")
        else:
            print("No") 

# Optimized solution
n,k,q = list(map(int, input().split()))
l=[int(eval(input())) for x in range(q)]
p=[0]*n
for i in l:
    p[i-1]=p[i-1]+1
for i in p:
    if i>=(q-k)+1:
        print("Yes")
    else:
        print("No")
# Original solution
N,K,Q=[int(e) for e in input().split(' ')]
lA=[int(eval(input())) for _ in range(Q)]

for i in range(N):
    if Q-lA.count(i+1) >= K:
        print('No')
    else:
        print('Yes')

# Optimized solution
N,K,Q=[int(e) for e in input().split(' ')]

c=[0]*N
for _ in range(Q):
    c[int(eval(input()))-1]+=1

for i in range(N):
    if Q-c[i] >= K:
        print('No')
    else:
        print('Yes')
# Original solution
import sys
import math
from copy import deepcopy
from collections import deque, defaultdict
from operator import mul
from functools import reduce
sys.setrecursionlimit(20000000)

# input = sys.stdin.readline


def main():
    n, k, q = list(map(int, input().split()))

    winners = []
    for w in range(q):
        winners.append(int(eval(input())))

    score = [k] * n

    for w in winners:
        winner = w - 1

        for i in range(len(score)):
            score[i] -= 1

        score[winner] += 1

    for s in score:
        if s > 0:
            print('Yes')
        else:
            print('No')


if __name__ == '__main__':
    main()

# Optimized solution
import sys
import math
from copy import deepcopy
from collections import deque, defaultdict
from operator import mul
from functools import reduce
sys.setrecursionlimit(20000000)

# input = sys.stdin.readline


def main():
    n, k, q = list(map(int, input().split()))

    winners = []
    for w in range(q):
        winners.append(int(eval(input())))

    score = [k - q] * n

    for w in winners:
        winner = w - 1

        score[winner] += 1

    for s in score:
        if s > 0:
            print('Yes')
        else:
            print('No')


if __name__ == '__main__':
    main()
# Original solution
def main():
  import sys
  import collections
  n,k,q=list(map(int,input().split()))
  a=[int(e) for e in sys.stdin]
  point=[k-q]*n
  
  for person,getPoint in list(collections.Counter(a).items()):
    point[person-1]+=getPoint
  
  for res in point:
    print(("Yes" if res>0 else "No"))
    
  
if __name__=="__main__":
  main()

# Optimized solution
def main():
  import collections
  n, k, q, *a = list(map(int, open(0).read().split()))
  point=[k-q]*n
  
  for person,getPoint in list(collections.Counter(a).items()):
    point[person-1]+=getPoint
  
  for res in point:
    print(("Yes" if res>0 else "No"))
    
if __name__=="__main__":
  main()