jiahuimbzuai/CoQuIR huggingface dataset:
//  [typescript]
const log = console.log;

const createScanFunctions = (input: string) => {
  const str = input.trim();
  const len = str.length;
  let index = 0;

  const scan = () => {
    const startIndex = index;

    while (index < len) {
      const char = str[index];

      if (char === " " || char === "\n")
        return str.substring(startIndex, index++);

      index++;
    }

    return str.substr(startIndex);
  };

  const scanInt = () => parseInt(scan());

  return { scan, scanInt };
};

// ----

const createWeightedUnionFindTree = (elementCount: number) => {
  const parent = new Array<number>(elementCount);
  const rank = new Array<number>(elementCount);
  const weightDifference = new Array<number>(elementCount);

  for (let i = 0; i < elementCount; i++) {
    parent[i] = i;
    rank[i] = 0;
    weightDifference[i] = 0;
  }

  const getRoot = (id: number): number => {
    if (parent[id] === id) return id;

    const root = getRoot(parent[id]);
    weightDifference[id] += weightDifference[parent[id]];

    return (parent[id] = root);
  };

  const getWeight = (id: number) => {
    getRoot(id);

    return weightDifference[id];
  };

  const getWeightDifference = (idA: number, idB: number) =>
    getWeight(idA) - getWeight(idB);

  const uniteTrees = (idA: number, idB: number, weightDiff: number): void => {
    weightDiff += getWeight(idA) - getWeight(idB);

    const rootA = getRoot(idA);
    const rootB = getRoot(idB);

    if (rootA === rootB) return;

    if (rank[rootA] < rank[rootB]) {
      parent[rootA] = rootB;
      weightDifference[rootA] = -weightDiff;
    } else {
      parent[rootB] = rootA;
      weightDifference[rootB] = weightDiff;
      if (rank[rootA] === rank[rootB]) rank[rootA]++;
    }
  };

  const sameTree = (idA: number, idB: number) => getRoot(idA) === getRoot(idB);

  return {
    getRoot,
    uniteTrees,
    sameTree,
    getWeight,
    getWeightDifference
  };
};

const isOdd = (n: number) => (n & 1) === 1;

// ----

