#include <bits/stdc++.h>
using namespace std;
struct vertex {
  int size, parent;
  bool change_colour;
  vertex() {}
  vertex(int p) {
    size = 0;
    parent = p;
    change_colour = false;
  }
};
struct save {
  int index[2];
  vertex v[2];
  save(int i_one, vertex v_one, int i_two, vertex v_two) {
    index[0] = i_one;
    v[0] = v_one;
    index[1] = i_two;
    v[1] = v_two;
  }
};
save gowno(0, 0, 0, 0);
struct DSU_with_rollbacks {
  int size;
  vector<vertex> vec;
  stack<save> state_save;
  DSU_with_rollbacks() {}
  DSU_with_rollbacks(int s) {
    size = s;
    for (int i = 0; i <= size; ++i) {
      vec.push_back(vertex(i));
    }
  }
  int find(int v) {
    while (v != vec[v].parent) {
      v = vec[v].parent;
    }
    return v;
  }
  bool get_colour(int v) {
    bool colour = vec[find(v)].change_colour;
    while (v != vec[v].parent) {
      colour ^= vec[v].change_colour;
      v = vec[v].parent;
    }
    return colour;
  }
  bool unite(int p, int q) {
    bool change = (get_colour(p) == get_colour(q));
    p = find(p);
    q = find(q);
    if (p == q) {
      state_save.push(gowno);
      return false;
    }
    if (vec[p].size > vec[q].size) swap(p, q);
    state_save.push(save(p, vec[p], q, vec[q]));
    if (change) {
      vec[p].change_colour = true;
    }
    vec[p].parent = q;
    if (vec[p].size == vec[q].size) vec[q].size++;
    return true;
  }
  void rollback() {
    if (state_save.empty()) return;
    save s_tmp = state_save.top();
    state_save.pop();
    for (int i = 0; i < 2; ++i) {
      vec[s_tmp.index[i]] = s_tmp.v[i];
    }
  }
};
vector<pair<int, int> > edges;
vector<pair<int, int> > queries;
vector<int> last;
DSU_with_rollbacks dsu;
bool add_edge(pair<int, int> &edge) {
  if (!dsu.unite(edge.first, edge.second)) {
    if (dsu.get_colour(edge.first) == dsu.get_colour(edge.second)) {
      return false;
    }
  }
  return true;
}
void rec(int L, int R, int optL, int optR, bool is_bipartite) {
  if (is_bipartite == false) return;
  int mid = (L + R) / 2;
  int cntL = 0, cntR = 0;
  for (int i = L; i < mid && is_bipartite; ++i) {
    cntL++;
    is_bipartite &= add_edge(edges[i]);
  }
  last[mid] = optR - 1;
  if (is_bipartite == false) {
    last[mid] = optR;
  }
  for (; last[mid] >= max(optL, mid) && is_bipartite; --last[mid]) {
    cntR++;
    if (add_edge(edges[last[mid]]) == false) break;
  }
  while (cntR--) {
    dsu.rollback();
  }
  cntL++;
  is_bipartite &= add_edge(edges[mid]);
  if (mid < R) rec(mid + 1, R, max(last[mid], mid + 1), optR, is_bipartite);
  while (cntL--) {
    dsu.rollback();
  }
  is_bipartite = true;
  for (int i = last[mid] + 1; i < optR; ++i) {
    is_bipartite &= add_edge(edges[i]);
  }
  if (L < mid) rec(L, mid - 1, optL, min(last[mid] + 1, optR), is_bipartite);
  for (int i = last[mid] + 1; i < optR; ++i) {
    dsu.rollback();
  }
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  int N, M, Q;
  cin >> N >> M >> Q;
  edges = vector<pair<int, int> >(M + 1);
  int f, t;
  for (int i = 1; i <= M; ++i) {
    cin >> f >> t;
    edges[i] = {f, t};
  }
  queries = vector<pair<int, int> >(Q);
  for (int i = 0; i < Q; ++i) {
    cin >> f >> t;
    queries[i] = {f, t};
  }
  dsu = DSU_with_rollbacks(N);
  last = vector<int>(M + 1, M + 1);
  rec(1, M, 1, M + 1, true);
  for (int i = 0; i < Q; ++i) {
    pair<int, int> q = queries[i];
    cout << ((q.second < last[q.first]) ? "YES\n" : "NO\n");
  }
  return 0;
}
