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

using ll = long long;
using ld = long double;

#define all(a) begin(a), end(a)
#define len(a) int((a).size())

template<typename Fun>
struct y_combinator {
    const Fun fun;

    explicit y_combinator(const Fun&& fun) : fun(std::forward<const Fun>(fun)) {}

    template<typename... Args>
    auto operator()(Args&&... args) const {
        return fun(std::ref(*this), std::forward<Args>(args)...);
    }
};

class strongly_connected_components {
private:
    int n;
    std::vector<std::vector<int>> g;

    int cur_id, cur_scc;
    std::vector<int> id, f, scc, st;

    void dfs(int v) {
        st.push_back(v);
        id[v] = f[v] = cur_id++;

        for (auto u : g[v]) {
            if (id[u] == -1) {
                dfs(u);
                f[v] = std::min(f[v], f[u]);
            } else if (scc[u] == -1) {
                f[v] = std::min(f[v], id[u]);
            }
        }

        if (id[v] == f[v]) {
            int u;
            do {
                u = st.back();
                st.pop_back();
                scc[u] = cur_scc;
            } while (u != v);
            cur_scc++;
        }
    }

public:
    strongly_connected_components(int n = 0) : n(n), g(n) {}

    // Adds directed edge (from -> to)
    void add(int from, int to) {
        g[from].push_back(to);
    }

    // Returns for each vertex the scc index from [0, number_of_scc).
    // If u is reachable from v, then scc_index[v] <= scc_index[u].
    std::vector<int> solve() {
        cur_id = cur_scc = 0;
        id.assign(n, -1);
        f.assign(n, -1);
        scc.assign(n, -1);

        for (int v = 0; v < n; v++) {
            if (id[v] == -1) {
                dfs(v);
            }
        }

        for (auto &x : scc) {
            x = cur_scc - 1 - x;
        }
        return scc;
    }
};

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

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

    vector<vector<pair<int, int>>> g(n);
    strongly_connected_components scc(n);

    auto mod = [&](int x) {
        return (x % n + n) % n;
    };

    while (m--) {
        int a, b;
        cin >> a >> b;
        a = mod(a);
        int nxt = mod(a + b);
        g[a].emplace_back(nxt, b);
        scc.add(a, nxt);
    }

    auto comp = scc.solve();
    const int C = *max_element(all(comp)) + 1;
    vector<vector<int>> comps(C);
    for (int v = 0; v < n; v++) {
        comps[comp[v]].push_back(v);
    }

    vector<bool> good(C), used(n);
    vector<ll> val(n);

    for (int i = 0; i < C; i++) {
        bool valid = true;

        y_combinator([&](auto dfs, int v) -> void {
            used[v] = true;
            for (auto [u, w] : g[v]) {
                if (!used[u]) {
                    val[u] = val[v] + w;
                    dfs(u);
                } else if (val[u] != val[v] + w) {
                    valid = false;
                }
            }
        })(comps[i][0]);

        good[i] = !valid;
    }

    for (int i = C - 1; i >= 0; i--) {
        for (auto v : comps[i]) {
            for (auto [u, _] : g[v]) {
                if (good[comp[u]]) {
                    good[i] = true;
                }
            }
        }
    }

    while (q--) {
        int x;
        cin >> x;
        x = mod(x);
        cout << (good[comp[x]] ? "Yes" : "No") << '\n';
    }
}