#include <algorithm>
#include <iostream>
#include <tuple>
#include <unordered_set>
#include <vector>

using namespace std;

struct Bridge {
    Bridge(int node1, int node2) : node1_(min(node1, node2)), node2_(max(node1, node2)) {}
    int node1_;
    int node2_;
};

bool operator==(const Bridge& lhs, const Bridge& rhs) {
    return lhs.node1_ == rhs.node1_ && lhs.node2_ == rhs.node2_;
}

class Dsu {
public:
    Dsu(int size) : parents(size) {
        for (int i = 0; i < parents.size(); ++i) {
            parents[i] = -1;
        }
    }

    bool IsInSameComponent(int u, int v) { return Parent(u) == Parent(v); }

    int Parent(int idx) {
        if (parents[idx] < 0)
            return idx;
        return parents[idx] = Parent(parents[idx]);
    }

    void Union(int u, int v) {
        if (IsInSameComponent(u, v))
            return;

        int pu = Parent(u);
        int pv = Parent(v);
        if (parents[pu] > parents[pv])
            swap(pu, pv);
        parents[pu] += parents[pv];
        parents[pv] = pu;
    }

private:
    vector<int> parents;
};

void Dfs(const vector<vector<int>>& edges, vector<bool>& is_visited,
    unordered_set<Bridge>& result, int node1, int parent, int& time, vector<int>& enter, vector<int>& ret) {
    is_visited[node1] = true;
    time++;
    enter[node1] = time;
    ret[node1] = time;
    for (int node2 : edges[node1]) {
        if (node2 == parent) continue;
        if (is_visited[node2]) {
            ret[node1] = min(ret[node1], enter[node2]);
            continue;
        }
        Dfs(edges, is_visited, result, node2, node1, time, enter, ret);
        ret[node1] = min(ret[node1], ret[node2]);
        if (enter[node1] >= ret[node2]) continue;
        result.insert({ node1, node2 });
    }
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);

    int nodes_count, edges_count, requests_count;
    cin >> nodes_count >> edges_count >> requests_count;
    vector<vector<int>> edges(1 + nodes_count);
    for (int i = 0; i < edges_count; ++i) {
        int node1, node2;
        cin >> node1 >> node2;
        edges[node1].push_back(node2);
        edges[node2].push_back(node1);
    }

    vector<bool> is_visited(1 + nodes_count, false);
    vector<int> enter(1 + nodes_count);
    vector<int> ret(1 + nodes_count);
    unordered_set<Bridge> result;
    int time = 0;
    for (int i = 1; i < is_visited.size(); ++i) {
        if (is_visited[i]) continue;
        Dfs(edges, is_visited, result, i, -1, time, enter, ret);
    }

    Dsu dsu(nodes_count + 1);
    for (int u = 0; u < edges.size(); ++u) {
        for (auto v : edges[u]) {
            if (result.count({ u, v }) || result.count({ v, u })) continue;

            dsu.Union(u, v);
        }
    }

    for (int i = 0; i < requests_count; ++i) {
        int u, v;
        cin >> u >> v;
        if (dsu.IsInSameComponent(u, v)) {
            cout << "YES\n";
        }
        else {
            cout << "NO\n";
        }
    }
    return 0;
}
/*
test1
5 7 5
0 2
0 3
0 4
0 5
1 2
2 3
2 5
0 2
4 5
1 3
2 4
2 5

YES
NO
NO
NO
YES
*/