function Main(input: string): void {
  const { scanInt } = createScanFunctions(input);
  const n = scanInt();

  const { uniteTrees, getWeightDifference } = createWeightedUnionFindTree(n);

  const edgeCount = n - 1;

  for (let i = 0; i < edgeCount; i++) {
    const vertexIdA = scanInt() - 1;
    const vertexIdB = scanInt() - 1;
    const distance = scanInt();

    uniteTrees(vertexIdA, vertexIdB, distance);
  }

  const vertexColors = new Array<number>(n).fill(0);
  for (let i = 1; i < n; i++)
    if (isOdd(getWeightDifference(0, i))) vertexColors[i] = 1;

  log(vertexColors.join("\n"));
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
import * as fs from "fs";

let [N_str, ...uvw_str] = fs.readFileSync("/dev/stdin", "utf8").trim().split('\n');

let N = Number(N_str);
let colors: boolean[] = new Array(N).fill(false);


type weight = number;
let tree: Map<number, [number, weight][]> = new Map();

for(let i=0; i<N-1; i++) {
    // u < v
    let [u, v, w] = uvw_str[i].split(' ').map(Number);
    u -= 1;
    v -= 1;
    for(let [p, child] of [[u, v], [v, u]]) {
        if (!tree.has(p)) {
            tree.set(p, []);
        }
        tree.get(p).push([child, w]);
    }
}

let stack: [number, number | null][] = [[0, null]]; // list of pair of (node, parent)

while (stack.length != 0) {
    let [node, prev] = stack.pop()
    if (tree.has(node)) {
        for(let [child, weight] of tree.get(node)) {
            if (child == prev)
                continue;
            if (weight%2 == 0) {
                colors[child] = colors[node];
            } else {
                colors[child] = !colors[node];
            }
            stack.push([child, node]);
        }
    }
}

for(let i=0; i<N; i++) {
    console.log((colors[i]?0:1));
}
//  [typescript]
const log = console.log;

const createScanFunctions = (input: string) => {
  const str = input.trim();
  const len = str.length;
  let index = 0;

  const scan = () => {
    const startIndex = index;

    while (index < len) {
      const char = str[index];

      if (char === " " || char === "\n")
        return str.substring(startIndex, index++);

      index++;
    }

    return str.substr(startIndex);
  };

  const scanInt = () => parseInt(scan());

  return { scan, scanInt };
};

const createArrayOfNumberArrays = (length: number) => {
  const array = new Array<number[]>(length);
  for (let i = 0; i < length; i++) array[i] = [];

  return array;
};

const isEven = (n: number) => (n & 1) === 0;

// ----

function Main(input: string): void {
  const { scanInt } = createScanFunctions(input);

  // prepare graph
  const n = scanInt();
  const adjacentVertexIdTable = createArrayOfNumberArrays(n);
  const adjacentVertexDistanceTable = createArrayOfNumberArrays(n);
  const vertexColorArray = new Array<number | undefined>(n).fill(undefined);

  function linkVertices(id: number, adjacentId: number, distance: number) {
    adjacentVertexIdTable[id].push(adjacentId);
    adjacentVertexDistanceTable[id].push(distance);
    adjacentVertexIdTable[adjacentId].push(id);
    adjacentVertexDistanceTable[adjacentId].push(distance);
  }

  function paintVertex(id: number, color: number) {
    vertexColorArray[id] = color;
  }

  const getVertexColor = (id: number) => vertexColorArray[id];

  // read edges data
  const edgeCount = n - 1;

  for (let i = 0; i < edgeCount; i++)
    linkVertices(scanInt() - 1, scanInt() - 1, scanInt());

  // prepare search, visit first vertex
  const recentVisitedStack: number[] = [];

  vertexColorArray[0] = 0;
  recentVisitedStack.push(0);

  const visitAdjacentVerticesOf = (vertexId: number, searchStack: number[]) => {
    const adjacentVertexIdArray = adjacentVertexIdTable[vertexId];
    const adjacentVertexDistanceArray = adjacentVertexDistanceTable[vertexId];
    const len = adjacentVertexIdArray.length;

    const currentColor = getVertexColor(vertexId);
    if (currentColor === undefined)
      throw new Error(`Vertex id: ${vertexId} not colored.`);

    for (let i = 0; i < len; i++) {
      const adjacentVertexId = adjacentVertexIdArray[i];

      if (vertexColorArray[adjacentVertexId] !== undefined) continue; // already visited

      const adjacentColor = isEven(adjacentVertexDistanceArray[i])
        ? currentColor
        : currentColor ^ 1;

      paintVertex(adjacentVertexId, adjacentColor);

      searchStack.push(adjacentVertexId);
    }
  };

  // search & paint
  while (true) {
    const vertexId = recentVisitedStack.pop();
    if (vertexId === undefined) break;

    visitAdjacentVerticesOf(vertexId, recentVisitedStack);
  }

  // output
  for (const color of vertexColorArray) log(color);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
import * as fs from "fs";

let [N_str, ...uvw_str] = fs.readFileSync("/dev/stdin", "utf8").trim().split('\n');

let N = Number(N_str);
let colors: boolean[] = new Array(N).fill(false);


type weight = number;
let tree: Map<number, [number, weight][]> = new Map();

for(let i=0; i<N-1; i++) {
    // u < v
    let [u, v, w] = uvw_str[i].split(' ').map(Number);
    u -= 1;
    v -= 1;
    if (!tree.has(u)) {
        tree.set(u, []);
    }
    tree.get(u).push([v, w]);
}

let stack: number[] = [0];

while (stack.length != 0) {
    let node = stack.pop()
    if (tree.has(node)) {
        for(let [child, weight] of tree.get(node)) {
            if (weight%2 == 0) {
                colors[child] = colors[node];
            } else {
                colors[child] = !colors[node];
            }
            stack.push(child);
        }
    }
}

for(let i=0; i<N; i++) {
    console.log((colors[i]?0:1));
}
//  [typescript]
import * as fs from "fs";

let [N_str, ...uvw_str] = fs.readFileSync("/dev/stdin", "utf8").trim().split('\n');

let N = Number(N_str);
let U = new Array();
let V = new Array();
let W = new Array();
for(let i=0; i<N-1; i++) {
    let [u, v, w] = uvw_str[i].split(' ').map(Number);
    U.push(u);
    V.push(v);
    W.push(w);
}
for(let i=0; i<N; i++) {
    console.log(0);
}
//  [typescript]
const log = console.log;

const createScanFunctions = (input: string) => {
  const str = input.trim();
  const len = str.length;
  let index = 0;

  const scan = () => {
    const startIndex = index;

    while (index < len) {
      const char = str[index];

      if (char === " " || char === "\n")
        return str.substring(startIndex, index++);

      index++;
    }

    return str.substr(startIndex);
  };

  const scanInt = () => parseInt(scan());

  return { scan, scanInt };
};

// ----

const createUnionFindTree = (elementCount: number) => {
  const parent = new Array<number>(elementCount);
  const rank = new Array<number>(elementCount);

  for (let i = 0; i < elementCount; i++) {
    parent[i] = i;
    rank[i] = 0;
  }

  const getRoot = (id: number) =>
    parent[id] === id ? id : (parent[id] = getRoot(parent[id]));

  const uniteGroups = (idA: number, idB: number): void => {
    const rootA = getRoot(idA);
    const rootB = getRoot(idB);

    if (rootA === rootB) return;

    if (rank[rootA] < rank[rootB]) {
      parent[rootA] = rootB;
    } else {
      parent[rootB] = rootA;
      if (rank[rootA] === rank[rootB]) rank[rootA]++;
    }
  };

  const sameGroup = (idA: number, idB: number) => getRoot(idA) === getRoot(idB);

  return { uniteGroups, sameGroup };
};

const isEven = (n: number) => (n & 1) === 0;

// ----

function Main(input: string): void {
  const { scanInt } = createScanFunctions(input);
  const n = scanInt();

  const { uniteGroups, sameGroup } = createUnionFindTree(n);

  const edgeCount = n - 1;

  for (let i = 0; i < edgeCount; i++) {
    const vertexIdA = scanInt() - 1;
    const vertexIdB = scanInt() - 1;
    const distance = scanInt();

    if (isEven(distance)) uniteGroups(vertexIdA, vertexIdB);
  }

  // output
  const vertexColors = new Array<number>(n).fill(0);
  for (let i = 0; i < n; i++) if (!sameGroup(i, 0)) vertexColors[i] = 1;

  log(vertexColors.join("\n"));
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [python]
def main():
    n, k, q, *al = map(int, open(0).read().split())
    gl = [0] * n
    for a in al:
        gl[a-1] += 1

    res = '\n'.join(
        'Yes' if g > q-k
        else 'No'
        for g in gl
    )
    print(res)

if __name__ == '__main__':
    main()
//  [python]
def main():
    N, K, Q, *A = map(int, open(0).read().split())
    ans = [0] * N
    for a in A:
        ans[a - 1] += 1
    print("\n".join("Yes" if Q < K + a else "No" for a in ans))
    return


main()
//  [python]
def main():
    N, K, Q, *A = map(int, open(0).read().split())
    ans = [0] * N
    for a in A:
        ans[a - 1] += 1
    print("\n".join(["Yes" if Q < K + a
                     else "No" for a in ans]))
    return


main()
//  [python]
n,k,q = map(int,input().split())
point = [k]*(n)
for _ in range(q):
    a = int(input())
    for i in range(n):
        if a-1 == i:
            pass
        else:
            point[i] -= 1
for i in range(n):
    if point[i] > 0:
        print("Yes")
    else:
        print("No")
//  [python]
N,K,Q = map(int,input().split())
A = [int(input()) for i in range(Q)]
B = [K]*N
p = 0
for i in range(N+1):
    A.append(i+1)
C = sorted(A)
for i in range(N):
    B[i] += C.index(i+2) - p - 1
    p = C.index(i+2)
for i in range(N):
    if(B[i] > Q):
        print("Yes")
    else:
        print("No")
//  [python]
N,K,Q = map(int,input().split())
A = [int(input()) for i in range(Q)]
B = [K]*N
for i in range(N):
    B[i] += A.count(i+1)
for i in range(N):
    if(B[i] > Q):
        print("Yes")
    else:
        print("No")
//  [java]
import java.util.Scanner;

public class Main {

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int k = sc.nextInt();
    int q = sc.nextInt();
    int[] a = new int[n];

    for (int i = 0; i < q; i++) {
      int c = sc.nextInt();
      a[c - 1]++;
    }

    for (int i = 0; i < n; i++) {
      if (a[i] > Math.max(q - k, 0)) {
        System.out.println("Yes");
      } else {
        System.out.println("No");
      }
    }

  }
}
//  [java]
import java.util.Arrays;
import java.util.Scanner;

public class Main {

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int k = sc.nextInt();
    int q = sc.nextInt();
    int[] a = new int[n];
    Arrays.fill(a, k);

    for (int i = 0; i < q; i++) {
      int c = sc.nextInt();
      for (int j = 0; j < n; j++) {
        if (j != (c - 1)) {
          a[j]--;
        }
      }
    }

    for (int i = 0; i < n; i++) {
      if (a[i] > 0) {
        System.out.println("Yes");
      } else {
        System.out.println("No");
      }
    }

  }
}
//  [cpp]
//#include<bits/stdc++.h>
#include<cstdio>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please

const int cm = 1 << 17;
char cn[cm], * ci = cn + cm;
inline char getcha() {
	if (ci - cn == cm) { fread(cn, 1, cm, stdin); ci = cn; }
	return *ci++;
}
inline int getint() {
	char C = getcha();
	int A = C - '0';
	while ((C = getcha()) >= '0') A = A * 10 + C - '0';
	return A;
}

const int dm = 1 << 12;
char dn[dm], * di = dn;

int main() {
	//cin.tie(0);
	//ios::sync_with_stdio(false);


	int N = getint(), K = getint(), Q = getint();

	int P[100001];
	rep1(i, N) {
		P[i] = K - Q;
	}
	rep(i, Q) {
		P[getint()]++;
	}
	rep1(i, N) {
		if (P[i] > 0) {
			*di++ = 'Y';
			*di++ = 'e';
			*di++ = 's';
			*di++ = '\n';
		}
		else {
			*di++ = 'N';
			*di++ = 'o';
			*di++ = '\n';
		}
		if (i % 100 == 0) {
			fwrite(dn, 1, di - dn, stdout);
			di = dn;
		}
	}
	fwrite(dn, 1, di - dn, stdout);

	Would you please return 0;
}
//  [cpp]
//#include<bits/stdc++.h>
#include<cstdio>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please

const int cm = 1 << 17;
char cn[cm], * ci = cn + cm;
inline char getcha() {
	if (ci - cn == cm) { fread(cn, 1, cm, stdin); ci = cn; }
	return *ci++;
}
inline int getint() {
	char C = getcha();
	int A = C - '0';
	while ((C = getcha()) >= '0') A = A * 10 + C - '0';
	return A;
}

const int dm = 1 << 16;
char dn[dm], * di = dn;

int main() {
	//cin.tie(0);
	//ios::sync_with_stdio(false);


	int N = getint(), K = getint(), Q = getint();

	int P[100001];
	rep1(i, N) {
		P[i] = K - Q;
	}
	rep(i, Q) {
		P[getint()]++;
	}
	rep1(i, N) {
		if (P[i] > 0) {
			*di++ = 'Y';
			*di++ = 'e';
			*di++ = 's';
			*di++ = '\n';
		}
		else {
			*di++ = 'N';
			*di++ = 'o';
			*di++ = '\n';
		}
		if (i % 16000 == 0) {
			fwrite(dn, 1, di - dn, stdout);
			di = dn;
		}
	}
	fwrite(dn, 1, di - dn, stdout);

	Would you please return 0;
}
//  [cpp]
//#include<bits/stdc++.h>
#include<cstdio>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please

const int cm = 1 << 17;
char cn[cm], * ci = cn + cm;
inline char getcha() {
	if (ci - cn == cm) { fread(cn, 1, cm, stdin); ci = cn; }
	return *ci++;
}
inline int getint() {
	char C = getcha();
	int A = C - '0';
	while ((C = getcha()) >= '0') A = A * 10 + C - '0';
	return A;
}

const int dm = 1 << 17;
char dn[dm], * di = dn;

int main() {
	//cin.tie(0);
	//ios::sync_with_stdio(false);


	int N = getint(), K = getint(), Q = getint();

	int P[100001];
	rep1(i, N) {
		P[i] = K - Q;
	}
	rep(i, Q) {
		P[getint()]++;
	}
	rep1(i, N) {
		if (P[i] > 0) {
			*di++ = 'Y';
			*di++ = 'e';
			*di++ = 's';
			*di++ = '\n';
		}
		else {
			*di++ = 'N';
			*di++ = 'o';
			*di++ = '\n';
		}
		if (i % 25000 == 0) {
			fwrite(dn, 1, di - dn, stdout);
			di = dn;
		}
	}
	fwrite(dn, 1, di - dn, stdout);

	Would you please return 0;
}
//  [cpp]
#include<iostream>
#include <algorithm>
#include <cmath>
#include <set>
#include<map>	
#include<cstring>
#include<iomanip>
#include <string>
#include <vector>	
#include<unordered_map>
#include<unordered_set>
using namespace std;


typedef long long unsigned llu;
typedef long double ld;
#define ll long long
#define PI 3.14159265358979323846
#define For(i, a, b) for (int i = a, sz = (int)b; i < sz; i++)
#define rFor(i, a, b, c) for (int i = (a); i >= (b); i -= (c))
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define fill(a, b) memset(a, b, sizeof(a))
#define IO ios_base::sync_with_stdio(false), cin.tie(0),cout.tie(0)
const int mod = 1000000007;
const ll inf = 1000000000009;
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b) { return a*b/gcd(a,b);}

