#include <bits/stdc++.h>

using namespace std;

const int N = 1e6 + 50;

int n, m, q, X[N], Y[N], AL[N], AR[N], atot, ans[2][N];
int start[N], rt[4], ch[N << 2][2], mx[N << 2], tot;
vector<pair<int, int>> ops;

int newnode() {
	++tot;
	ch[tot][0] = ch[tot][1] = mx[tot] = 0;
	return tot;
}

void upd(int &o, int l, int r, int ql, int qr, int x) {
	if (ql > qr) return;
	if (!o) {
		o = newnode();
	}
	if (ql <= l && r <= qr) {
		mx[o] = max(mx[o], x);
	}
	else {
		const int mid = l + r >> 1;
		if (ql <= mid) {
			upd(ch[o][0], l, mid, ql, qr, x);
		}
		if (qr > mid) {
			upd(ch[o][1], mid + 1, r, ql, qr, x);
		}
	}
}

int query(int &o, int l, int r, int x) {
	if (!o)
		return 0;
	if (l == r)
		return mx[o];
	const int mid = l + r >> 1;
	if (x <= mid)
		return max(mx[o], query(ch[o][0], l, mid, x));
	else
		return max(mx[o], query(ch[o][1], mid + 1, r, x));
}

int main() {
	cin >> n >> m >> q;
	memset(start, -1, sizeof start);
	for (int i = 1; i <= m; ++i) {
		cin >> X[i] >> Y[i];
		start[i] = 0;
	}
	for (int _ = 1; _ <= q; ++_) {
		int op;
		cin >> op;
		if (op == 1) {
			int p;
			cin >> p;
			++atot;
			ans[0][atot] = X[p];
			ans[1][atot] = Y[p];
			assert(start[p] >= 0);
			AL[atot] = start[p];
			AR[atot] = (int)(ops.size()) - 1;
		}
		else if (op == 2) {
			int p;
			cin >> p;
			ops.emplace_back(p, 0);
		}
		else if (op == 3) {
			int p;
			cin >> p;
			ops.emplace_back(p, 1);
		}
		else if (op == 4) {
			++m;
			int x, y;
			cin >> x >> y;
			X[m] = x, Y[m] = y;
			start[m] = ops.size();
		}
		else throw;
	}
	vector<int> qq;
	for (int i = 1; i <= atot; ++i) {
		int l = AL[i], r = AR[i];
		if (l <= r) {
			qq.push_back(i);
		}
	}
	function<void(int, int, const vector<int>&)> solve = [&](int l, int r, const vector<int> &qq) {
		if (qq.empty())
			return;
		rt[0] = rt[1] = rt[2] = rt[3] = tot = 0;
		const int mid = l + r >> 1;
		vector<int> qql, qqr, qq_cur;
		array<vector<pair<int, int>>, 2> qu;
		for (int i = l; i <= r; ++i) {
			auto [x, op] = ops[i];
			int ql = query(rt[!op], 0, n, x), qr = n - x - 1;
			qu[op].emplace_back(x, ql);
			upd(rt[op], 0, n, ql, qr, x + 1);
		}
		for (auto x : qq) {
			int wl = AL[x], wr = AR[x];
			//printf("wl = %d, wr = %d, l = %d, r = %d\n", wl, wr, l, r);
			if (wl <= l && r <= wr) {
				qq_cur.push_back(x);
			}
			else {
				if (wl <= mid) {
					qql.push_back(x);
				}
				if (wr > mid) {
					qqr.push_back(x);
				}
			}
		}
		for (int o : {0, 1}) {
			sort(qu[o].begin(), qu[o].end(), greater<pair<int, int>>());
			sort(qq_cur.begin(), qq_cur.end(), [&](const int &x, const int &y) {
				return ans[!o][x] > ans[!o][y];
			});
			int pl = 0, pr = 0;
			const auto &f = qu[o];
			while (pl < qq_cur.size()) {
				int x = qq_cur.at(pl);
				while (pr < f.size() && f[pr].first >= ans[!o][x]) {
					int l = f[pr].second, r = n - f[pr].first, v = r;
					upd(rt[o + 2], 0, n, l, r, v);
					++pr;
				}
				int ww = query(rt[o + 2], 0, n, ans[o][x]);
				ans[o][x] = max(ans[o][x], ww);
				++pl;
			}
		}
		solve(l, mid, qql);
		solve(mid + 1, r, qqr);
	};
	solve(0, (int)(ops.size()) - 1, qq);
	for (int i = 1; i <= atot; ++i) {
		cout << ans[0][i] << " " << ans[1][i] << '\n';
	}
	return 0;
}