// Problem: P11369 [Ynoi2024] 弥留之国的爱丽丝
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P11369
// Memory Limit: 512 MB
// Time Limit: 8000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
#define pb emplace_back
#define fst first
#define scd second
#define mkp make_pair
#define uint unsigned
#define mems(a, x) memset((a), (x), sizeof(a))

using namespace std;
typedef long long ll;
typedef double db;
typedef unsigned long long ull;
typedef long double ldb;
typedef pair<int, int> pii;

const int maxn = 100100;
const int B = 220;

int n, m, q, et, c[maxn];
pii a[maxn], d[maxn];
bool mk[maxn], vis[maxn];

struct oper {
	int o, x, y;
} b[maxn];

int dfn[maxn], low[maxn], tim, stk[maxn], top, scc[maxn], cnt;
int p[maxn], K;

inline int ID(int x) {
	return lower_bound(p + 1, p + K + 1, x) - p;
}

struct graph {
	int hd[maxn], len, to[maxn], nxt[maxn];
	
	inline void init() {
		for (int i = 1; i <= n; ++i) {
			hd[i] = 0;
		}
		len = 0;
	}
	
	inline void add_edge(int u, int v) {
		to[++len] = v;
		nxt[len] = hd[u];
		hd[u] = len;
	}
} G, T;

void tarjan(int u) {
	dfn[u] = low[u] = ++tim;
	stk[++top] = u;
	for (int i = G.hd[u]; i; i = G.nxt[i]) {
		int v = G.to[i];
		if (!dfn[v]) {
			tarjan(v);
			low[u] = min(low[u], low[v]);
		} else if (!scc[v]) {
			low[u] = min(low[u], dfn[v]);
		}
	}
	if (dfn[u] == low[u]) {
		++cnt;
		while (1) {
			int x = stk[top--];
			scc[x] = cnt;
			if (x == u) {
				break;
			}
		}
	}
}

bitset<445> f[maxn], g[445], h[445];

inline bool query(int x, int y) {
	bitset<445> vis, cur;
	vis.reset();
	cur.reset();
	for (int i = 1; i <= K; ++i) {
		h[i].reset();
	}
	for (int i = 1; i <= et; ++i) {
		if (mk[c[i]]) {
			h[d[i].fst].set(d[i].scd);
		}
	}
	vis.set(x);
	while (1) {
		if (vis.test(y)) {
			return 1;
		}
		int u = (vis ^ cur)._Find_first();
		if (u > K) {
			return 0;
		}
		cur.set(u);
		vis |= g[u] | h[u];
	}
}

inline void solve(int L, int R) {
	tim = top = cnt = K = et = 0;
	mems(dfn, 0);
	mems(low, 0);
	mems(stk, 0);
	mems(scc, 0);
	mems(vis, 0);
	for (int i = L; i <= R; ++i) {
		if (b[i].o == 1) {
			p[++K] = a[b[i].x].fst;
			p[++K] = a[b[i].x].scd;
			vis[b[i].x] = 1;
			c[++et] = b[i].x;
		} else {
			p[++K] = b[i].x;
			p[++K] = b[i].y;
		}
	}
	sort(p + 1, p + K + 1);
	K = unique(p + 1, p + K + 1) - p - 1;
	sort(c + 1, c + et + 1);
	et = unique(c + 1, c + et + 1) - c - 1;
	for (int i = 1; i <= et; ++i) {
		d[i] = mkp(ID(a[c[i]].fst), ID(a[c[i]].scd));
	}
	G.init();
	T.init();
	for (int i = 1; i <= m; ++i) {
		if (!vis[i] && mk[i]) {
			G.add_edge(a[i].fst, a[i].scd);
		}
	}
	for (int i = 1; i <= n; ++i) {
		if (!dfn[i]) {
			tarjan(i);
		}
	}
	for (int u = 1; u <= n; ++u) {
		for (int i = G.hd[u]; i; i = G.nxt[i]) {
			int v = G.to[i];
			if (scc[u] != scc[v]) {
				T.add_edge(scc[u], scc[v]);
			}
		}
	}
	for (int i = 1; i <= K; ++i) {
		f[scc[p[i]]].set(i);
	}
	for (int u = 1; u <= cnt; ++u) {
		for (int i = T.hd[u]; i; i = T.nxt[i]) {
			int v = T.to[i];
			f[u] |= f[v];
		}
	}
	for (int i = 1; i <= K; ++i) {
		for (int j = 1; j <= K; ++j) {
			g[i][j] = f[scc[p[i]]].test(j);
		}
	}
	for (int i = L; i <= R; ++i) {
		int o = b[i].o, x = b[i].x, y = b[i].y;
		if (o == 1) {
			mk[x] ^= 1;
		} else {
			puts(query(ID(x), ID(y)) ? "YES" : "NO");
		}
	}
}

void solve() {
	scanf("%d%d%d", &n, &m, &q);
	for (int i = 1; i <= m; ++i) {
		scanf("%d%d", &a[i].fst, &a[i].scd);
		mk[i] = 1;
	}
	for (int i = 1; i <= q; ++i) {
		scanf("%d%d", &b[i].o, &b[i].x);
		if (b[i].o == 2) {
			scanf("%d", &b[i].y);
		}
	}
	for (int i = 1; i <= q; i += B) {
		solve(i, min(i + B - 1, q));
		for (int j = i; j <= min(i + B - 1, q); ++j) {
			if (b[j].o == 1) {
				mk[b[j].x] ^= 1;
			}
		}
	}
}

int main() {
	int T = 1;
	// scanf("%d", &T);
	while (T--) {
		solve();
	}
	return 0;
}