#include <bits/stdc++.h>

using namespace std;
#define int long long

struct change {
    int *cell, val, time;
};

struct DSU {
    vector<int> p, sz, len;
    vector<change> changes;
    int flag, timer;

    void init(int n) {
        p.resize(n), sz.resize(n), len.resize(n);
        for (int i = 0; i < n; i++)
            p[i] = i, sz[i] = 1, len[i] = 0;
        flag = -1, timer = 0;
    }

    void undo() {
        if (changes.empty()) return;
        int time = changes.back().time;
        if (time == flag) flag = -1;
        while (!changes.empty() &&
               changes.back().time == time) {
            *changes.back().cell = changes.back().val;
            changes.pop_back();
        }
    }

    pair<int, int> find(int v) {
        if (v == p[v]) return {v, 0};
        auto pr = find(p[v]);
        return {pr.first, (pr.second + len[v]) % 2};
    }

    bool isBipartite() {
        return flag == -1;
    }

    void unite(int u, int v) {
        timer++;
        auto P = find(u), Q = find(v);
        int p1 = P.first, p2 = Q.first;
        if (sz[p1] > sz[p2]) swap(p1, p2), swap(P, Q);
        if (p1 == p2) {
            if (P.second == Q.second && flag == -1) flag = timer;
            changes.emplace_back(&p[p1], p1, timer);
            return;
        }
        changes.emplace_back(&p[p1], p[p1], timer);
        p[p1] = p2;
        changes.emplace_back(&len[p1], len[p1], timer);
        len[p1] = (P.second + Q.second + 1) % 2;
        changes.emplace_back(&sz[p2], sz[p2], timer);
        sz[p2] += sz[p1];
    }
};

struct update {
    char type;
    int u, v;
};

struct QueueUndoTrick {
    DSU T;
    int bottom;
    vector<update> updates;

    void init(int n) {
        T.init(n);
        bottom = 0;
    }

    void advance_bottom() {
        while (bottom < updates.size() && updates[bottom].type == 'B') bottom++;
    }

    void reverse_updates() {
        for (int i = 0; i < (int) updates.size(); i++)
            T.undo();
        reverse(updates.begin(), updates.end());
        for (int i = 0; i < (int) updates.size(); i++) {
            T.unite(updates[i].u, updates[i].v);
            updates[i].type = 'A';
        }
        bottom = 0;
    }

    void fix() {
        if (updates.empty() || updates.back().type == 'A') return;
        advance_bottom();
        vector<update> saveA, saveB = {updates.back()};
        updates.pop_back(), T.undo();
        while (saveA.size() != saveB.size() && updates.size() > bottom) {
            if (updates.back().type == 'A')
                saveA.emplace_back(updates.back());
            else
                saveB.emplace_back(updates.back());
            T.undo();
            updates.pop_back();
        }
        reverse(saveA.begin(), saveA.end());
        reverse(saveB.begin(), saveB.end());
        for (auto &u: saveB)
            updates.emplace_back(u), T.unite(u.u, u.v);
        for (auto &u: saveA)
            updates.emplace_back(u), T.unite(u.u, u.v);
        advance_bottom();
    }

    void undo() {
        advance_bottom();
        if (bottom == updates.size())
            reverse_updates();
        fix();
        T.undo();
        updates.pop_back();
    }

    void unite(int u, int v) {
        T.unite(u, v);
        updates.emplace_back('B', u, v);
    }

    bool isBipartite() {
        return T.isBipartite();
    }
};

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    int n, m, q;
    cin >> n >> m >> q;
    QueueUndoTrick T;
    vector<pair<int, int>> e(m);
    for (int i = 0; i < m; i++) {
        cin >> e[i].first >> e[i].second;
        e[i].first--, e[i].second--;
    }
    T.init(n);
    int r = -1, right[m];
    for (int i = 0; i < m; i++)
        T.unite(e[i].first, e[i].second);
    for (int i = 0; i < m; i++) {
        while (r + 1 < m && !T.isBipartite()) {
            T.undo();
            r++;
        }
        if (T.isBipartite())
            right[i] = r;
        else right[i] = (int) 1e9;
        T.unite(e[i].first, e[i].second);
    }
    for (int i = 0; i < q; i++) {
        int L, R;
        cin >> L >> R;
        if (right[L - 1] <= R - 1)
            cout << "NO\n";
        else
            cout << "YES\n";
    }
    return 0;
}