#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
class RollbackDSU {
 public:
  bool isBipartite;
  int find(int cur) {
    if (anc[cur] == cur) return cur;
    return find(anc[cur]);
  }
  int getValue(int cur) {
    if (anc[cur] == cur) return 0;
    return w[cur] ^ getValue(anc[cur]);
  }
  void rollback() {
    for (int k = 0; k < 2; k++) {
      int U = version.back().node;
      anc[U] = U;
      w[U] = version.back().w;
      rnk[U] = version.back().rnk;
      isBipartite = version.back().isBipartite;
      version.pop_back();
    }
  }
  void join(int i, int j) {
    int wI = getValue(i), wJ = getValue(j);
    i = find(i);
    j = find(j);
    version.push_back(state(i, w[i], rnk[i], isBipartite));
    version.push_back(state(j, w[j], rnk[j], isBipartite));
    if (i == j) {
      if (wI == wJ) isBipartite = false;
      return;
    }
    if (rnk[i] < rnk[j]) swap(i, j);
    anc[j] = i;
    w[j] = 1 ^ (wI ^ wJ);
    if (rnk[i] == rnk[j]) rnk[i]++;
  }
  void init(int N) {
    for (int i = 1; i <= N; i++) anc[i] = i;
    isBipartite = true;
  }

 protected:
  struct state {
    int node;
    int rnk, w;
    bool isBipartite;
    state(int n, int r, int w, bool is)
        : node(n), rnk(r), w(w), isBipartite(is) {}
  };
  int anc[MAXN], rnk[MAXN], w[MAXN];
  vector<state> version;
};
int n, m, q;
int opt[MAXN];
int U[MAXN], V[MAXN];
RollbackDSU DSU;
void addEdges(int L, int R) {
  for (int i = L; i <= R; i++) DSU.join(U[i], V[i]);
}
void removeEdges(int L, int R) {
  for (int i = L; i <= R; i++) DSU.rollback();
}
void DivAndConquer(int l, int r, int optmin, int optmax) {
  if (l > r) return;
  int mid = (l + r) / 2;
  addEdges(l, mid - 1);
  if (!DSU.isBipartite)
    opt[mid] = optmax + 1;
  else {
    for (int i = optmax; i >= optmin && i >= mid; i--) {
      DSU.join(U[i], V[i]);
      if (!DSU.isBipartite) {
        opt[mid] = i;
        break;
      }
    }
  }
  removeEdges(opt[mid], optmax);
  removeEdges(l, mid - 1);
  addEdges(opt[mid] + 1, optmax);
  DivAndConquer(l, mid - 1, optmin, opt[mid]);
  removeEdges(opt[mid] + 1, optmax);
  addEdges(l, mid);
  DivAndConquer(mid + 1, r, opt[mid], optmax);
  removeEdges(l, mid);
}
int main() {
  scanf("%d %d %d", &n, &m, &q);
  DSU.init(n);
  for (int i = 1; i <= m; i++) scanf("%d %d", &U[i], &V[i]);
  int last = -1;
  for (int i = 1; i <= m; i++) {
    DSU.join(U[i], V[i]);
    if (!DSU.isBipartite) {
      last = i + 1;
      break;
    }
  }
  if (DSU.isBipartite) {
    for (int i = 1; i <= q; i++) printf("NO\n");
    return 0;
  }
  for (int i = last; i <= m; i++) opt[i] = m + 1;
  removeEdges(1, last - 1);
  DivAndConquer(1, last, 1, m);
  for (int i = 1; i <= q; i++) {
    int L, R;
    scanf("%d %d", &L, &R);
    if (R < opt[L])
      printf("YES\n");
    else
      printf("NO\n");
  }
}
