#include <bits/stdc++.h>

#pragma GCC optimize("Ofast")

using namespace std;

ifstream fin("elmaj.in");
ofstream fout("elmaj.out");

template <typename T>
struct Fenwick {
	int N;
	int LGN;
	vector<T> tree;

	Fenwick () {

	}

	Fenwick (int size) {
		N = size;
		LGN = __lg(N);
		tree = vector<T> (size);
	}

	Fenwick& operator = (const Fenwick &_) {
		N = _.N;
		LGN = _.LGN;
		tree = _.tree;
		return *this;
	}

	int lsb(int i) {
		return i & (-i);
	}

	void update(int position, int value) {
		for(int i = position; i <= N; i += lsb(i)) {
			tree[i] += value;
		}
	}

	int query(int position) {
		int ret = 0;
		for(int i = position; i > 0; i -= lsb(i)) {
			ret += tree[i];
		}
		return ret;
	}

	int query(int left, int right) {
		return query(right) - query(left - 1);
	}

	int search(int value) {
		int sum = 0, pos = 0, ret = 0;
		for(int i = LGN; i >= 0; i--) {
			if(pos + (1 << i) <= N) {
				if(sum + tree[pos + (1 << i)] <= value) {
					sum += tree[pos + (1 << i)];
					pos += (1 << i);

					ret = pos;
				}
			}
		}

		return ret;
	}
};

struct Query {
	int TYPE;
	int value;
};
vector<Query> Queries;

vector<int> values;
int normalize(int value) {
	return distance(values.begin(), lower_bound(values.begin(), values.end(), value)) + 1;
}

int N;
vector<int> freq;
Fenwick<int> DS;

const int error_message = -1;

void Insert(int value) {
	N++;
	freq[value]++;
	DS.update(value, 1);
}

void Erase(int value) {
	assert(freq[value] > 0);
	N--;
	freq[value]--;
	DS.update(value, -1);
}

int MajorityQuery() {
	int value = DS.search(N / 2) + 1;

	// cout << (N + 1) / 2 << " " << value << " " << values[value - 1] << " " << DS.query(value) << '\n';

	if(value == 0) {
		return error_message;
	}

	if(freq[value] > N / 2) {
		return value;
	}
	return error_message;
}

int main() {
	int Q;
	fin >> Q;
	Queries = vector<Query> (Q);

	for(auto &q: Queries) {
		int TYPE = 1, value;
		fin >> value;
		q = {TYPE, value};
	}
	Queries.push_back({3, 0});

	for(const auto &q: Queries) {
		if(q.TYPE < 3) {
			values.push_back(q.value);
		}
	}
	sort(values.begin(), values.end());
	values.erase(unique(values.begin(), values.end()), values.end());
	for(auto &q: Queries) {
		if(q.TYPE < 3) {
			q.value = normalize(q.value);
		}
	}

	freq = vector<int> (values.size() + 1);
	DS = Fenwick<int> (values.size() + 1);

	for(const auto &q: Queries) {
		if(q.TYPE == 1) {
			Insert(q.value);
		} else if(q.TYPE == 2) {
			Erase(q.value);
		} else {
			fout << values[MajorityQuery() - 1] << " " << freq[MajorityQuery()] << '\n';
		}
	}
	return 0;
}