stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<cstdio>

#include<iostream>

#include<algorithm>

#include<cstring>

#include<string>

using namespace std;

typedef long long ll;

const int maxn=1e5+100;

int main()

{

	ll n,k,q;

	ll x;

	ll a[maxn];

	memset(a,0,sizeof(a));

	scanf("%lld%lld%lld",&n,&k,&q);

	for(int i=0;i<q;i++)

	{

		scanf("%d",&x);

		a[x]++;

	}

	for(int i=1;i<=n;i++)

	{

		if(a[i]+k-q>0)

			printf("Yes");

		else

			printf("No");

		if(i!=n)

			printf("\n");

//		printf("%d ",a[i]+k-q);

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.781726530539078x):
#include<bits/stdc++.h>

#include<iostream>

#include<cmath>

#define rep(i,a,b) for(int i=a;i<=b;i++)

typedef long long ll;

using namespace std;

const int inf=0x3f3f3f3f;

const ll INF=0x3f3f3f3f3f3f3f3f;

const int N=1e5+10;

void io(){

	ios::sync_with_stdio(0);

	cin.tie(0);

	cout.tie(0);

}

ll a[N];

int main()

{

	io();

	ll n,k,q,b;cin>>n>>k>>q;

	for(int i=0;i<q;i++){

		cin>>b;

		a[b]++;

	}

	for(int i=1;i<=n;i++){

		if(a[i]+k-q<=0)puts("No");

		else puts("Yes");

	}

	return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#include<stdlib.h>

#include<string.h>

#include<cmath>

using namespace std;

typedef long long ll;

#define N 100005

int main()

{

    int n,m,i,j,k,l;

    int T,unit;

    int x,z,y,x1,y1;

    int ans1=0,ans2=0;

    int n1,n2;

    int a[100005]={0};

    scanf("%d%d%d",&n,&m,&T);

    for(i=0;i<T;i++)

    {

        scanf("%d",&x);

        a[x]++;

    }

    for(i=1;i<=n;i++)

    {

        if(m<=T-a[i])

            printf("No\n");

        else

            printf("Yes\n");

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.3172769356541045x):
#include<bits/stdc++.h>

using namespace std;

const int maxn = 3e5+10;

int main()

{

	long long n,k,q;

	cin >> n >> k >> q;

	long long a[maxn];

	for(int i = 1;i <= q;i ++){

		int x;

		cin >> x;

		a[x]++;

	}

/*	for(int i = 1;i <= q;i ++){

		cout << a[i];

	}cout << endl;*/

	for(int i = 1;i <= n;i ++){

		if( k-(q-a[i]) <= 0) cout << "No" << endl;

		else cout << "Yes" << endl;

	}

	return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<iostream>

#include<algorithm>

#include<cstring>

#include<string>

using namespace std;

typedef long long ll;

const int maxn=1e5+100;

int main()

{

	ll n,k,q;

	ll x;

	ll a[maxn];

	memset(a,0,sizeof(a));

	scanf("%lld%lld%lld",&n,&k,&q);

	for(int i=0;i<q;i++)

	{

		scanf("%d",&x);

		a[x]++;

	}

	for(int i=1;i<=n;i++)

	{

		if(a[i]+k-q>0)

			printf("Yes");

		else

			printf("No");

		if(i!=n)

			printf("\n");

//		printf("%d ",a[i]+k-q);

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.7014962746787647x):
#include<bits/stdc++.h>

using namespace std;

const int maxn = 3e5+10;

int main()

{

	long long n,k,q;

	cin >> n >> k >> q;

	long long a[maxn];

	for(int i = 1;i <= q;i ++){

		int x;

		cin >> x;

		a[x]++;

	}

/*	for(int i = 1;i <= q;i ++){

		cout << a[i];

	}cout << endl;*/

	for(int i = 1;i <= n;i ++){

		if( k-(q-a[i]) <= 0) cout << "No" << endl;

		else cout << "Yes" << endl;

	}

	return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#include<stdlib.h>

#include<string.h>

#include<cmath>

using namespace std;

typedef long long ll;

#define N 100005

int main()

{

    int n,m,i,j,k,l;

    int T,unit;

    int x,z,y,x1,y1;

    int ans1=0,ans2=0;

    int n1,n2;

    int a[100005]={0};

    scanf("%d%d%d",&n,&m,&T);

    for(i=0;i<T;i++)

    {

        scanf("%d",&x);

        a[x]++;

    }

    for(i=1;i<=n;i++)

    {

        if(m<=T-a[i])

            printf("No\n");

        else

            printf("Yes\n");

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.3872434438163819x):
#include<iostream>

#include<stdio.h>

using namespace std;

typedef long long ll;

ll  a[1111111];

int main()

{

	ll n,k,q,x;

	cin>>n>>k>>q;

	for(int i =0;i<n;++i)

	{

		a[i] = k;

	 } 

	 

	 for(ll i =0;i<q;++i)

	 {

	 	

	 	scanf("%lld",&x);

	 	a[x-1]++;

	 }

	 

	 for(ll i=0;i<n;++i)

	 {

	 	if(a[i]-q>0)

	 		cout<<"Yes"<<endl;

	 	else	

		 	cout<<"No"<<endl; 

	 }

	 return 0;

 }
// Slower C++ solution:
#include<cstdio>

#include<iostream>

#include<algorithm>

#include<cstring>

#include<string>

using namespace std;

typedef long long ll;

const int maxn=1e5+100;

int main()

{

	ll n,k,q;

	ll x;

	ll a[maxn];

	memset(a,0,sizeof(a));

	scanf("%lld%lld%lld",&n,&k,&q);

	for(int i=0;i<q;i++)

	{

		scanf("%d",&x);

		a[x]++;

	}

	for(int i=1;i<=n;i++)

	{

		if(a[i]+k-q>0)

			printf("Yes");

		else

			printf("No");

		if(i!=n)

			printf("\n");

//		printf("%d ",a[i]+k-q);

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.7918704016130391x):
#include<iostream>

#include<stdio.h>

using namespace std;

typedef long long ll;

ll  a[1111111];

int main()

{

	ll n,k,q,x;

	cin>>n>>k>>q;

	for(int i =0;i<n;++i)

	{

		a[i] = k;

	 } 

	 

	 for(ll i =0;i<q;++i)

	 {

	 	

	 	scanf("%lld",&x);

	 	a[x-1]++;

	 }

	 

	 for(ll i=0;i<n;++i)

	 {

	 	if(a[i]-q>0)

	 		cout<<"Yes"<<endl;

	 	else	

		 	cout<<"No"<<endl; 

	 }

	 return 0;

 }
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int maxn=2e5+6;

int main()

{

	int n,k,q,a,vis[maxn],flag[maxn];

	scanf("%d%d%d",&n,&k,&q);

	memset(vis,0,sizeof(vis));

	memset(flag,0,sizeof(flag));

	for(int i=1;i<=q;i++)

	{

		scanf("%d",&a);

		vis[a]++;

	}

	for(int j=1;j<=n;j++)

	{

		if(q-vis[j]<k)

		{

			flag[j]=1;

		}

		else

		{

			flag[j]=0;

		}

	}

	for(int i=1;i<=n;i++)

	{

		if(flag[i]==1)

		{

			printf("Yes\n");

		}

		else

		{

			printf("No\n");

		}

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.600935732139805x):
#include<iostream>

#include<stdio.h>

using namespace std;

typedef long long ll;

ll  a[1111111];

int main()

{

	ll n,k,q,x;

	cin>>n>>k>>q;

	for(int i =0;i<n;++i)

	{

		a[i] = k;

	 } 

	 

	 for(ll i =0;i<q;++i)

	 {

	 	

	 	scanf("%lld",&x);

	 	a[x-1]++;

	 }

	 

	 for(ll i=0;i<n;++i)

	 {

	 	if(a[i]-q>0)

	 		cout<<"Yes"<<endl;

	 	else	

		 	cout<<"No"<<endl; 

	 }

	 return 0;

 }
// Slower C++ solution:
#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#include<stdlib.h>

#include<string.h>

#include<cmath>

using namespace std;

typedef long long ll;

#define N 100005

int main()

{

    int n,m,i,j,k,l;

    int T,unit;

    int x,z,y,x1,y1;

    int ans1=0,ans2=0;

    int n1,n2;

    int a[100005]={0};

    scanf("%d%d%d",&n,&m,&T);

    for(i=0;i<T;i++)

    {

        scanf("%d",&x);

        a[x]++;

    }

    for(i=1;i<=n;i++)

    {

        if(m<=T-a[i])

            printf("No\n");

        else

            printf("Yes\n");

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.3741726355412065x):
#include<bits/stdc++.h>

using namespace std;

#define all(v) ((v).begin()),((v).end())

#define ll long long

#define fastIO cout << fixed << setprecision(12), ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr)

double const EPS = 1e-12, PI = acos(-1);

const int N = 1e5 + 9, M = 5e3 + 9, OO = 1e9 + 7, MOD = 1e9 + 7;

const ll inf = 1e18;



int n, k, m;

ll tree[4*N], lazy[4*N];



void propagate(int node, int start, int end) {

  if(!lazy[node])

    return;

  tree[node] += lazy[node] * (end - start + 1);

  if(start != end) {

    lazy[node * 2] += lazy[node];

    lazy[node * 2 + 1] += lazy[node];

  }

  lazy[node] = 0;

}



void build(int node, int start, int end) {

  if(start == end) {

    tree[node] = k;

    return;

  }

  int mid = (start + end) / 2;

  build(node * 2, start, mid);

  build(node * 2 + 1, mid + 1, end);

  tree[node] = tree[node * 2] + tree[node * 2 + 1];

}



ll query(int node, int start, int end, int idx) {

  propagate(node, start, end);

  if(start == end)

    return tree[node];

  int mid = (start + end) / 2;

  if(idx <= mid)

    return query(node * 2, start, mid, idx);

  else

    return query(node * 2 + 1, mid + 1, end, idx);

}



void update(int node, int start, int end, int l, int r, int val) {

  propagate(node, start, end);

  if(start > r || end < l)

    return;

  if(start >= l && end <= r) {

    lazy[node] = val;

    propagate(node, start, end);

    return;

  }

  int mid = (start + end) / 2;

  update(node * 2, start, mid, l, r, val);

  update(node * 2 + 1, mid + 1, end, l, r, val);

  tree[node] = tree[node * 2] + tree[node * 2 + 1];

}



int main() {

  fastIO;

#ifdef LOCAL

  freopen("input.in", "rt", stdin);

#endif

  cin >> n >> k >> m;

  build(1, 1, n);

  int a;

  for (int i = 0; i < m; ++i) {

    cin >> a;

    update(1, 1, n, 1, n, -1);

    update(1, 1, n, a, a, 1);

  }

  for (int i = 1; i <= n; ++i) {

    int val = query(1, 1, n, i);

//    cerr << val << endl;

    if(val > 0) {

      cout << "Yes\n";

    } else {

      cout << "No\n";

    }

  }

  return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<iostream>

#include<algorithm>

#include<cstring>

#include<string>

using namespace std;

typedef long long ll;

const int maxn=1e5+100;

int main()

{

	ll n,k,q;

	ll x;

	ll a[maxn];

	memset(a,0,sizeof(a));

	scanf("%lld%lld%lld",&n,&k,&q);

	for(int i=0;i<q;i++)

	{

		scanf("%d",&x);

		a[x]++;

	}

	for(int i=1;i<=n;i++)

	{

		if(a[i]+k-q>0)

			printf("Yes");

		else

			printf("No");

		if(i!=n)

			printf("\n");

//		printf("%d ",a[i]+k-q);

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.7749871396464065x):
#include<bits/stdc++.h>

using namespace std;

#define all(v) ((v).begin()),((v).end())

#define ll long long

#define fastIO cout << fixed << setprecision(12), ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr)

double const EPS = 1e-12, PI = acos(-1);

const int N = 1e5 + 9, M = 5e3 + 9, OO = 1e9 + 7, MOD = 1e9 + 7;

const ll inf = 1e18;



int n, k, m;

ll tree[4*N], lazy[4*N];



void propagate(int node, int start, int end) {

  if(!lazy[node])

    return;

  tree[node] += lazy[node] * (end - start + 1);

  if(start != end) {

    lazy[node * 2] += lazy[node];

    lazy[node * 2 + 1] += lazy[node];

  }

  lazy[node] = 0;

}



void build(int node, int start, int end) {

  if(start == end) {

    tree[node] = k;

    return;

  }

  int mid = (start + end) / 2;

  build(node * 2, start, mid);

  build(node * 2 + 1, mid + 1, end);

  tree[node] = tree[node * 2] + tree[node * 2 + 1];

}



ll query(int node, int start, int end, int idx) {

  propagate(node, start, end);

  if(start == end)

    return tree[node];

  int mid = (start + end) / 2;

  if(idx <= mid)

    return query(node * 2, start, mid, idx);

  else

    return query(node * 2 + 1, mid + 1, end, idx);

}



void update(int node, int start, int end, int l, int r, int val) {

  propagate(node, start, end);

  if(start > r || end < l)

    return;

  if(start >= l && end <= r) {

    lazy[node] = val;

    propagate(node, start, end);

    return;

  }

  int mid = (start + end) / 2;

  update(node * 2, start, mid, l, r, val);

  update(node * 2 + 1, mid + 1, end, l, r, val);

  tree[node] = tree[node * 2] + tree[node * 2 + 1];

}



int main() {

  fastIO;

#ifdef LOCAL

  freopen("input.in", "rt", stdin);

#endif

  cin >> n >> k >> m;

  build(1, 1, n);

  int a;

  for (int i = 0; i < m; ++i) {

    cin >> a;

    update(1, 1, n, 1, n, -1);

    update(1, 1, n, a, a, 1);

  }

  for (int i = 1; i <= n; ++i) {

    int val = query(1, 1, n, i);

//    cerr << val << endl;

    if(val > 0) {

      cout << "Yes\n";

    } else {

      cout << "No\n";

    }

  }

  return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int maxn=2e5+6;

int main()

{

	int n,k,q,a,vis[maxn],flag[maxn];

	scanf("%d%d%d",&n,&k,&q);

	memset(vis,0,sizeof(vis));

	memset(flag,0,sizeof(flag));

	for(int i=1;i<=q;i++)

	{

		scanf("%d",&a);

		vis[a]++;

	}

	for(int j=1;j<=n;j++)

	{

		if(q-vis[j]<k)

		{

			flag[j]=1;

		}

		else

		{

			flag[j]=0;

		}

	}

	for(int i=1;i<=n;i++)

	{

		if(flag[i]==1)

		{

			printf("Yes\n");

		}

		else

		{

			printf("No\n");

		}

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.5764293396660176x):
#include<bits/stdc++.h>

using namespace std;

#define all(v) ((v).begin()),((v).end())

#define ll long long

#define fastIO cout << fixed << setprecision(12), ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr)

double const EPS = 1e-12, PI = acos(-1);

const int N = 1e5 + 9, M = 5e3 + 9, OO = 1e9 + 7, MOD = 1e9 + 7;

const ll inf = 1e18;



int n, k, m;

ll tree[4*N], lazy[4*N];



void propagate(int node, int start, int end) {

  if(!lazy[node])

    return;

  tree[node] += lazy[node] * (end - start + 1);

  if(start != end) {

    lazy[node * 2] += lazy[node];

    lazy[node * 2 + 1] += lazy[node];

  }

  lazy[node] = 0;

}



void build(int node, int start, int end) {

  if(start == end) {

    tree[node] = k;

    return;

  }

  int mid = (start + end) / 2;

  build(node * 2, start, mid);

  build(node * 2 + 1, mid + 1, end);

  tree[node] = tree[node * 2] + tree[node * 2 + 1];

}



ll query(int node, int start, int end, int idx) {

  propagate(node, start, end);

  if(start == end)

    return tree[node];

  int mid = (start + end) / 2;

  if(idx <= mid)

    return query(node * 2, start, mid, idx);

  else

    return query(node * 2 + 1, mid + 1, end, idx);

}



void update(int node, int start, int end, int l, int r, int val) {

  propagate(node, start, end);

  if(start > r || end < l)

    return;

  if(start >= l && end <= r) {

    lazy[node] = val;

    propagate(node, start, end);

    return;

  }

  int mid = (start + end) / 2;

  update(node * 2, start, mid, l, r, val);

  update(node * 2 + 1, mid + 1, end, l, r, val);

  tree[node] = tree[node * 2] + tree[node * 2 + 1];

}



int main() {

  fastIO;

#ifdef LOCAL

  freopen("input.in", "rt", stdin);

#endif

  cin >> n >> k >> m;

  build(1, 1, n);

  int a;

  for (int i = 0; i < m; ++i) {

    cin >> a;

    update(1, 1, n, 1, n, -1);

    update(1, 1, n, a, a, 1);

  }

  for (int i = 1; i <= n; ++i) {

    int val = query(1, 1, n, i);

//    cerr << val << endl;

    if(val > 0) {

      cout << "Yes\n";

    } else {

      cout << "No\n";

    }

  }

  return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#include<stdlib.h>

#include<string.h>

#include<cmath>

using namespace std;

typedef long long ll;

#define N 100005

int main()

{

    int n,m,i,j,k,l;

    int T,unit;

    int x,z,y,x1,y1;

    int ans1=0,ans2=0;

    int n1,n2;

    int a[100005]={0};

    scanf("%d%d%d",&n,&m,&T);

    for(i=0;i<T;i++)

    {

        scanf("%d",&x);

        a[x]++;

    }

    for(i=1;i<=n;i++)

    {

        if(m<=T-a[i])

            printf("No\n");

        else

            printf("Yes\n");

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.394509910619351x):
/**

*   @Author : MeGA

*   @InitTime :01/24/20 12:32:13

*   @Idea : 

*

*

*

*

*

*

*

**/

#include <bits/stdc++.h>

using namespace std;

int main(){

#ifndef ONLINE_JUDGE

  // freopen("in","r",stdin);

  // freopen("out","w",stdout);

#endif

       int n,k,q;

       scanf("%d %d %d",&n,&k,&q);

       vector<int>v(n+1);

       long long maxx=0;

       for(int i=0;i<q;i++){

           int a;

           scanf("%d",&a);

           v[a]++;

       }

       for(int i=1;i<=n;i++){

            if(1ll*k-q+v[i] <= 0){

                printf("No\n");

            }else{

               printf("Yes\n");

            }

            

       }







}
// Slower C++ solution:
#include<cstdio>

#include<iostream>

#include<algorithm>

#include<cstring>

#include<string>

using namespace std;

typedef long long ll;

const int maxn=1e5+100;

int main()

{

	ll n,k,q;

	ll x;

	ll a[maxn];

	memset(a,0,sizeof(a));

	scanf("%lld%lld%lld",&n,&k,&q);

	for(int i=0;i<q;i++)

	{

		scanf("%d",&x);

		a[x]++;

	}

	for(int i=1;i<=n;i++)

	{

		if(a[i]+k-q>0)

			printf("Yes");

		else

			printf("No");

		if(i!=n)

			printf("\n");

//		printf("%d ",a[i]+k-q);

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.8012563294014048x):
/**

*   @Author : MeGA

*   @InitTime :01/24/20 12:32:13

*   @Idea : 

*

*

*

*

*

*

*

**/

#include <bits/stdc++.h>

using namespace std;

int main(){

#ifndef ONLINE_JUDGE

  // freopen("in","r",stdin);

  // freopen("out","w",stdout);

#endif

       int n,k,q;

       scanf("%d %d %d",&n,&k,&q);

       vector<int>v(n+1);

       long long maxx=0;

       for(int i=0;i<q;i++){

           int a;

           scanf("%d",&a);

           v[a]++;

       }

       for(int i=1;i<=n;i++){

            if(1ll*k-q+v[i] <= 0){

                printf("No\n");

            }else{

               printf("Yes\n");

            }

            

       }







}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int maxn=2e5+6;

int main()

{

	int n,k,q,a,vis[maxn],flag[maxn];

	scanf("%d%d%d",&n,&k,&q);

	memset(vis,0,sizeof(vis));

	memset(flag,0,sizeof(flag));

	for(int i=1;i<=q;i++)

	{

		scanf("%d",&a);

		vis[a]++;

	}

	for(int j=1;j<=n;j++)

	{

		if(q-vis[j]<k)

		{

			flag[j]=1;

		}

		else

		{

			flag[j]=0;

		}

	}

	for(int i=1;i<=n;i++)

	{

		if(flag[i]==1)

		{

			printf("Yes\n");

		}

		else

		{

			printf("No\n");

		}

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.614559594078742x):
/**

*   @Author : MeGA

*   @InitTime :01/24/20 12:32:13

*   @Idea : 

*

*

*

*

*

*

*

**/

#include <bits/stdc++.h>

using namespace std;

int main(){

#ifndef ONLINE_JUDGE

  // freopen("in","r",stdin);

  // freopen("out","w",stdout);

#endif

       int n,k,q;

       scanf("%d %d %d",&n,&k,&q);

       vector<int>v(n+1);

       long long maxx=0;

       for(int i=0;i<q;i++){

           int a;

           scanf("%d",&a);

           v[a]++;

       }

       for(int i=1;i<=n;i++){

            if(1ll*k-q+v[i] <= 0){

                printf("No\n");

            }else{

               printf("Yes\n");

            }

            

       }







}
// Slower C++ solution:
#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#include<stdlib.h>

#include<string.h>

#include<cmath>

using namespace std;

typedef long long ll;

#define N 100005

int main()

{

    int n,m,i,j,k,l;

    int T,unit;

    int x,z,y,x1,y1;

    int ans1=0,ans2=0;

    int n1,n2;

    int a[100005]={0};

    scanf("%d%d%d",&n,&m,&T);

    for(i=0;i<T;i++)

    {

        scanf("%d",&x);

        a[x]++;

    }

    for(i=1;i<=n;i++)

    {

        if(m<=T-a[i])

            printf("No\n");

        else

            printf("Yes\n");

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.3862193810724117x):
#include<bits/stdc++.h>

using namespace std;

main(){

int i,j,k,l,n,m;

while(cin>>l>>m>>n){

int x[l+1]={0};j=0;k=0;

for(i=0;i<n;i++){

    cin>>j;

    x[j]++;

}

for(i=1;i<=l;i++){

        n-=x[i];

    if(m>n) cout<<"Yes"<<endl;

    else cout<<"No"<<endl;

n+=x[i];

}

} return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<iostream>

#include<algorithm>

#include<cstring>

#include<string>

using namespace std;

typedef long long ll;

const int maxn=1e5+100;

int main()

{

	ll n,k,q;

	ll x;

	ll a[maxn];

	memset(a,0,sizeof(a));

	scanf("%lld%lld%lld",&n,&k,&q);

	for(int i=0;i<q;i++)

	{

		scanf("%d",&x);

		a[x]++;

	}

	for(int i=1;i<=n;i++)

	{

		if(a[i]+k-q>0)

			printf("Yes");

		else

			printf("No");

		if(i!=n)

			printf("\n");

//		printf("%d ",a[i]+k-q);

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.7905476433556518x):
#include<bits/stdc++.h>

using namespace std;

main(){

int i,j,k,l,n,m;

while(cin>>l>>m>>n){

int x[l+1]={0};j=0;k=0;

for(i=0;i<n;i++){

    cin>>j;

    x[j]++;

}

for(i=1;i<=l;i++){

        n-=x[i];

    if(m>n) cout<<"Yes"<<endl;

    else cout<<"No"<<endl;

n+=x[i];

}

} return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int maxn=2e5+6;

int main()

{

	int n,k,q,a,vis[maxn],flag[maxn];

	scanf("%d%d%d",&n,&k,&q);

	memset(vis,0,sizeof(vis));

	memset(flag,0,sizeof(flag));

	for(int i=1;i<=q;i++)

	{

		scanf("%d",&a);

		vis[a]++;

	}

	for(int j=1;j<=n;j++)

	{

		if(q-vis[j]<k)

		{

			flag[j]=1;

		}

		else

		{

			flag[j]=0;

		}

	}

	for(int i=1;i<=n;i++)

	{

		if(flag[i]==1)

		{

			printf("Yes\n");

		}

		else

		{

			printf("No\n");

		}

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.599015722069029x):
#include<bits/stdc++.h>

using namespace std;

main(){

int i,j,k,l,n,m;

while(cin>>l>>m>>n){

int x[l+1]={0};j=0;k=0;

for(i=0;i<n;i++){

    cin>>j;

    x[j]++;

}

for(i=1;i<=l;i++){

        n-=x[i];

    if(m>n) cout<<"Yes"<<endl;

    else cout<<"No"<<endl;

n+=x[i];

}

} return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#include<stdlib.h>

#include<string.h>

#include<cmath>

using namespace std;

typedef long long ll;

#define N 100005

int main()

{

    int n,m,i,j,k,l;

    int T,unit;

    int x,z,y,x1,y1;

    int ans1=0,ans2=0;

    int n1,n2;

    int a[100005]={0};

    scanf("%d%d%d",&n,&m,&T);

    for(i=0;i<T;i++)

    {

        scanf("%d",&x);

        a[x]++;

    }

    for(i=1;i<=n;i++)

    {

        if(m<=T-a[i])

            printf("No\n");

        else

            printf("Yes\n");

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.3747526630713531x):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

int main()

{



string s,ss,x;

 ll a,b,i,j,l=0,k=0,d,c;

map<ll,ll>m;

cin>>a>>b>>c;

for(i=1;i<=c;i++)

{

cin>>d;m[d]++;

}

for(i=1;i<=a;i++)

{

if((b-c+m[i])>0)

{

cout<<"Yes\n";

}

else

{cout<<"No\n";}

}



}
// Slower C++ solution:
#include<cstdio>

#include<iostream>

#include<algorithm>

#include<cstring>

#include<string>

using namespace std;

typedef long long ll;

const int maxn=1e5+100;

int main()

{

	ll n,k,q;

	ll x;

	ll a[maxn];

	memset(a,0,sizeof(a));

	scanf("%lld%lld%lld",&n,&k,&q);

	for(int i=0;i<q;i++)

	{

		scanf("%d",&x);

		a[x]++;

	}

	for(int i=1;i<=n;i++)

	{

		if(a[i]+k-q>0)

			printf("Yes");

		else

			printf("No");

		if(i!=n)

			printf("\n");

//		printf("%d ",a[i]+k-q);

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.775736347846325x):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

int main()

{



string s,ss,x;

 ll a,b,i,j,l=0,k=0,d,c;

map<ll,ll>m;

cin>>a>>b>>c;

for(i=1;i<=c;i++)

{

cin>>d;m[d]++;

}

for(i=1;i<=a;i++)

{

if((b-c+m[i])>0)

{

cout<<"Yes\n";

}

else

{cout<<"No\n";}

}



}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int maxn=2e5+6;

int main()

{

	int n,k,q,a,vis[maxn],flag[maxn];

	scanf("%d%d%d",&n,&k,&q);

	memset(vis,0,sizeof(vis));

	memset(flag,0,sizeof(flag));

	for(int i=1;i<=q;i++)

	{

		scanf("%d",&a);

		vis[a]++;

	}

	for(int j=1;j<=n;j++)

	{

		if(q-vis[j]<k)

		{

			flag[j]=1;

		}

		else

		{

			flag[j]=0;

		}

	}

	for(int i=1;i<=n;i++)

	{

		if(flag[i]==1)

		{

			printf("Yes\n");

		}

		else

		{

			printf("No\n");

		}

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.5775168303552025x):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

int main()

{



string s,ss,x;

 ll a,b,i,j,l=0,k=0,d,c;

map<ll,ll>m;

cin>>a>>b>>c;

for(i=1;i<=c;i++)

{

cin>>d;m[d]++;

}

for(i=1;i<=a;i++)

{

if((b-c+m[i])>0)

{

cout<<"Yes\n";

}

else

{cout<<"No\n";}

}



}