//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdoutn

int main()
{
	IO;
	map<int,int>m;
	ll n{},k{},q{};
	cin>>n>>k>>q;
	For(i,1,q+1){int x{};cin>>x; m[x]++;}
	vector<int>p(n+1);
	For(i,1,n+1)p[i]=k;
	For(i,1,n+1)
	{
		if(m[i]>0)p[i]-=q-m[i];
		else if(!m[i])p[i]-=q;
	}
	For(i,1,n+1)
	{
		if(p[i]>0)cout<<"YES\n";
		else cout<<"NO\n";
	}
//	system("pause");	
	return 0;
}
//  [cpp]
// セグメントツリー　遅延評価なし ((0-indexed))
// https://www.creativ.xyz/segment-tree-abstraction-979/
#include <bits/stdc++.h>
using namespace std;

#define rep(i,n) for(int i=0;i<(n);i++)

typedef long long ll;

#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
//定数
#define INF 1000000000 //10^9:極めて大きい値,∞
//略記
#define PB push_back //vectorヘの挿入
#define MP make_pair //pairのコンストラクタ
#define F first //pairの一つ目の要素
#define S second //pairの二つ目の要素

template <class T>
class SegTree {
    int n;                       // 葉の数
    vector<T> data;              // データを格納するvector
    T def;                       // 初期値かつ単位元
    function<T(T, T)> operation; // 区間クエリで使う処理

