#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template <class T> ll size(const T &x) { return x.size(); }
#define rep(i,a,b) for(ll i = (a); i < (b); ++i)
#define iter(it,c) for(__typeof((c).begin()) it = (c).begin(); it != (c).end();++it)
#define MOD 1000000007
#define pb push_back
#define fs first
#define sc second
typedef pair<ll,ll> ii;
typedef vector<ll> vi;
typedef vector<ii> vii;

const int INF = 2147493647;
const double pi = acos(-1);
const double EPS = 1e-9;

/*vi cnt(64,0);
ll mem[64][2];
ll dp(long long at, bool contr){
    if(at == 64){
        return 0;
    }
    if(mem[at][contr] != -1) return mem[at][contr];
    ll mx = 0;
    if((cnt[at]+contr) % 2){
        mx = max(mx, (1ll<<at)+dp(at+1,false));
    }else if((cnt[at]+contr) % 2 == 0 && (cnt[at]+contr) >= 2){
        mx = max(mx, dp(at+1,false));
        mx = max(mx, dp(at+1,true));
    }
    return mem[at][contr] = mx;
}

bool isKthBitSet(unsigned long long n, long long k)
{
    if ((n >> (k - 1)) & 1)
        return true;
    else
        return false;
}

int main() {
    cin.sync_with_stdio(false);
    memset(mem,-1,sizeof(mem));
    ll n;
    cin >> n;
    rep(i,0,n){
        unsigned long long a;
        cin >> a;
        for(int x = 63; x >= 0; x--){
            if(isKthBitSet(a,x+1)) cnt[x]++;
        }
    }
    rep(i,0,64) cout << cnt[i] << ' '; cout << endl;
    cout << dp(0,0) << endl;
    return 0;
}*/

struct node {
	node* left = NULL;
	node* right = NULL;
	ll atl, atr, val;
	ll lazy = 0;
	ll mn,mx;
	node(node* l, node* r, int v, int al, int ar) {
		left = l; right = r; val = v;
		atl = al; atr = ar; mn = v; mx = v;
	}
	void lazyupdate(int l, int r, ll by) {
		if(lazy != 0) propagate();
		if(l > atr || r < atl) return;
		if(l <= atl && atr <= r) {
			val += (atr-atl+1)*by;
			mx += by; mn += by;
			if(left != NULL) {
				left->lazy += by;
				right->lazy += by;
			}
			return;
		}
		left->lazyupdate(l,r,by);
		right->lazyupdate(l,r,by);
		mn = min(left->mn, right->mn);
		mx = max(left->mx, right->mx);
		val = left->val+right->val;
	}
	ll lazyquery(int l, int r) {
		if(l > atr || r < atl) return 0;
		if(lazy != 0) propagate();
		if(l <= atl && atr <= r) return val;
		return left->lazyquery(l,r)+right->lazyquery(l,r);
	}
	int lazylowest(int l, int r) {
		if(l > atr || r < atl) return INF;
		if(lazy != 0) propagate();
		if(l <= atl && atr <= r) return mn;
		return min(left->lazylowest(l,r), right->lazylowest(l,r));
	}
	int lazyhighest(int l, int r) {
		if(l > atr || r < atl) return 0;
		if(lazy != 0) propagate();
		if(l <= atl && atr <= r) return mx;
		return max(left->lazyhighest(l,r), right->lazyhighest(l,r));
	}
	void propagate() {
		val += (atr-atl+1)*lazy;
		mn += lazy;
		mx += lazy;
		if(left != NULL) {
			right->lazy += lazy;
			left->lazy += lazy;
		}
		lazy = 0;
	}
};
node* build(int l, int r) {
	if(l > r) return NULL;
	if(l == r) return new node(NULL, NULL, 0, l, r);
	int m = (l+r)/2;
	node* left = build(l,m);
	node* right = build(m+1,r);
	node* cur = new node(left,right,0,l,r);
	return cur;
}


int main(){
    int n, k, q;
    cin >> n >> k >> q;
    vi A(q);
    rep(i,0,q){
        cin >> A[i];
        A[i]--;
    }
    node* root = build(0, n);
    root->lazyupdate(0,n-1,k);
    rep(i,0,q){
        int cur = A[i];
        if(cur == 0){
            root->lazyupdate(1,n-1,-1);
        }else if(cur == n-1){
            root->lazyupdate(0,n-2,-1);
        }else{
            root->lazyupdate(cur+1,n-1,-1);
            root->lazyupdate(0,cur-1,-1);
        }
    }
    rep(i,0,n){
        if(root->lazyquery(i,i) >= 1) cout << "Yes" << endl;
        else cout << "No" << endl;
    }
    /*ll n, m;
    cin >> n >> m;
    vi A(n);

    priority_queue<ll,vector<ll>,less<ll> > pq;
    rep(i,0,n){
        cin >> A[i];
        pq.push(A[i]);
    }
    rep(i,0,m){
        ll cur = pq.top();
        pq.pop();
        pq.push(cur/2);
    }
    ll sm = 0;
    rep(i,0,n){
        sm += pq.top();
        pq.pop();
    }
    cout << sm << endl;*/
}



Measured memory_bytes: 18176