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

namespace SPFA {
  std::mt19937_64 rnd(std::chrono::steady_clock::now().time_since_epoch().count());

  int n;
  std::vector<int> cnt, vis, in_s, pos;
  std::vector<long long> dis, pre;
  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 = pre = std::vector<long long> (n, INF);
    cnt = vis = in_s = std::vector<int> (n);
    pos = std::vector<int> (n, -1);
  }

  int my_random(int x) {
    return rnd() % x;
  }

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

    int c = s.size();
    for (int u : s) in_s[u] = 1, c += G[u].size();

    if (c <= 500) {
      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;
    }
    else {
      bool neg_circle = false;
      for (int u : s) in_s[u] = 1;

      int tot = 0;
      auto DFS = [&](auto &&self, int u) -> void {
        random_shuffle(G[u].begin(), G[u].end(), my_random);
        pos[u] = tot++, vis[u] = 1;
        for (auto [v, w] : G[u]) if (in_s[v]) {
          if (!vis[v]) {
            self(self, v);
            pre[tot] = pre[tot - 1] + w;
            if (neg_circle) break;
          }
          else {
            if (pre[tot - 1] - pre[v] + w) {
              neg_circle = true; break;
            }
          }
        }
        pos[u] = -1, --tot;
      };

      for (int i = 0; i < 50; ++i) {
        int rt = s[rnd() % int(s.size())];
        tot = 0;
        DFS(DFS, rt);
        if (neg_circle) break;
        for (int u : s) vis[u] = 0;
      }
      
      for (int u : s) in_s[u] = 0;
			
      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;
}