    // 区間[a,b)の総和。ノードk=[l,r)に着目している。
    T _query(int a, int b, int k, int l, int r) {
        if (r <= a || b <= l) return def; // 交差しない
        if (a <= l && r <= b)
            return data[k]; // a,l,r,bの順で完全に含まれる
        else {
            T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
            T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
            return operation(c1, c2);
        }
    }

  public:
    // _n:必要サイズ, _def:初期値かつ単位元, _operation:クエリ関数
    SegTree(size_t _n, T _def, function<T(T, T)> _operation)
        : def(_def), operation(_operation) {
        n = 1;
        while (n < _n) {
            n *= 2;
        }
        data = vector<T>(2 * n - 1, def);
    }

    // 場所i(0-indexed)の値をxで更新
    void change(int i, T x) {
        i += n - 1;
        data[i] = x;
        while (i > 0) {
            i = (i - 1) / 2;
            data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
        }
    }
    // 場所i(0-indexed)の値をxで加算
    void add(int i, T x) {
        i += n - 1;
        data[i] = data[i]+ x;
        while (i > 0) {
            i = (i - 1) / 2;
            data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
        }
    }

    // [a, b)の区間クエリを実行
    T query(int a, int b) {
        return _query(a, b, 0, 0, n);
    }

    // 添字でアクセス
    T operator[](int i) {
        return data[i + n - 1];
    }
};
/////////////////////////////
// 区間クエリ                                                  dif
// 区間ｍinクエリ： int func(int a, int b){ return min(a, b); } INF
// 区間ｍaxクエリ： int func(int a, int b){ return max(a, b); } -INF
// 区間和： int func(int a, int b){ return a + b; }            0
/////////////////////////////

