#include<bits/stdc++.h>
using namespace std;

#define int long long

typedef pair<int, int> pii;
typedef long long LL;
typedef unsigned long long uLL;

const int inf32 = 1e9;
const LL inf64 = 1e18;

struct SCC {
    int n;
    vector<vector<int>> G;
    vector<int> dfn, low, ins, stk;
    vector<int> col, siz;
    int id, colcnt;

    SCC() {}
    SCC(int x) {
        init(x);
    }
    void init(int x) {
        n = x;
        G.assign(n + 5, {});
    }
    void add_edge(int x, int y) {
        G[x].push_back(y);
    }
    void dfs(int cur) {
        dfn[cur] = low[cur] = ++id;
        stk.push_back(cur), ins[cur] = 1;
        for (auto v : G[cur]) {
            if (!dfn[v]) {
                dfs(v);
                low[cur] = min(low[cur], low[v]);
            } else if (ins[v]) {
                low[cur] = min(low[cur], dfn[v]);
            }
        }
        
        if (dfn[cur] == low[cur]) {
            ++colcnt;
            int x = stk.back();
            while (x != cur) {
                col[x] = colcnt;
                ins[x] = 0;
                ++siz[colcnt];
                stk.pop_back();
                x = stk.back();
            }
            col[cur] = colcnt;
            ins[cur] = 0;
            ++siz[colcnt];
            stk.pop_back();
        }
    }
    void gets() {
        dfn.assign(n + 5, 0);
        low.assign(n + 5, 0);
        ins.assign(n + 5, 0);
        col.assign(n + 5, 0);
        siz.assign(n + 5, 0);
        stk.clear();
        id = colcnt = 0;

        for (int i = 0; i < n; i++)
            if (!dfn[i]) dfs(i);
    }
    int diff(int x, int y) {
		return col[x] != col[y];
	}
};

signed main()
{
    cin.tie(0); cout.tie(0);
    ios::sync_with_stdio(0);

    int T = 1;
    // cin >> T;
    while (T--) {
        int n, k, Q;
        cin >> n >> k >> Q;
        
        SCC TG(n);
        vector<vector<pii>> G(n + 5);
        vector<pii> e;
        for (int i = 1; i <= k; i++) {
            int x, y;
            cin >> x >> y;
            int u = (x % n + n) % n, v = (u + y) % n, w = y;
            // cerr << u << ' ' << v << ' ' << w << endl;

            G[u].push_back({v, w});
            TG.add_edge(u, v);
            e.push_back({u, v});
        }

        TG.gets();

        int len = TG.colcnt;
        vector<int> vis(len + 5, 0), ff(len + 5, 0), val(n + 5, inf64);
        function<int(int, int, int, int)> dfs = [&] (int cur, int ftr, int now, int s) -> int {
            // cerr << cur << ' ' << s << ' ' << val[cur] << endl;
            if (val[cur] != inf64) {
                return s != val[cur];
            }
            val[cur] = s;

            for (auto [v, w] : G[cur]) {
                if (TG.col[v] != now) continue;
                if (dfs(v, cur, now, s + w)) return 1;
            }
            return 0;
        };

        for (int i = 0; i < n; i++) {
            int col = TG.col[i];
            if (vis[col]) continue;
            vis[col] = 1;
            ff[col] = dfs(i, 0, col, 0);
        }

        vector<pii> l;
        for (auto [u, v] : e) {
            if (TG.col[u] == TG.col[v]) continue;
            l.push_back({u, v});
        }

        sort(l.begin(), l.end(), [&](pii x, pii y) {
            if (x.first != y.first) return x.first > y.first;
            return x.second > y.second;
        });

        for (auto [u, v] : l) {
            u = TG.col[u], v = TG.col[v];
            // cerr << u <<' ' << v << endl;
            ff[u] = max(ff[u], ff[v]);
        }

        // for (int i = 0; i < n; i++) cerr << TG.col[i] << ' '; cerr << endl;
        // for (int i = 1; i <= len; i++) cerr << ff[i] << ' '; cerr << endl;

        while (Q--) {
            int x;
            cin >> x;
            x = (x % n + n) % n;
            cout << (ff[TG.col[x]] ? "Yes\n" : "No\n");
        }
    }

    return 0;
}