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

struct SCC {
    int n, unix, tot;
    vector<vector<int>> E;
    vector<int> dfn, low, bel, stk;

    SCC(int n) : n(n), unix(0), tot(0), E(n), dfn(n, -1), low(n), bel(n, -1) {}

    void add(int u, int v) {
        E[u].push_back(v);
    }

    void dfs(int u) {
        dfn[u] = low[u] = unix++;    // 记录DFS序
        stk.push_back(u);

        // DP更新low[u]
        for (auto& v : E[u]) {
            if (dfn[v] == -1) dfs(v), low[u] = min(low[u], low[v]);
            else if (bel[v] == -1) low[u] = min(low[u], dfn[v]);
        }

        // u是SCC的根
        if (dfn[u] == low[u]) {
            int v;
            do {
                v = stk.back();
                stk.pop_back();   // 出栈
                bel[v] = tot;     // 记录u的子节点的根为u
            } while (v != u);     // 不断弹出直到根u弹出为止
            tot++;                // 记录SCC的数量
        }
    }

    struct Graph {
        int n;
        vector<vector<int>> E;
        vector<int> ecnt, pcnt, bel;
        Graph(int n) : n(n), E(n), ecnt(n), pcnt(n) {}
    };
    Graph work() {
        for (int u = 0; u < n; u++) {
            if (dfn[u] == -1) dfs(u);
        }
        Graph G(tot);
        G.bel = bel;
        for (int u = 0; u < n; u++) {
            for (auto& v : E[u]) {
                if (bel[u] != bel[v]) G.E[bel[u]].push_back(bel[v]);  // bel[u]总是小于p[v]
                else G.ecnt[bel[u]]++;
            }
            G.pcnt[bel[u]]++;
        }
        for (auto& vec : G.E) {
            sort(vec.begin(), vec.end());
            vec.erase(unique(vec.begin(), vec.end()), vec.end());
        }
        return G;
    }

    template<typename T>
    vector<T> compress(const vector<T>& w) {
        vector<T> res(tot);
        for (int u = 0; u < n; u++) {
            res[bel[u]] += w[u];
        }
        return res;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);

    int n, m, q;
    cin >> n >> m >> q;

    vector<vector<pair<int, int>>> E(n);
    SCC G(n);
    while (m--) {
        int u, w;
        cin >> u >> w;
        int v = u + w;
        u = (u % n + n) % n;
        v = (v % n + n) % n;
        G.add(u, v);
        E[u].push_back({ w, v });
    }

    vector<int> vis(n);
    vector<ll> val(n);
    for (int u = 0; u < n; u++) {
        if (vis[u]) continue;
        queue<int> Q;
        Q.push(u);
        while (!Q.empty()) {
            int u = Q.front(); Q.pop();
            vis[u] = 1;
            for (auto [w, v] : E[u]) {
                if (vis[v]) continue;
                val[v] = val[u] + w;
                Q.push(v);
            }
        }
    }

    auto g = G.work();
    vector<int> dp(g.n);
    for (int u = 0; u < n; u++) {
        for (auto [w, v] : E[u]) {
            if (g.bel[u] == g.bel[v] && val[u] + w != val[v]) {
                dp[g.bel[u]] = 1;
            }
        }
    }

    for (int u = 0; u < g.n; u++) {
        for (auto v : g.E[u]) {
            dp[u] |= dp[v];
        }
    }

    while (q--) {
        int u;
        cin >> u;
        u = (u % n + n) % n;
        cout << (dp[g.bel[u]] ? "Yes" : "No") << endl;
    }

    return 0;
}