int main(void) {
    int N, K, Q;
    cin >> N >> K >> Q;
    // 要素数N・dif=INF・区間min
    SegTree<long long> st(N, K,
                          [](long long a, long long b) { return a+b; });
    rep(q, Q) {
        int a;
        cin >> a;
        a--;
        rep(i,a) st.add(i,-1);
        for(int i=a+1;i<N;i++) st.add(i,-1);
    }
    rep(i,N){
        if(st[i]>0) cout<<"Yes"<<endl;
        else cout<<"No"<<endl;
    }
    return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main(){
  int n,k,q,ans;
  cin>>n>>k>>q;
  vector<int>p(n+1,k-q);
  for(int i=0;i<q;i++){
    int ai;
    cin>>ai;
    p[ai]++;
    ans+=p[ai]>0;
  }
  cout<<ans<<endl;
  return 0;
}
//  [c]
// 2019.9.15 bal4u
// Template for Online Contest

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef long long ll;

#define gc() getchar()
#define pc(c) putchar(c)

int in() {  // 整数の入力
	int n = 0, c = gc();
	if (c == '-') {	c = gc();
		do n = 10*n + (c & 0xf), c = gc(); while (c >= '0');
		return -n;
	}
	do n = 10*n + (c & 0xf), c = gc(); while (c >= '0');
	return n;
}

ll inL() {  // long long 整数の入力
	ll n = 0; int c = gc();
	if (c == '-') {	c = gc();
		do n = 10*n + (c & 0xf), c = gc(); while (c >= '0');
		return -n;
	}
	do n = 10*n + (c & 0xf), c = gc(); while (c >= '0');
	return n;
}

void out(int n) { // 整数の表示
	int i; char b[30];
	if (!n) pc('0');
	else {
		if (n < 0) pc('-'), n = -n;
		i = 0; while (n) b[i++] = n % 10 + '0', n /= 10;
		while (i--) pc(b[i]);
	}
	pc('\n');
}

void outL(ll n) { // 整数の表示
	int i; char b[30];
	if (!n) pc('0');
	else {
		if (n < 0) pc('-'), n = -n;
		i = 0; while (n) b[i++] = n % 10 + '0', n /= 10;
		while (i--) pc(b[i]);
	}
	pc('\n');
}

int ins(char *s) { // 文字列の入力
	char *p = s--;
	do *++s = gc();
	while (*s > ' ');
	*s = 0;
	return s - p;
}

void outs(char *s) {  // 文字列の表示
	while (*s) pc(*s++);
}

#define MIN(a,b)  ((a)<=(b)?(a):(b))
#define MAX(a,b)  ((a)>=(b)?(a):(b))
#define ABS(a)    ((a)>=0?(a):-(a))
inline static int chmax(int *a, int b) { if (*a < b) *a = b; }
inline static ll  chmaxL(ll *a, int b) { if (*a < b) *a = b; }
inline static int chmin(int *a, int b) { if (*a > b) *a = b; }
inline static ll  chminL(ll *a, int b) { if (*a > b) *a = b; }

int N, K, Q;
int f[100005];

int main()
{
	int i;

	N = in(), K = in(), Q = in();
	for (i = 0; i < Q; i++) f[in()]++;
	for (i = 1; i <= N; i++) puts(K-Q+f[i] <= 0? "No": "Yes");
	return 0;
}
//  [c]
#include<stdio.h>
#include<stdlib.h>
int main(void){
    int num;
    int firstpoint;
    int score;
    int correct[100001];
    int point[100001];
    int minuspoint[100001]={};
    int ans=0;
    char str[20];

    scanf("%d%d%d\n",&num,&firstpoint,&score);

    for(int i=0;i<score;i++){
        gets(str);
        correct[i]=atoi(str);
        minuspoint[correct[i]-1]++;
    }
    
    for(int a=0;a<num;a++){
        if(firstpoint-score+minuspoint[a]>0){
            printf("Yes\n");
        }else{
            printf("No\n");
        }
    }
    return 0;

}
//  [c]
int main()
{
  int n, k, q;
  scanf("%d %d %d", &n, &k, &q);
  int point[n], i;
  for (i = 0; i < n; i++)
    point[i] = 0;
  int a[q];
  for (i = 0; i < q; i++)
  {
    scanf("%d", &a[i]);
    point[a[i] - 1]++;
  }
  int tmp = q - k;
  for (i = 0; i < n; i++)
  {
    if (point[i] > tmp)
    {
      printf("Yes\n");
    }
    else
    {
      printf("No\n");
    }
  }
}
//  [c]
#include <stdio.h>
#include <stdlib.h>

int main()
{
  int n,k,q,i,j,a;
  int *point;

  scanf("%d%d%d",&n,&k,&q );
  point = calloc(n,sizeof(int));
  for(i=0; i<n; i++)
    point[i] = k;

  for(i=0; i<q; i++){
    scanf("%d", &a);
      for(j=0; j<n; j++){
        if(j != a-1)
          point[j]--;
      }
  }

  for(i=0; i<n; i++)
  {
    if(point[i] > 0)
      puts("Yes");
    else
      puts("No");
  }
  free(point);
  return 0;
}
//  [c]
#ifndef LOCAL
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#else
#include <iostream>
#include <iomanip> 
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <memory>
#include <cctype>
#include <cstring>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <algorithm>
#include <numeric>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; }; sim > rge<c> range(c i, c j) { return rge<c>{i, j}; } sim > auto dud(c* x) -> decltype(cerr << *x, 0); sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; } eni(!=) cerr << boolalpha << i; ris; } eni(==) ris << range(begin(i), end(i)); } sim, class b dor(pair < b, c > d) { ris << "(" << d.first << ", " << d.second << ")"; } sim dor(rge<c> d) { *this << "["; for (auto it = d.b; it != d.e; ++it) *this << ", " + 2 * (it == d.b) << *it; ris << "]"; }
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

// #include <ext/pb_ds/assoc_container.hpp> 
// #include <ext/pb_ds/tree_policy.hpp> 
// using namespace __gnu_pbds; 
// #define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update> 

template<typename T> void setmax(T& x, T y) {x = max(x, y);}
template<typename T> void setmin(T& x, T y) {x = min(x, y);}
#define fix(a) fixed << setprecision(a)
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
#define all(V) V.begin(), V.end()
#define rall(V) V.rbegin(), V.rend()
#define len(V) (int)V.size()
#define ll long long
#define ld long double
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define endl '\n'



void solve(){
  int n, k, q;
  cin >> n >> k >> q;
  vector<int> m(n);
  forn(i,q){
    int a;
    cin >> a;
    a--;
    m[a]++;
  }
  rep(i,0,n){
    if(k+m[i]-q <= 0){
      cout << "No" << endl;
    } else {
      cout << "Yes" << endl;
    }
  }
}

int main() {
  ios::sync_with_stdio(false); 
  // cin.tie(0); cout.tie(0);
  int t = 1;
  // cin >> t;
  forn(i, t){
    solve();
  }
}

/* 




*/
//  [c]
#include <stdio.h>
int main()
{
  long long n,k,q;
  scanf("%lli%lli%lli",&n,&k,&q);
  long long p[n];
  long long t[q];
  for (long long i=0;i<q;i++) {
    scanf("%lli",&t[i]);
    p[t[i]-1] += 1;
  }
  for (long long i=0;i<n;i++) {
    if (k-q+p[i]>0) {
      printf("%s\n","Yes");
    } else {
      printf("%s\n","No");
    }
  }
  return 0;  
}
//  [javascript]
function main(arg) {
	arg = arg.trim().split('\n');
  	var data = arg.shift().split(' ').map(str => parseInt(str, 10)),
        //参加者、ポイント、回答数
      	n = data[0], k = data[1], q = data[2],
        //正解者、pt数
        arg = arg.map(str => parseInt(str, 10)), pt = new Array(n).fill(0);
    //加点処理
  	for (var i = 0; i < q; i++) {
      pt[arg[i]-1] +=1
    }
  	//減点処理
  	for (var i = 0; i < n; i++) {
    	 pt[i] = pt[i]-(q-k);
    }
  	//1pt以上を判定
  	for (var i = 0; i < n; i++) {
    	pt[i] = (pt[i] > 0) ? 'Yes' : 'No';
    }
  	var out = pt.join('\n');
  console.log(out);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input) {
  data = input.split('\n');
  var N = data[0].split(' ')[0];
  var K = data[0].split(' ')[1];
  var Q = data[0].split(' ')[2];
  N = parseInt(N, 10);
  K = parseInt(K, 10);
  Q = parseInt(Q, 10);

  var A = input.split('\n');
  A.shift();
  for(var i = 0; i < Q; i++) {
    A[i] = parseInt(A[i], 10);
  }


  var C = [];
  for(var i = 0; i < N; i++) {
    C[i] = 0;
  }
  for(var i = 0; i < Q; i++) {
    C[A[i] - 1] += 1;
  }
    /*
    C = C.map((x)=>{
    var a;
    a = x - Q;
    a += K;
    return a;
  });
  */
  C = C.map(function(x) {
    var a;
    a = x - Q;
    a += K;
    return a;
  });

  for(var i = 0;i < N; i++) {
    if(C[i] > 0) {
      C[i] = 'Yes';
    } else {
      C[i] = 'No';
    }
  }
  
  console.log(C.join('\n'));
}
Main(require('fs').readFileSync('/dev/stdin', 'utf-8'));
//  [javascript]
"use strict";
    
const main = arg => {
    arg = arg.trim().split("\n");
    const N = parseInt(arg[0].split(" ")[0]);
    const K = parseInt(arg[0].split(" ")[1]);
    const Q = parseInt(arg[0].split(" ")[2]);
    
    const A = arg.slice(1, Q + 1).map(n=>parseInt(n));
    let points = new Array(N).fill(0);
    
    for(let i=0; i<Q; i++) {
        points[A[i]-1]++;
    }
    
    let answer = points.map(n=>(n + K) - Q > 0 ? "Yes" : "No");

    console.log(answer.join("\n"));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input){
    input = input.split('\n');

    tmp = input[0].split(" ");
    tmp= tmp.map(Number);
    const sankasha_N = tmp[0];
    const initPoints_K = tmp[1];
    const questions_Q = tmp[2];
    input.shift();
    input= input.filter(v => v);
    input = input.map(Number);

    //メンバの持ち点配列
    var memPoints = new Array(sankasha_N).fill(initPoints_K);

    var memPointsAF = [];

   input.map((v) => {
        memPoints = memPoints.map((vv,ii) => {
        if(v == ii+1){
            return vv;
        }else{
            return vv=vv-1;
        }
    });});
    memPoints.map((v) => {
        if(0 < v){
            console.log('Yes');
        }else{
            console.log('No');
        }
    });
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
process.stdin.resume();
process.stdin.setEncoding('utf8');

var lines = []
var reader = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

reader.on('line', (line) => {
  lines.push(line);
});

reader.on('close', () => {
 var nkq = lines[0].split(' ');
 var n = Number(nkq[0]);
 var k = Number(nkq[1]);
 var q = Number(nkq[2]);
 var points = [];
 for(i=0; i<n; i++){
   points.push(k);
 }

 for(i=1; i<=q; i++){
   var num = Number(lines[i]);
   for(j=0; j<n; j++){
     if(j == num-1){
       continue;
     }
     points[j]--;
   }
 }

 for(i=0; i<n; i++){
   if(points[i] > 0){
     console.log('Yes');
   }else{
     console.log('No');
   }
 }
});
//  [javascript]
function main(arg) {
	arg = arg.trim().split('\n');
  	var data = arg[0].split(' ').map(str =>  parseInt(str, 10));
  	var n = data[0];//参加者
    var k = data[1];//pt
    var q = data[2];//正解数
  	var seikai = [];
    var ary = [];
  	var sei_long = q+1;
  	//正解者
  	for (var i = 1; i < sei_long; i ++) {
    	seikai.push(arg[i])
    }
  	//初期ポイント
    for (var i = 0; i < n; i++) {
    	ary.push(k);
    }
  	//不正解のみ減点正解者は処理をスキップ
    for (var i = 0; i < q; i++) {
      var num = seikai[i]-1;
    	for (var a = 0; a < n; a++) {
          	if (a == num){
               continue;
        	}
        	ary[a] = ary[a] -1;
        }
    }
  	//1pt以上に'yes'を返す
    for (var a = 0; a < n; a++) {
        ary[a] = (ary[a] = ary[a] > 0) ? 'Yes' : 'No';
      	console.log(ary[a]);
    } 
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func main() {
	var n, k, q int
	fmt.Scan(&n, &k, &q)

	sc := bufio.NewScanner(os.Stdin)
	ans := make([]int, n)
	for i := 0; i < q; i++ {
		sc.Scan()
		a, _ := strconv.Atoi(sc.Text())
		ans[a-1]++
	}

	wr := bufio.NewWriter(os.Stdout)
	for _, v := range ans {
		if k-(q-v) > 0 {
			wr.WriteString("Yes\n")
			continue
		}
		wr.WriteString("No\n")
	}
	wr.Flush()
}
//  [go]
package main

import (
	"bufio"
	"os"
	"strconv"
)

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	sc.Scan()
	n, _ := strconv.Atoi(sc.Text())
	sc.Scan()
	k, _ := strconv.Atoi(sc.Text())
	slice := make([]int, n)
	sc.Scan()
	q, _ := strconv.Atoi(sc.Text())
	for i := 0; i < q; i++ {
		sc.Scan()
		An, _ := strconv.Atoi(sc.Text())
		slice[An-1]++
	}

	writer := bufio.NewWriter(os.Stdout)
	for i := 0; i < n; i++ {
		if slice[i]-q <= k*(-1) {
			writer.WriteString("No\n")
		} else {
			writer.WriteString("Yes\n")
		}
	}
	writer.Flush()
}
//  [go]
package main

import (
	"bufio"
	"os"
	"strconv"
)

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)

	sc.Scan()
	N, _ := strconv.Atoi(sc.Text())

	sc.Scan()
	K, _ := strconv.Atoi(sc.Text())

	sc.Scan()
	Q, _ := strconv.Atoi(sc.Text())

	A := make([]int, Q)
	for i := 0; i < Q; i++ {
		sc.Scan()
		A[i], _ = strconv.Atoi(sc.Text())
	}

	points := make([]int, N)
	for i := 0; i < N; i++ {
		points[i] = K - Q
	}

	for _, person := range A {
		points[person-1]++
	}

	writer := bufio.NewWriter(os.Stdout)
	for _, point := range points {
		if point > 0 {
			writer.WriteString("Yes\n")
		} else {
			writer.WriteString("No\n")
		}
	}
	writer.Flush()
}
//  [go]
package main

