#include<bits/stdc++.h>
#define INF 1000000000
using namespace std;

struct Node
{
	int Val, Key, Cnt, Size, Lson, Rson;
} a[1000019];
int til, Root;

void Add(int v)
{
	a[++til].Val = v;
	a[til].Cnt = 1;
	a[til].Size = 1;
	a[til].Key = rand();
}

void Pushup(int cur)
{
	a[cur].Size = a[a[cur].Lson].Size + a[a[cur].Rson].Size + a[cur].Cnt;
}

void Build()
{
	Add(-INF);
	Root = til;
	Add(INF);
	a[Root].Rson = til;
	Pushup(Root);
}

void zig(int &cur)
{
	int rs = a[cur].Rson;
	a[cur].Rson = a[rs].Lson;
	a[rs].Lson = cur;
	cur = rs;
	Pushup(a[cur].Lson), Pushup(cur);
}
void zag(int &cur)
{
	int ls = a[cur].Lson;
	a[cur].Lson = a[ls].Rson;
	a[ls].Rson = cur;
	cur = ls;
	Pushup(a[cur].Rson), Pushup(cur);
}

void Insert(int &cur, int val)
{
	if(!cur)
	{
		Add(val);
		cur = til;
		return;
	}
	if(a[cur].Val == val)
		a[cur].Cnt++;
	else
	{
		if(val < a[cur].Val)
		{
			Insert(a[cur].Lson, val);
			if(a[cur].Key < a[a[cur].Lson].Key)
				zag(cur);
		}
		else	
		{
			Insert(a[cur].Rson, val);
			if(a[cur].Key < a[a[cur].Rson].Key)
				zig(cur);
		}
		Pushup(cur);
	}
}

void Del(int cur, int val)
{
	if(!cur)
		return;
	if(val == a[cur].Val)
	{
		if(a[cur].Cnt > 1)
		{
			a[cur].Cnt--, a[cur].Size--;
			return;
		}
		if(a[cur].Lson || a[cur].Rson)
		{
			if(!a[cur].Rson || a[a[cur].Rson].Key > a[a[cur].Lson].Key)	
				zag(cur), Del(a[cur].Rson, val);
			else
				zig(cur), Del(a[cur].Lson, val);
			Pushup(cur);
		}
		else
			cur = 0;
		return;
	}
	if(val < a[cur].Val)
		Del(a[cur].Lson, val);
	else
		Del(a[cur].Rson, val);
	Pushup(cur);
}

int GetRank(int cur, int val)
{
	if(!cur)
		return 1;
	if(val == a[cur].Val)
		return a[a[cur].Lson].Size + 1;
	else
	{
		if(val < a[cur].Val)
			return GetRank(a[cur].Lson, val);
		else
			return GetRank(a[cur].Rson, val) + a[a[cur].Lson].Size + a[cur].Cnt;
	}
}

int GetVal(int cur, int rk)
{
	if(!cur)
		return INF;
	if(a[a[cur].Lson].Size >= rk)
		return GetVal(a[cur].Lson, rk);
	else
	{
		if(rk <= a[a[cur].Lson].Size + a[cur].Cnt)
			return a[cur].Val;
		else
			return GetVal(a[cur].Rson, rk - a[a[cur].Lson].Size - a[cur].Cnt);
	}
}

int GetPrev(int val)
{
	int cur = Root, pre;
	while(cur)
	{
		if(a[cur].Val < val)
			pre = a[cur].Val, cur = a[cur].Rson;
		else
			cur = a[cur].Lson;
	}
	return pre;
}

int GetNext(int val)
{
	int cur = Root, nex;
	while(cur)
	{
		if(a[cur].Val > val)
			nex = a[cur].Val, cur = a[cur].Lson;
		else
			cur = a[cur].Rson;
	}
	return nex;
}

int main()
{
	Build();
	int T; cin >> T;
	while(T--)
	{
		int opt, v;
		cin >> opt >> v;
		if(opt == 1)
			Insert(Root, v);
		if(opt == 2)
			Del(Root, v);
		if(opt == 3)
			cout << GetRank(Root, v) - 1 << endl;
		if(opt == 4)
			cout << GetVal(Root, v + 1) << endl;
		if(opt == 5)
			cout << GetPrev(v) << endl;
		if(opt == 6)
			cout << GetNext(v) << endl;
	}
	return 0;
}