#include <iostream>
#include <cmath>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <unordered_map>
using namespace std;

#define int long long

const int N = 1e4 + 5, INF = INT_MAX, MINF = INT_MIN + 1;

unordered_map<int, bool> p;

int n, idx, root;

class Treap
{
public:
	struct Node
	{
		int l, r, val, cnt, sz, key;
	}tr[N];
	int get_node(int key)
	{
		tr[++idx].key = key;
		tr[idx].sz = tr[idx].cnt = 1;
		tr[idx].val = rand();
		return idx;
	}
	void pushup(int u)
	{
		tr[u].sz = tr[tr[u].l].sz + tr[tr[u].r].sz + tr[u].cnt;
	}
	void zig(int& x)
	{
		int q = tr[x].l;
		tr[x].l = tr[q].r, tr[q].r = x, x = q;
		pushup(tr[x].r), pushup(x);
	}
	void zag(int& x)
	{
		int q = tr[x].r;
		tr[x].r = tr[q].l, tr[q].l = x, x = q;
		pushup(tr[x].l), pushup(x);
	}
	void build()
	{
		get_node(MINF), get_node(INF);
		root = 1, tr[1].r = 2;
		pushup(root);
		if (tr[1].val < tr[2].val) zag(root);
	}
	void insert(int& x, int key)
	{
		if (!x) x = get_node(key);
		else if (tr[x].key == key) tr[x].cnt++;
		else if (tr[x].key > key)
		{
			insert(tr[x].l, key);
			if (tr[tr[x].l].val > tr[x].val) zig(x);
		}
		else
		{
			insert(tr[x].r, key);
			if (tr[tr[x].r].val > tr[x].val) zag(x);
		}
		pushup(x);
	}
	int get_key(int p, int rank)
	{
		if (!p) return INF;
		if (tr[tr[p].l].sz >= rank) return get_key(tr[p].l, rank);
		if (tr[tr[p].l].sz + tr[p].cnt >= rank) return tr[p].key;
		return get_key(tr[p].r, rank - tr[tr[p].l].sz - tr[p].cnt);
	}
	int get_rank(int x, int key)
	{
		if (!x) return 0;
		if (tr[x].key == key) return tr[tr[x].l].sz + 1;
		if (tr[x].key > key) return get_rank(tr[x].l, key);
		return tr[tr[x].l].sz + tr[x].cnt + get_rank(tr[x].r, key);
	}
	int get_prev(int x, int key)
	{
		if (!x) return MINF;
		if (tr[x].key >= key) return get_prev(tr[x].l, key);
		return max(tr[x].key, get_prev(tr[x].r, key));
	}
	int get_next(int x, int key)
	{
		if (!x) return INF;
		if (tr[x].key <= key) return get_next(tr[x].r, key);
		return min(tr[x].key, get_next(tr[x].r, key));
	}
	void del(int& x, int key)
	{
		if (!x) return;
		if (tr[x].key == key)
		{
			if (tr[x].cnt > 1) tr[x].cnt--;
			else if (tr[x].l || tr[x].r)
			{
				if (!tr[x].r || tr[tr[x].l].val > tr[tr[x].r].val)
				{
					zig(x);
					del(tr[x].r, key);
				}
				else
				{
					zag(x), del(tr[x].l, key);
				}
			}
			else tr[x].cnt--, tr[x].sz--, x = 0;
		}
		else if (tr[x].key > key) del(tr[x].l, key);
		else del(tr[x].r, key);
		pushup(x);
	}
};

Treap tp;

signed main()
{
	int cnt = 0;
	tp.build();
	scanf("%lld", &n);
	while (n--)
	{
		int op, x;
		scanf("%lld%lld", &op, &x);
		if (op == 1)
		{
			tp.insert(root, x);
			printf("%lld\n", tp.get_rank(root, x) - 1);
			tp.del(root, x);
		}
		else if (op == 2)
		{
			if (x > cnt) printf("%lld\n", INF);
			else printf("%lld\n", tp.get_key(root, x + 1));
		}
		else if (op == 3)
		{
			tp.insert(root, x);
			printf("%lld\n", tp.get_prev(root, x));
			tp.del(root, x);
		}
		else if (op == 4) tp.insert(root, x), printf("%lld\n", tp.get_next(root, x)), tp.del(root, x);
		else tp.insert(root, x), cnt++, p[x] = true;
	}
	return 0;
}