#include <iostream>
#include <cstring>
#include <stack>
#include <algorithm>
#include <vector>
using namespace std;

typedef pair<int, int> PII;
const int N = 4e5 + 10;
int n, m, q, p[N];
PII links[N];
bool edge_st[N];
vector<int> all;
vector<PII> g[N];
stack<string> res;

struct oper {
    int op, u, v;
} opers[N];

int query(int x) {
    int l = 0, r = all.size() - 1;
    while (l < r) {
        int mid = l + r >> 1;
        if (all[mid] >= x) {
            r = mid;
        } else {
            l = mid + 1;
        }
    }

    return l + 1;
}

int find(int x) {
    if (x != p[x]) {
        p[x] = find(p[x]);
    }
    return p[x];
}

bool exist(int u, int v) {
    int l = 0, r = g[u].size() - 1;
    if (r == -1) {
        return false;
    }
    while (l < r) {
        int mid = l + r >> 1;
        if (g[u][mid].first >= v) {
            r = mid;
        } else {
            l = mid + 1;
        }
    }

    return g[u][l].first == v;
}

int main() {
    cin >> n >> m >> q;
    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        if (u > v) {
            swap(u, v);
        }
        all.push_back(u), all.push_back(v);
        links[i] = {u, v};
    }

    for (int i = 0; i < q; i++) {
        int op, u, v;
        cin >> op >> u >> v;
        opers[i] = {op, u, v};
        all.push_back(u), all.push_back(v);
    }

    sort(all.begin(), all.end());
    all.erase(unique(all.begin(), all.end()), all.end());

    memset(edge_st, true, sizeof edge_st);
    sort(links, links + m);


    for (int i = 0; i < m; i++) {
        auto e = links[i];
        int u_i = query(e.first), v_i = query(e.second);
        g[u_i].push_back({v_i, i});
    }

    for (int i = 0; i < q; i++) {
        auto tmp = opers[i];
        int op = tmp.op, u = query(tmp.u), v = query(tmp.v);
        if (op == 1) {
            if (u > v) {
                swap(u, v);
            }

            int l = 0, r = g[u].size() - 1;
            if (r == -1) {
                continue;
            }
            while (l < r) {
                int mid = l + r >> 1;
                if (g[u][mid].first >= v) {
                    r = mid;
                } else {
                    l = mid + 1;
                }
            }

            if (g[u][l].first == v) {
                edge_st[g[u][l].second] = false;
            }
        }
    }


    for (int i = 1; i <= all.size(); i++) {
        p[i] = i;
    }

    for (int i = 0; i < m; i++) {
        if (edge_st[i]) {
            int u = links[i].first, v = links[i].second;
            int u_i = query(u), v_i = query(v);
            int pu_i = find(u_i), pv_i = find(v_i);
            if (pu_i != pv_i) {
                p[pu_i] = pv_i;
            }
        }
    }

    for (int i = q - 1; i >= 0; i--) {
        int u = query(opers[i].u), v = query(opers[i].v);
        if (opers[i].op == 1) {
            if (u > v) {
                swap(u, v);
            }
            if (exist(u, v)) {
                int pu_i = find(u), pv_i = find(v);
                if (pu_i != pv_i) {
                    p[pu_i] = pv_i;
                }
            }
        } else {
            int pu_i = find(u), pv_i = find(v);
            if (pu_i != pv_i) {
                res.push("No");
            } else {
                res.push("Yes");
            }
        }
    }

    while (!res.empty()) {
        cout << res.top() << endl;
        res.pop();
    }

    return 0;
}