import "fmt"

func main() {
	var n, k, q int
	fmt.Scan(&n, &k, &q)
	seq := make([]int, q)
	point := make([]int, n)
	for i:=0; i<len(point); i++{
		point[i] = k
	}

	for i:=0; i<len(seq); i++{
		fmt.Scan(&seq[i])
		for j:=0; j<len(point); j++{
			if j != seq[i]-1{
				point[j]--
			}
		}
	}

	fmt.Println("-----")
	for i:=0; i<len(point); i++{
		if point[i] >= 1{
			fmt.Println("Yes")
		}else {
			fmt.Println("No")
		}
	}


}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	N, K, Q := getStdinInt3()
	Pt := make([]int, N)
	for i := 0; i < N; i++ {
		Pt[i] = K
	}
	for i := 0; i < Q; i++ {
		A := getStdinInt()
		for n := 0; n < N; n++ {
			if n != A-1 {
				Pt[n]--
				if Pt[n] <= 0 {
					Pt[n] = -1000000
				}
			}
		}
	}
	for i := 0; i < N; i++ {
		if Pt[i] > 0 {
			fmt.Printf("Yes\n")
		} else {
			fmt.Printf("No\n")
		}
	}
}

var sc = bufio.NewReaderSize(os.Stdin, 1024*1024*10)

