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

using i64 = long long;

struct Tarjen {
    int n;
    vector<std::vector<std::pair<int, int> > > G;
    vector<int> ans;
    Tarjen(int n) : n(n), G(n), ans(n) {}

    void addedge(int u, int v, int w) {
        G[u].emplace_back(v, w);
    } 
    auto solve() {
        vector<int> scc(n), dfn(n), low(n), res(n + 1);
        std::vector<i64> dp(n);
        vector<int> stk;
        std::vector<int> good(n);
        int dfs_clock = 0, cnt = 0;
        function<void(int)> tarjan = [&](int u) {
            stk.push_back(u);
            dfn[u] = low[u] = ++dfs_clock;
            for (auto [v, w] : G[u]) {
                if (!dfn[v]) {
                    dp[v] = dp[u] + w;
                    tarjan(v);
                    low[u] = min(low[u], low[v]);
                } else if (!scc[v]) {
                    low[u] = min(low[u], dfn[v]);
                }
                if(dfn[u] >= dfn[v]) {
                    good[u] |= dp[u] - dp[v] + w != 0;
                }
            }
            if (dfn[u] == low[u]) {
                int v;
                cnt += 1;
                bool nice = false;
                do {
                    v = stk.back();
                    stk.pop_back();
                    scc[v] = cnt;
                    nice |= good[v];
                } while (v != u);
                res[cnt] = nice;
            }
        };
        for (int i = 0; i < n; ++i) if (!dfn[i]) tarjan(i);

        std::vector adj(cnt + 1, std::vector<int>());
        for (int i = 0; i < n; i += 1) {
            for (auto [j, w] : G[i]) {
                adj[scc[i]].emplace_back(scc[j]);
            }
        }
        std::vector<int> vis(cnt + 1);
        std::function<void(int)> dfs = [&](int u) {
            if (vis[u]) return;
            vis[u] = 1;
            for (int v : adj[u]) {
                dfs(v);
                res[u] |= res[v];
            }
        };
        for (int i = 1; i <= cnt; i += 1) {
            if (!vis[i]) dfs(i);
        }
        return std::make_pair(scc, res); 
    }
};

int main(){
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    int n, m, q;
    std::cin >> n >> m >> q;
    Tarjen tarjen(n);
    for (int i = 0; i < m; i += 1) {
        int x, y;
        std::cin >> x >> y;
        int w = y;
        x = (x % n + n) % n;
        y = (y % n + n) % n;
        tarjen.addedge(x, (x + y) % n, w);
    }
    auto [scc, res] = tarjen.solve();
    while(q--) {
        int x;
        std::cin >> x;
        x = (x % n + n) % n;
        std::cout << (res[scc[x]] ? "Yes" : "No") << "\n";
    }
    return 0;
}