#include<iostream>
#include<vector>
#include<string>
#include<queue>
#include<map>
#include<set>
#include<cstring>
#include<stdlib.h>
#include<stdio.h>
#include<algorithm>
#include<math.h>
#define int long long
const int maxn = 200005;
const int maxm = 505;
const int maxs = 2005;
const int mod = 998244353;
const int inf = 1e17;
using namespace std;
#if 0
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> oset;
#endif
#if 0
class DSU {
public:
vector<int> p, rank;
DSU(int n) {
p.resize(n), rank.resize(n, 1);
for (int i = 0; i < n; ++i) p[i] = i;
}
int fset(int x) { return p[x] = ((p[x] == x) ? x : fset(p[x])); }
bool iset(int x, int y) { return fset(x) == fset(y); }
void uset(int x, int y) {
x = fset(x), y = fset(y);
if (x == y) return;
if (rank[x] > rank[y]) swap(x, y);
p[x] = y, rank[y] += rank[x];
}
};
#endif
#if 1
class segtree {
private:
vector<int> st, lazy, a;
const int dv = 0;
const int ldv = 0;
int join(int l, int r) {
return l + r;
}
int ljoin(int l, int r) {
return l + r;
}
void upd(int s, int e, int node, int val) {
if (val == ldv) return;
st[node] += ((e - s + 1) * val);
}
int build(int s, int e, int node) {
if (s == e)
return st[node] = a[s];
int mid = (s + e) / 2;
return st[node] = join(build(s, mid, node * 2), build(mid + 1, e, node * 2 + 1));
}
void update(int s, int e, int node, int l, int r, int val) {
if ((l > e) || (r < s)) return;
if ((l <= s) && (r >= e)) {
upd(s, e, node, val);
lazy[node] = ljoin(lazy[node], val);
return;
}
int mid = (s + e) / 2;
upd(s, mid, node * 2, lazy[node]);
upd(mid + 1, e, node * 2 + 1, lazy[node]);
lazy[node * 2] = ljoin(lazy[node * 2], lazy[node]);
lazy[node * 2 + 1] = ljoin(lazy[node * 2 + 1], lazy[node]);
lazy[node] = ldv;
update(s, mid, node * 2, l, r, val);
update(mid + 1, e, node * 2 + 1, l, r, val);
st[node] = join(st[node * 2], st[node * 2 + 1]);
}
int query(int s, int e, int node, int l, int r) {
if ((l > e) || (r < s)) return dv;
if ((l <= s) && (r >= e)) return st[node];
int mid = (s + e) / 2;
upd(s, mid, node * 2, lazy[node]);
upd(mid + 1, e, node * 2 + 1, lazy[node]);
lazy[node * 2] = ljoin(lazy[node * 2], lazy[node]);
lazy[node * 2 + 1] = ljoin(lazy[node * 2 + 1], lazy[node]);
lazy[node] = ldv;
return join(query(s, mid, node * 2, l, r),
query(mid + 1, e, node * 2 + 1, l, r));
}
public:
segtree(int n, vector<int> arr) {
a = arr;
st.resize(4 * n, dv);
lazy.resize(4 * n, ldv);
build(0, n - 1, 1);
}
int query(int l, int r) {
return query(0, a.size() - 1, 1, l, r);
}
void update(int l, int r, int val) {
update(0, a.size() - 1, 1, l, r, val);
}
};
#endif
#if 0
int p[200005][20], dep[200005];
vector<int> g[200005];
void dfs(int node, int par) {
p[node][0] = par;
dep[node] = dep[par] + 1;
for (int i = 1; i < 20; ++i)
p[node][i] = p[p[node][i - 1]][i - 1];
for (auto x : g[node])
if (x != par) dfs(x, node);
}
int kpar(int node, int k) {
for (int i = 0; i < 20; ++i)
if (k & (1 << i))
node = p[node][i];
return node;
}
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
u = kpar(u, dep[u] - dep[v]);
if (u == v) return u;
for (int i = 19; i >= 0; --i)
if (p[u][i] != p[v][i])
u = p[u][i],
v = p[v][i];
return p[u][0];
}
#endif
#if 0
class line {
public:
int m, c;
line(int a = 0, int b = 0) { m = a, c = b; }
int y(int x) { return m * x + c; }
};
class CHT {
private:
int i = 0;
vector<line> arr;
bool bad(line a, line b, line c) {
if (b.m == c.m) return b.c >= c.c;
double x = (c.c - a.c) / (a.m - c.m);
double y = (b.c - a.c) / (a.m - b.m);
return ((y - x) > (double)(1e-6));
}
public:
void add(int m, int c) {
line l(m, c);
if (arr.size() < 2) {
if (arr.size() == 1)
if (arr.back().m == m)
if (arr.back().c >= c)
arr.pop_back();
arr.push_back(l);
return;
}
while (arr.size() > 1) {
line pprev = arr[arr.size() - 2], prev = arr.back();
if (!bad(pprev, prev, l)) break;
arr.pop_back();
}
arr.push_back(l);
}
int query(int x) {
if (arr.empty()) return inf;
if (i >= arr.size()) i = arr.size() - 1;
while (i < (arr.size() - 1)) {
int cur = arr[i].y(x);
int nxt = arr[i + 1].y(x);
if (nxt > cur) break;
++i;
}
return arr[i].y(x);
}
};
#endif
vector<int> g[maxn];
void solve() {
int n, m, q; cin >> n >> m >> q;
vector<pair<int, int>> edg;
for (int i = 0; i < m; ++i) {
int u, v; cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
edg.push_back({ u,v });
}
vector<int> col(n + 1, -1), deg(n + 1, 0), bs(m);
int r = 0;
for (int l = 0; l < m; ++l) {
for (; (r < m); ++r) {
int u = edg[r].first, v = edg[r].second;
if ((min(col[u], col[v]) == -1))
col[u] = max(col[u], col[v]),
col[v] = max(col[v], col[u]);
if (col[u] != col[v]) break;
++deg[u], ++deg[v];
}
bs[l] = r - 1;
int u = edg[l].first, v = edg[r].second;
--deg[u], --deg[v];
if (deg[u] == 0) col[u] = -1;
if (deg[v] == 0) col[v] = -1;
}
while (q--) {
int x, y; cin >> x >> y; --x, --y;
cout << ((y >= bs[x]) ? "NO" : "YES") << endl;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
///cin >> t;
while (t--) {
solve();
}
return 0;
}