func getStdin() string {
	return readLine()
}
func getStdinInt() int {
	str := getStdin()
	rtn, _ := strconv.Atoi(str)
	return rtn
}
func getStdinInt2() (int, int) {
	list := getStdinIntArr()
	return list[0], list[1]
}
func getStdinInt3() (int, int, int) {
	list := getStdinIntArr()
	return list[0], list[1], list[2]
}
func getStdinInt64() int64 {
	str := getStdin()
	rtn, _ := strconv.ParseInt(str, 10, 64)
	return rtn
}
func getStdinIntU64() uint64 {
	str := getStdin()
	rtn, _ := strconv.ParseInt(str, 10, 64)
	return uint64(rtn)
}
func getStdinInt64_2() (int64, int64) {
	list := getStdinIntArr64()
	return list[0], list[1]
}
func getStdinInt64_3() (int64, int64, int64) {
	list := getStdinIntArr64()
	return list[0], list[1], list[2]
}
func getStdinIntArr() []int {
	str := getStdin()
	list := strings.Split(str, " ")
	rtn := make([]int, len(list))
	for idx, val := range list {
		rtn[idx], _ = strconv.Atoi(val)
	}
	return rtn
}
func getStdinIntArr64() []int64 {
	str := getStdin()
	list := strings.Split(str, " ")
	rtn := make([]int64, len(list))
	for idx, val := range list {
		rtn[idx], _ = strconv.ParseInt(val, 10, 64)
	}
	return rtn
}
func getStdinIntArrU64() []uint64 {
	str := getStdin()
	list := strings.Split(str, " ")
	rtn := make([]uint64, len(list))
	for idx, val := range list {
		r, _ := strconv.ParseInt(val, 10, 64)
		rtn[idx] = uint64(r)
	}
	return rtn
}
func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}
func min64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}
func max(a, b int) int {
	if a < b {
		return b
	}
	return a
}
func max64(a, b int64) int64 {
	if a < b {
		return b
	}
	return a
}
func abs(n int) int {
	if n < 0 {
		return -n
	}
	return n
}
func abs64(n int64) int64 {
	if n < 0 {
		return -n
	}
	return n
}
func readLine() string {
	buf := make([]byte, 0, 0)
	for {
		l, p, _ := sc.ReadLine()
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}
//  [go]
package main

import (
	"fmt"
)

func main() {

	var N, K, Q int
	fmt.Scanf("%d %d %d", &N, &K, &Q)

	point := make(map[int]int, N)
	for i := 0; i < N; i++ {
		point[i+1] = K
	}

	var A int
	for i := 0; i < Q; i++ {
		fmt.Scanf("%d", &A)
		for i := 0; i < N; i++ {
			point[i+1]--
		}
		point[A]++
	}

	for i := 0; i < N; i++ {
		if point[i+1] > 0 {
			fmt.Println("Yes")
		} else {
			fmt.Println("No")
		}
	}
}
//  [ruby]
n,k,q = gets.split.map(&:to_i)
a = Array.new(n,0)
q.times do
    a[gets.to_i-1] += 1
end
ans = ""
a.each {|i| 
    if k - q + i > 0
        ans << "Yes\n"
    else
        ans << "No\n"
    end
}

puts ans
//  [ruby]
n, k, q = gets.split.map(&:to_i)
p = [k - q] * n
q.times { p[gets.to_i - 1] += 1}
puts p.map { |j| j > 0 ? 'Yes' : 'No'}.join("\n")
//  [ruby]
# frozen_string_literal: true

N, K, Q = gets.split.map(&:to_i)
count = Array.new(N) { K }
Q.times { count[gets.to_i.pred] += 1 }

N.times { |i| puts count[i] - Q > 0 ? 'Yes' : 'No' }
//  [ruby]
N, K, Q = gets.split.map &:to_i
ans = Array.new(N, K)

Q.times do
  a = gets.to_i - 1
  ans.each_with_index do |e, idx|
    ans[idx] += -1 unless idx == a
  end
end

ans.each do |e|
  if e <= 0
    puts 'No'
  else
    puts 'Yes'
  end
end
//  [ruby]
n,k,q=gets.split.map(&:to_i)
a=Array.new(q)
q.times do |i|
    a[i]=gets.to_i
end

n.times do |i|
    if k-q+a.count(i+1)>0
        puts "Yes"
    else
        puts "No"
    end
end
//  [ruby]
n,k,q = gets.strip.split.map(&:to_i)
array = []
while number = gets
  array << number.chomp.to_i
end
(1..n).each do |x|
  if k-q+array.count(x)>0
    puts "Yes"
  else
    puts "No"
  end
end
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

use std::io::{stdout, Write, BufWriter};
// use std::cmp::{max};

fn main() {
    input! {
        n: usize,
        k: u32,
        q: usize,
        a: [usize; q],
    }

    let out = stdout();
    let mut out = BufWriter::new(out.lock());

    let mut t: Vec<u32> = vec![0; n];
    for a_ in a { t[a_ - 1] += 1 }
    for i in t {
        if i + k > q as u32 { writeln!(out, "Yes").unwrap(); }
        else { writeln!(out,"No").unwrap(); }
    }
}
//  [rust]
// Template from https://techracho.bpsinc.jp/jhonda/2019_08_05/78537

// input macro for competive-programming from https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };

    ($iter:expr, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($next:expr, [ $t:tt ]) => {
        {
            let len = read_value!($next, usize);
            (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
        }
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, bytes) => {
        read_value!($iter, String).into_bytes()
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    use std::io::Read;
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();

    println!("{}", solve(&s));
}

macro_rules! test {
    ($($input:expr => $output:expr),* $(,)*) => {
        #[test]
        fn solve_test() {
            $(
                assert_eq!(solve($input), $output);
            )*
        }
    };
}

test! {
r#"6 3 4
3
1
3
2"# => r#"No
No
Yes
No
No
No
"#,
}

fn solve(src: &str) -> String {
    input! {
        source = src,
        n: usize, k: usize, q: usize,
        a: [usize; q],
    }
    let mut pa = vec![k; n];

    for i in 0..q {
        pa[a[i] - 1] += 1;
    }

    let mut ans = "".to_string();
    for i in 0..n {
        ans.push_str(if pa[i] > q { "Yes" } else { "No" });
        ans.push_str("\n");
    }

    ans.to_string()
}
//  [rust]
use proconio::{fastout, input};
use std::collections::BTreeMap;

#[fastout]
fn main() {
    input! {
        n: usize,
        k: i64,
        q: usize,
        a: [i64; q]
    };

    let a: Vec<i64> = a.iter().map(|x| x - 1).collect();
    let mut v: Vec<i64> = vec![k; n];
    let mut map = BTreeMap::new();

    for i in a.iter() {
        let count = map.entry(i).or_insert(0);
        *count += 1;
    }

    for (&key, value) in &map {
        v = v.iter().map(|x| x - value).collect();
        v[*key as usize] += *value as i64;
    }

    for &i in v.iter() {
        if i <= 0 {
            println!("No");
        } else {
            println!("Yes");
        }
    }

    // for i in 0..n as usize {
    //     let x = a.iter().filter(|&x| *x == i as i64).count();
    //     if k - (q as i64 - x as i64) > 0 {
    //         println!("Yes");
    //     } else {
    //         println!("No");
    //     }
    // }
}
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        n: usize,
        k: i64,
        q: usize,
        a: [i64; q]
    };

    let a: Vec<i64> = a.iter().map(|x| x - 1).collect();
    let mut v: Vec<i64> = vec![k; n];

    for &i in a.iter() {
        v = v.iter().map(|x| x - 1).collect();
        v[i as usize] += 1;
    }

    for &i in v.iter() {
        if i <= 0 {
            println!("No")
        } else {
            println!("Yes")
        }
    }

    // for i in 0..n as usize {
    //     let x = a.iter().filter(|&x| *x == i as i64).count();
    //     if k - (q as i64 - x as i64) > 0 {
    //         println!("Yes");
    //     } else {
    //         println!("No");
    //     }
    // }
}
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        n: i64,
        k: i64,
        q: usize,
        a: [i64; q]
    };

    let a: Vec<i64> = a.iter().map(|x| x - 1).collect();

    for i in 0..n as usize {
        let x = a.iter().filter(|&x| *x == i as i64).count();
        if k - (q as i64 - x as i64) > 0 {
            println!("Yes");
        } else {
            println!("No");
        }
    }
}
//  [swift]
// 🐋💭
import Foundation

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func readInt() -> Int {
    return Int(readLine()!)!
}

