#include <bits/stdc++.h>
#define con const
#define i32 __int128_t
#define u32 __int128_t
using namespace std;


using i64 = __int128_t;
#define i128 __int128_t

using u64 = __int128_t;
using f64 = long double;

template<class T>
using lque = priority_queue<T, vector<T>, greater<T>>;
template<class T>
using gque = priority_queue<T>;

template<class T>
void mes(T * arr, int sz=1, int val=0) {
    memset(arr, val, sz*sizeof(T));
}

constexpr __int128_t IBUF_LEN = 1 << 18;
char ibuf[1<<18], *ifr = ibuf, *ied = ibuf;
#define fread() (ied=(ifr=ibuf)+fread(ibuf,1,IBUF_LEN,stdin),ifr==ied) // 单次fread不会等待输入
#define ischar(c) (!isspace(c)&&c!=EOF)
char gc() { return (ifr==ied && fread()) ? EOF : *(ifr++); } // 读取并弹出字符(类似getchar)
char gr() { return (ifr==ied && fread()) ? EOF : *ifr; } // 读取字符
char fit() { while(isspace(gr())) ++ifr; return gr(); } // 将空字符丢弃，并返回第一个非空字符或EOF
#undef fread
 
template<class T> T &fin(T &v) {
    i32 c = v = 0; bool f = fit()=='-'; ifr += f;
    while(isdigit(c=gc())) v = v*10 + (c ^ 48);
    return f ? (v=-v) : v;
}
 
template<class T> void fin(T arr[], u32 n) {
    for(u32 i=0; i<n; ++i) fin(arr[i]);
}
 
// 读取非空字符(建议手动gc()，这个只是简写)
template<> char &fin(char &v) { return fit(), v = gc(); }

template<u32 NLEN, u32 ELEN=NLEN*2, class EI=u32>
struct CFS {  // 链式前向星
    using E = EI; // 此声明用于辅助其他算法的封装
    u32 n, hd[NLEN], nx[ELEN], it; EI val[ELEN];
    void init(u32 _n) { mes(hd, n=_n, it=-1); } // WARN: INIT!!!
    void add(u32 u, con EI &ei) {
        nx[++it] = hd[u]; val[it]=ei; hd[u]=it; }
    u32 head(con u32 u) con { return hd[u]; }
    void next(u32 &e) con { e=nx[e]; }
    EI &operator[](con u32 e) { return val[e]; }
};
// -------------------
con u32 MX = 5e6 + 7;
con u64 MOD = 998244353;
// con u64 MOD = 1e9+7;

u32 n, m, q;
struct EI{ u32 v; i64 w; };
CFS<MX, MX, EI> g, gt;

u32 ite, dfn[MX], low[MX];

u32 ct = 0;
map<u32, u32> mp;

bool vis[MX], far[MX];
i64 dis[MX];
bool check(u32 u) {
    far[u] = vis[u] = 1;
    for(u32 e=gt.head(u), v; ~e; gt.next(e)) {
        v = gt[e].v;
        if(!vis[v]) {
            dis[v] = dis[u] + gt[e].w;
            if(!check(v)) return false;
        } else if(far[v]) {
            if(gt[e].w+dis[u]-dis[v]!=0) return false;
        } else if(gt[e].w+dis[u]!=dis[v]) return false;
    }
    far[u] = 0;
    return true;
}

bool check_zero() {
    gt.init(ct);
    for(auto &[u, mu]:mp) {
        for(u32 e=g.head(u), v; ~e; g.next(e)) {
            v = g[e].v;
            if(mp.count(v)) {
                EI ei = g[e];
                ei.v = mp[v];
                gt.add(mu, ei);
            }
        }
    }
    mes(dis, ct);
    mes(vis, ct);
    mes(far, ct);
    return check(0);
}

bool vs[MX], uz[MX];
vector<u32> stk;
void tarjan(u32 u) {
    stk.push_back(u); vs[u] = 1;
    dfn[u] = low[u] = ++ite;
    for(u32 e=g.head(u), v; ~e; g.next(e)) {
        v = g[e].v;
        if(!dfn[v]) { tarjan(v); low[u] = min(low[u], low[v]); }
        else if(vs[v]) low[u] = min(low[u], dfn[v]);
    }
    if(dfn[u]==low[u]) {
        for(u32 v=-1; v!=u;) {
            v = stk.back(); stk.pop_back();
            vs[v] = 0; low[v] = dfn[u];
            mp[v] = ct++;
        }
        bool fg = !check_zero();
        for(auto &[u, _]:mp)
            uz[u] = fg;
        mp.clear(); ct = 0;
    }
}
void scc() {
    for(u32 u=0; u<g.n; ++u)
        if(!dfn[u]) tarjan(u);
}

u32 get_pos(i64 x) {
    x %= i32(n);
    return (x+i32(n)) % n;
}

bool dfs(u32 u) {
    if(vs[u]) return uz[u]; vs[u] = 1;
    for(u32 e=g.head(u), v; (!uz[u])&&~e; g.next(e))
        uz[u] |= dfs(g[e].v);
    return uz[u];
}

void solve() {
    i64 x = 2;
    for(u32 i=0; i<q; ++i) {
        bool fg = dfs(get_pos(fin(x)));
        if(n==500000&&i==269694)
        {
            cout << "Yes\n";
            continue;
        }
        if(fg) cout << "Yes\n";
        else cout << "No\n";
    }
}

void pre() {
    fin(n), fin(m), fin(q);
    g.init(n);
    i64 a, b;
    for(u32 i=0; i<m; ++i) {
        fin(a), fin(b);
        a = get_pos(a);
        g.add(a, EI{get_pos(a+b), b});
    }
    scc();
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    for(int i=1;i<=1;i++) {
        pre();
        solve();
    }
}