#include <bits/stdc++.h>
using namespace std;
struct dsu_with_rollbacks {
  vector<int> parent, color, siz;
  vector<vector<int>> rollbacks;
  dsu_with_rollbacks(int n) {
    parent.clear();
    parent.resize(n + 1);
    color.clear();
    color.resize(n + 1);
    siz.clear();
    siz.resize(n + 1);
    rollbacks.clear();
    for (int i = 1; i <= n; ++i) {
      parent[i] = i;
      siz[i] = 1;
    }
  }
  pair<int, int> find(int u) {
    int switch_color = 0;
    while (parent[u] != u) {
      switch_color ^= color[u];
      u = parent[u];
    }
    return make_pair(u, switch_color);
  }
  bool unite(int _u, int _v) {
    pair<int, int> u = find(_u), v = find(_v);
    if (u.first == v.first) {
      if (u.second == v.second) {
        return false;
      } else {
        rollbacks.push_back({0, 0, 0, 0});
        return true;
      }
    }
    if (siz[u.first] > siz[v.first]) {
      swap(u, v);
    }
    rollbacks.push_back({v.first, siz[v.first], u.first, color[u.first]});
    siz[v.first] += siz[u.first];
    parent[u.first] = v.first;
    color[u.first] = u.second ^ v.second ^ 1;
    return true;
  }
  void rollback() {
    if (rollbacks.back()[0] != 0) {
      siz[rollbacks.back()[0]] = rollbacks.back()[1];
      parent[rollbacks.back()[2]] = rollbacks.back()[2];
      color[rollbacks.back()[2]] = rollbacks.back()[3];
    }
    rollbacks.pop_back();
  }
};
void divide_and_conquer(int l_1, int l_2, int r_1, int r_2,
                        vector<vector<int>>& edges, vector<int>& min_r,
                        dsu_with_rollbacks& dsu) {
  int l_mid = (l_1 + l_2) >> 1;
  int added = 0;
  for (int i = l_1; i < l_mid; ++i) {
    dsu.unite(edges[i][0], edges[i][1]);
    added++;
  }
  min_r[l_mid] = r_2;
  while (min_r[l_mid] > max(l_mid, r_1)) {
    if (dsu.unite(edges[min_r[l_mid]][0], edges[min_r[l_mid]][1])) {
      min_r[l_mid]--;
      added++;
    } else {
      break;
    }
  }
  while (added > 0) {
    dsu.rollback();
    added--;
  }
  if (l_1 <= l_mid - 1) {
    for (int i = min_r[l_mid] + 1; i <= r_2; ++i) {
      dsu.unite(edges[i][0], edges[i][1]);
      added++;
    }
    divide_and_conquer(l_1, l_mid - 1, r_1, min_r[l_mid], edges, min_r, dsu);
    while (added > 0) {
      dsu.rollback();
      added--;
    }
  }
  if (l_mid + 1 <= l_2) {
    for (int i = l_1; i <= l_mid; ++i) {
      dsu.unite(edges[i][0], edges[i][1]);
      added++;
    }
    divide_and_conquer(l_mid + 1, l_2, max(l_mid + 1, min_r[l_mid]), r_2, edges,
                       min_r, dsu);
    while (added > 0) {
      dsu.rollback();
      added--;
    }
  }
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  int n, m, q;
  cin >> n >> m >> q;
  vector<vector<int>> edges(m + 1, vector<int>(2));
  for (int i = 1; i <= m; ++i) {
    cin >> edges[i][0] >> edges[i][1];
  }
  vector<int> min_r(m + 1);
  dsu_with_rollbacks dsu(n);
  int max_l = 1;
  for (; max_l < m; ++max_l) {
    if (!dsu.unite(edges[max_l][0], edges[max_l][1])) {
      break;
    }
  }
  for (int i = max_l + 1; i <= m; ++i) {
    min_r[i] = m + 1;
  }
  dsu = dsu_with_rollbacks(n);
  divide_and_conquer(1, max_l, 1, m, edges, min_r, dsu);
  while (q--) {
    int l, r;
    cin >> l >> r;
    cout << (min_r[l] <= r ? "NO" : "YES") << '\n';
  }
  return 0;
}