///最大公約数を返す
func gcd(_ m:Int, _ n:Int) -> Int {
    if n == 0 {return m}
    return gcd(n, m % n)
}

///素数判定(試し割り)
func isPrime(_ x:Int) -> Bool {
    if x <= 1 || x % 2 == 0 { return false }
    if x == 2 { return true }
    for i in stride(from: 3, to: Int(ceil(sqrt(Double(x)))), by: 2){
        if x % i == 0 {
            return false
        }
    }
    return true
}

//https://program-life.com/669
///実行速度の計測
func exectionTime(action: () -> Void) {
    let startDate = Date()
    action()
    let endDate = Date()
    print(endDate.timeIntervalSince(startDate))
}

// https://melheaven.hatenadiary.jp/entry/atcoder144
///約数の配列を返す
func makeDivisors(_ n:Int) -> [Int] {
    var divisors = [Int]()
    for i in 1..<Int(pow(Double(n), 0.5)) + 1 {
        if n % i == 0{
            divisors.append(i + n / i)
        }
    }
    
    return divisors
}

//https://riptutorial.com/ja/swift/example/14738/インデックスを知らずに配列から要素を削除する
extension Array where Element: Equatable {
    
    mutating func remove(_ element: Element) {
        _ = index(of: element).flatMap {
            self.remove(at: $0)
        }
    }
}

func binarySearch(rifgt:Int, key:Int, ary:[String]) -> Int{
    var left = 0
    var right = rifgt
    
    while abs(right - left) > 1 {
        let mid = left + (right - left) / 2
        
        if Int(ary[mid])! < key {
            left = mid
            
        } else {
            right = mid
        }
    }
    return left
}

func arrangement (prev:String, ary:[String], returnVal:[String]) -> [String] {
    var returnVal = returnVal
    if ary.count == 0 {
        returnVal.append(prev)
        return returnVal
    }
    
    for s in ary {
        let wprev = prev + s
        var wary = ary
        wary.remove(s)
        returnVal = arrangement(prev: wprev, ary: wary, returnVal: returnVal)
    }
    return returnVal
}

func main() {
    let nkq = readInts()
    let (n, k, q) = (nkq[0], nkq[1], nkq[2])
    
    var aryPoints = [Int](repeating: k - q, count: n)
    
    for _ in 1...q {
        aryPoints[readInt() - 1] += 1
    }
    
    for i in aryPoints {
        print(i > 0 ? "Yes": "No")
    }
}

main()
//  [swift]
var X = readLine()!.characters.split{$0==" "}.map{Int(String($0))!}

var N = X[0]
var K = X[1]
var Q = X[2]
var A = [Int]()
for _ in 0..<N {
    A.append(K - Q)
}

for _ in 0..<Q {
    let n: Int = Int(readLine()!)!
    A[n-1] += 1
}

for i in 0..<N {
    if A[i] > 0 {
        print("Yes")
    }else {
        print("No")
    }
}
//  [swift]
var arr=readLine()!.characters.split{$0==" "}.map{Int(String($0))!}

var n = arr[0]
var k = arr[1]
var q = arr[2]

var p = Array(count: n, repeatedValue: 0 )

var i = 0
var a = 0
for i in 0..<q {
  a=Int(readLine()!)!
  p[a-1] += 1
}

i = 0
for i in 0..<n {
  if( ( k - q + p[i] ) > 0) {
    print( "Yes" )
  } else {
    print( "No" )
  }
}
//  [swift]
// 🐋💭
import Foundation

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func readInt() -> Int {
    return Int(readLine()!)!
}

///最大公約数を返す
func gcd(_ m:Int, _ n:Int) -> Int {
    if n == 0 {return m}
    return gcd(n, m % n)
}

///素数判定(試し割り)
func isPrime(_ x:Int) -> Bool {
    if x <= 1 || x % 2 == 0 { return false }
    if x == 2 { return true }
    for i in stride(from: 3, to: Int(ceil(sqrt(Double(x)))), by: 2){
        if x % i == 0 {
            return false
        }
    }
    return true
}

//https://program-life.com/669
///実行速度の計測
func exectionTime(action: () -> Void) {
    let startDate = Date()
    action()
    let endDate = Date()
    print(endDate.timeIntervalSince(startDate))
}

// https://melheaven.hatenadiary.jp/entry/atcoder144
///約数の配列を返す
func makeDivisors(_ n:Int) -> [Int] {
    var divisors = [Int]()
    for i in 1..<Int(pow(Double(n), 0.5)) + 1 {
        if n % i == 0{
            divisors.append(i + n / i)
        }
    }
    
    return divisors
}

//https://riptutorial.com/ja/swift/example/14738/インデックスを知らずに配列から要素を削除する
extension Array where Element: Equatable {
    
    mutating func remove(_ element: Element) {
        _ = index(of: element).flatMap {
            self.remove(at: $0)
        }
    }
}

func binarySearch(rifgt:Int, key:Int, ary:[String]) -> Int{
    var left = 0
    var right = rifgt
    
    while abs(right - left) > 1 {
        let mid = left + (right - left) / 2
        
        if Int(ary[mid])! < key {
            left = mid
            
        } else {
            right = mid
        }
    }
    return left
}

func arrangement (prev:String, ary:[String], returnVal:[String]) -> [String] {
    var returnVal = returnVal
    if ary.count == 0 {
        returnVal.append(prev)
        return returnVal
    }
    
    for s in ary {
        let wprev = prev + s
        var wary = ary
        wary.remove(s)
        returnVal = arrangement(prev: wprev, ary: wary, returnVal: returnVal)
    }
    return returnVal
}

func main() {
    let nkq = readInts()
    let (n, k, q) = (nkq[0], nkq[1], nkq[2])
    
    var aryPoints = [Int](repeating: k, count: n)
    for _ in 1...q {
        let answer = readInt()
        for i in 0..<n {
            if i + 1 != answer {
                aryPoints[i] -= 1
            }
        }
    }
    for i in 0..<n {
        print(aryPoints[i] > 0 ? "Yes": "No")
    }
}

main()