#include "bits/stdc++.h"

using namespace std;

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

#define all(x) (x).begin(), (x).end()

vector<bool> visited; // keeps track of which vertices are already visited

// runs depth first search starting at vertex v.
// each visited vertex is appended to the output vector when dfs leaves it.
void dfs(int v, vector<vector<int>> const &adj, vector<int> &output) {
  visited[v] = true;
  for (auto u: adj[v])
    if (!visited[u])
      dfs(u, adj, output);
  output.push_back(v);
}

// input: adj -- adjacency list of G
// output: components -- the strongy connected components in G
// output: adj_cond -- adjacency list of G^SCC (by root vertices)
void strongly_connected_components(vector<vector<int>> const &adj,
                                   vector<vector<int>> &components) {
  int n = adj.size();
  components.clear();

  vector<int> order; // will be a sorted list of G's vertices by exit time

  visited.assign(n, false);

  // first series of depth first searches
  for (int i = 0; i < n; i++)
    if (!visited[i])
      dfs(i, adj, order);

  // create adjacency list of G^T
  vector<vector<int>> adj_rev(n);
  for (int v = 0; v < n; v++)
    for (int u: adj[v])
      adj_rev[u].push_back(v);

  visited.assign(n, false);
  reverse(order.begin(), order.end());

  vector<int> roots(n, 0); // gives the root vertex of a vertex's SCC

  // second series of depth first searches
  for (auto v: order)
    if (!visited[v]) {
      std::vector<int> component;
      dfs(v, adj_rev, component);
      components.push_back(component);
      int root = *min_element(begin(component), end(component));
      for (auto u: component)
        roots[u] = root;
    }
}

const int M = 500500;

int n, m, q;
vector<vector<int>> g;
vector<vector<ll>> h;
int col[M];
ll p[M];
bool used[M];
bool bad[M];

int norm(ll x) {
  x %= n;
  if (x < 0)
    x += n;
  assert(0 <= x && x < n);
  return x;
}

void read() {
  cin >> n >> m >> q;
  g.resize(n);
  h.resize(n);
  for (int i = 0; i < m; ++i) {
    ll a, b;
    cin >> a >> b;
    int u = norm(a);
    int v = norm(a + b);
    ll w = b;

//    cerr << u << " -> " << v << " with w " << w << "\n";
    g[u].push_back(v);
    h[u].push_back(w);
  }
}

void dfs2(int v, ll cur_p) {
  used[v] = true;
  p[v] = cur_p;
  for (int i = 0; i < (int) g[v].size(); ++i) {
    int to = g[v][i];
    ll w = h[v][i];
    if (col[to] == col[v] && !used[to])
      dfs2(to, p[v] + w);
  }
}

bool check(const vector<int> &s) {
  dfs2(s.front(), 0);
  for (int v: s) {
    for (int i = 0; i < (int) g[v].size(); ++i) {
      int to = g[v][i];
      if (col[to] != col[v])
        continue;
      if (p[to] - p[v] != h[v][i])
        return false;
    }
  }
  return true;
}

bool dfs3(int v) {
  if (used[v])
    return bad[v];
  used[v] = true;
  for (int to: g[v])
    bad[v] |= dfs3(to);
  return bad[v];
}

void kill() {
  vector<vector<int>> scc;
  strongly_connected_components(g, scc);

  for (int i = 0; i < (int) scc.size(); ++i)
    for (int x: scc[i])
      col[x] = i;

  fill(used, used + n, false);
  fill(bad, bad + n, false);
  for (const auto &s: scc) {
    if (!check(s)) {
      for (int v: s)
        bad[v] = true;
    }
  }

  fill(used, used + n, false);
  for (int v = 0; v < n; ++v)
    dfs3(v);

  for (int i = 0; i < q; ++i) {
    ll x;
    cin >> x;
    cout << (bad[norm(x)] ? "Yes" : "No") << "\n";
  }
}

int main() {
#ifndef ONLINE_JUDGE
  freopen("m.txt", "r", stdin);
#endif
  ios_base::sync_with_stdio(false);

  read();
  kill();

  return 0;
}