#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <queue>
#include <deque>
#include <bitset>
#include <iterator>
#include <list>
#include <stack>
#include <map>
#include <set>
#include <functional>
#include <numeric>
#include <utility>
#include <limits>
#include <time.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <unordered_map>
#include <unordered_set>

using namespace std;

typedef long long lli;
typedef long double ld;
typedef pair<lli, lli > plli;
typedef vector<lli> vlli;
typedef vector<plli > vplli;

#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);
#define lcm(a, b) ((a * b) / gcd(a, b))
#define sqr(x) (x)*(x)
#define all(a) a.begin(),a.end()
#define UN(v) sort(all(v)), v.resize(unique(all(v))-v.begin())

#define endl '\n'

const long long INF = 100000000000000000;
const long long MOD = 1000000007;
const long long MAXN = 100005;

lli dx[]={0,0,-1,1,-1,-1,1,1};
lli dy[]={1,-1,0,0,1,-1,-1,1};

lli gcd(lli a , lli b) {
    if(b == 0) return a;
    a %= b;
    return gcd(b,a);
}

lli tree[4 * MAXN], lazy[4 * MAXN];

void build(lli node, lli start, lli end, lli val) {
    if (start > end) return;

    if (start == end) {
        tree[node] = val;
        return;
    }

    lli mid = (start + end) / 2;
    build(2 * node, start, mid, val);
    build(2 * node + 1, mid + 1, end, val);
    tree[node] = tree[2 * node] + tree[2 * node + 1];
}

void update(lli node, lli start, lli end, lli l, lli r) {

    if (lazy[node]) {
        tree[node] += (end - start + 1) * lazy[node];
        if (start != end) {
            lazy[2 * node] += lazy[node];
            lazy[2 * node + 1] += lazy[node];
        }
        lazy[node] = 0;
    }

    if (start > end or end < l or start > r) return;

    if (start >= l and end <= r) {
        tree[node] += (end - start + 1) * (-1);
        if (start != end) {
            lazy[2 * node] += -1;
            lazy[2 * node + 1] += -1;
        }
        return;
    }

    lli mid = (start + end) / 2;
    update(2 * node, start, mid, l, r);
    update(2 * node + 1, mid + 1, end, l, r);

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

lli query(lli node, lli start, lli end, lli l, lli r) {

    if (lazy[node]) {
        tree[node] += (end - start + 1) * lazy[node];
        if (start != end) {
            lazy[2 * node] += lazy[node];
            lazy[2 * node + 1] += lazy[node];
        }
        lazy[node] = 0;
    }

    if (start > end or end < l or start > r) return 0;

    if (start >= l and end <= r) {
        return tree[node];
    }

    lli mid = (start + end) / 2;
    lli q1 = query(2 * node, start, mid, l, r);
    lli q2 = query(2 * node + 1, mid + 1, end, l, r);

    return (q1 + q2);
}

void solve() {
    int n, k, q;
    cin >> n >> k >> q;

    build(1, 1, n, k);
    while (q--) {
        lli a;
        cin >> a;
        update(1, 1, n, 1, a - 1);
        update(1, 1, n, a + 1, n);
    }

    for (int i = 1; i <= n; i++) {
        //cout << query(1, 1, n, i, i) << endl;
        if (query(1, 1, n, i, i) <= 0) {
            cout << "No" << endl;
        } else {
            cout << "Yes" << endl;
        }
    }
}

int main()
{
    IOS;
    //comment it out
    //freopen("input.txt", "r", stdin);
    lli t = 1;
    //cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}


Measured memory_bytes: 6784