#include <bits/stdc++.h>
const long long INF = 1e16;

namespace SPFA {
  int n;
  std::vector<int> cnt, vis, in_s;
  std::vector<long long> dis;
  std::vector<std::vector<std::pair<int, int> > > G;

  void Init(int _n, std::vector<std::vector<std::pair<int, int> > > _G) {
    n = _n, G = _G;
    dis = std::vector<long long> (n, INF);
    cnt = vis = in_s = std::vector<int> (n);
  }

  bool SPFA(std::vector<int> &s, int coef) {
    if (s.empty()) return false;
    // std::cout << "Begin" << std::endl;

    for (int u : s) in_s[u] = 1;
    int st = s[0];
    dis[st] = 0, vis[st] = 1;
    int head = 0, tail = 1;
    std::vector<int> que(1, st);
    bool neg_circle = false;
    while (head < tail) {
      int u = que[head++];
      vis[u] = 0;
      for (auto [v, w] : G[u]) {
        if (!in_s[v]) continue;
        w *= coef;
        if (dis[v] > dis[u] + w) {
          dis[v] = dis[u] + w;
          cnt[v] = cnt[u] + 1;
          if (cnt[v] >= n) {neg_circle = true; break;}
          if (!vis[v]) que.emplace_back(v), ++tail, vis[v] = 1;
        }
      }
    }
    for (int u : s) dis[u] = INF, cnt[u] = vis[u] = in_s[u] = 0;

    // std::cout << "End" << std::endl;

    return neg_circle;
  }
}

void charming() {
  int n, m, q; std::cin >> n >> m >> q;
  std::vector<std::vector<std::pair<int, int> > > G(n);
  for (int i = 0, a, b, c; i < m; ++i) {
    std::cin >> a >> b;
    a = ((a % n) + n) % n;
    c = (((a + b) % n) + n) % n;
    G[a].emplace_back(std::make_pair(c, b));

    // std::cout << "G Add Edge " << a << ' ' << c << ' ' << b << '\n';
  }

  int tot = 0, scc_cnt = 0;
  std::vector<int> dfn(n, -1), low(n, -1), bel(n, -1), stk;
  std::vector<std::vector<int> > scc;
  auto Tarjan = [&](auto &&self, int u) -> void {
    dfn[u]= low[u] = tot++;
    stk.emplace_back(u);
    for (auto [v, _] : G[u]) {
      if (dfn[v] == -1) {
        self(self, v);
        low[u] = std::min(low[u], low[v]);
      } else if (bel[v] == -1) low[u] = std::min(low[u], dfn[v]);
    }
    if (low[u] >= dfn[u]) {
      bel[u] = scc_cnt;
      std::vector<int> new_scc;
      while (stk.back() != u) {
        bel[stk.back()] = scc_cnt;
        new_scc.emplace_back(stk.back());
        stk.pop_back();
      }
      new_scc.emplace_back(u);
      stk.pop_back();
      scc.emplace_back(new_scc);
      ++scc_cnt;
    }
  };
  for (int u = 0; u < n; ++u) if (dfn[u] == -1) Tarjan(Tarjan, u);

  // for (int i = 0; i < n; ++i) std::cout << bel[i] << ' ';
  // std::cout << '\n';

  // std::cout << 0 << std::endl;

  std::vector<int> du(scc_cnt);
  std::vector<std::vector<int> > nG(scc_cnt);
  for (int u = 0; u < n; ++u) {
    for (auto [v, _] : G[u]) {
      if (bel[u] != bel[v]) {
        // std::cout << "nG Add edge " << ' ' << bel[v] << ' ' << bel[u] << std::endl;
        nG[bel[v]].emplace_back(bel[u]);
        ++du[bel[u]];
      }
    }
  }

  SPFA::Init(n, G);
  auto Check = [&](int id) -> bool {
    // std::cout << id << ' ' << SPFA::SPFA(scc[id], 1) << ' ' << SPFA::SPFA(scc[id], -1) << '\n';
    return SPFA::SPFA(scc[id], 1) | SPFA::SPFA(scc[id], -1);
  };

  // std::cout << 1 << std::endl;

  int head = 0, tail = 0;
  std::vector<int> que, f(n);
  for (int u = 0; u < scc_cnt; ++u) if (!du[u]) que.emplace_back(u), ++tail;
  while (head < tail) {
    int u = que[head++];
    if (!f[u]) f[u] |= Check(u);
    for (int v : nG[u]) {
      --du[v];
      f[v] |= f[u];
      if (!du[v]) que.emplace_back(v), ++tail;
    }
  }

  // std::cout << 2 << std::endl;

  for (int i = 0, x; i < q; ++i) {
    std::cin >> x;
    x = ((x % n) + n) % n;
    x = bel[x];
    if (f[x]) std::cout << "Yes\n";
    else std::cout << "No\n";
  }
}

signed main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(NULL);
  std::cout.tie(NULL);
  charming();
  return 0;
}