#include <bits/stdc++.h>
using namespace std;
template <class C>
constexpr int sz(const C &c) {
  return int(c.size());
}
constexpr const char nl = '\n', sp = ' ';
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using i128 = __int128_t;
using ui128 = __uint128_t;
template <class S>
struct FIFOWithLIFO : public S {
  using T = typename S::T;
  using S::query;
  vector<pair<T, bool>> stk;
  template <class... Args>
  FIFOWithLIFO(Args &&...args) : S(forward<Args>(args)...) {}
  void push(const T &v) {
    stk.emplace_back(v, false);
    S::push(v);
  }
  void pop() {
    if (!stk.back().second) {
      vector<T> A, B{stk.back().first};
      stk.pop_back();
      S::pop();
      for (; !stk.empty() && A.size() != B.size(); stk.pop_back(), S::pop())
        (stk.back().second ? A : B).push_back(stk.back().first);
      reverse(A.begin(), A.end());
      if (!A.empty()) reverse(B.begin(), B.end());
      for (auto &&b : B) {
        stk.emplace_back(b, A.empty());
        S::push(b);
      }
      for (auto &&a : A) {
        stk.emplace_back(a, true);
        S::push(a);
      }
    }
    stk.pop_back();
    S::pop();
  }
};
struct IncrementalBipartiteUndo {
  vector<int> UF;
  vector<bool> P, B;
  int cnt;
  bool bipartiteGraph;
  vector<tuple<int, int, int, bool, bool>> history;
  IncrementalBipartiteUndo(int V)
      : UF(V, -1), P(V, false), B(V, true), cnt(V), bipartiteGraph(true) {}
  pair<int, bool> find(int v) {
    bool p = P[v];
    for (; UF[v] >= 0; p ^= P[v = UF[v]])
      ;
    return make_pair(v, p);
  }
  void addEdge(int v, int w) {
    bool pv, pw;
    tie(v, pv) = find(v);
    tie(w, pw) = find(w);
    if (v == w) {
      history.emplace_back(v, w, 0, bipartiteGraph, B[v]);
      bipartiteGraph &= (B[v] = B[v] & (pv ^ pw));
      return;
    }
    if (UF[v] > UF[w]) {
      swap(v, w);
      swap(pv, pw);
    }
    history.emplace_back(v, w, UF[w], P[w], B[v]);
    UF[v] += UF[w];
    UF[w] = v;
    P[w] = pv ^ pw ^ 1;
    B[v] = B[v] & B[w];
    cnt--;
  }
  void undo() {
    int v, w, ufw;
    bool pw, bv;
    tie(v, w, ufw, pw, bv) = history.back();
    history.pop_back();
    B[v] = bv;
    if (ufw == 0)
      bipartiteGraph = pw;
    else {
      UF[w] = ufw;
      UF[v] -= UF[w];
      P[w] = pw;
      cnt++;
    }
  }
  bool connected(int v, int w) { return find(v).first == find(w).first; }
  int getSize(int v) { return -UF[find(v).first]; }
  bool componentBipartite(int v) { return B[find(v).first]; }
  bool color(int v) { return find(v).second; }
  bool pathParity(int v, int w) { return color(v) ^ color(w); }
};
struct S {
  using T = pair<int, int>;
  IncrementalBipartiteUndo bp;
  S(int V) : bp(V) {}
  void push(const pair<int, int> &e) { bp.addEdge(e.first, e.second); }
  void pop() { bp.undo(); }
  bool query() { return bp.bipartiteGraph; }
};
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  int N, M, Q;
  cin >> N >> M >> Q;
  FIFOWithLIFO<S> ds(N);
  vector<pair<int, int>> edges(M);
  for (auto &&e : edges) {
    cin >> e.first >> e.second;
    --e.first;
    --e.second;
    ds.push(e);
  }
  vector<int> R(M, INT_MAX);
  for (int l = 0, r = 0; l < M; l++) {
    for (; !ds.query(); r++) ds.pop();
    if (ds.query()) R[l] = r - 1;
    ds.push(edges[l]);
  }
  for (int i = 0; i < Q; i++) {
    int l, r;
    cin >> l >> r;
    cout << (R[--l] <= --r ? "NO" : "YES") << nl;
  }
  return 0;
}
