#include<bits/stdc++.h>
using namespace std;
template<typename T>
inline void read(T &x){
	x=0;
	bool flag=false;
	char c=getchar();
	while (c<'0' || c>'9'){
		flag^=(c=='-');
		c=getchar();
	}
	while (c>='0' && c<='9'){
		x=(x<<3)+(x<<1)+(c^48);
		c=getchar();
	}
	x=flag?-x:x;
}
template<typename T>
inline void write(T x){
	if (x<0){
		putchar('-');
		x=-x;
	}
	if (x>9) write(x/10);
	putchar(x%10+'0');
}
template<typename T>
inline void write(T x,char c){
	write(x),putchar(c);
}
template<typename Ty=int,Ty MIN=INT_MIN+1,Ty MAX=INT_MAX>
class ScapegoatTree{
	#define alpha (0.6)
	private:
		struct Node{
			Node *l,*r;
			int size;
			int nodecnt;
			bool deleted;
			Ty val;
			bool check(){
				return (l->nodecnt)>(alpha*nodecnt) || (r->nodecnt)>(alpha*nodecnt);
			}
			void pushup(){
				size=(!deleted)+l->size+r->size;
				nodecnt=1+l->nodecnt+r->nodecnt;
			}
		};
		typedef Node* nodeptr;
		nodeptr null;
		nodeptr newNode(Ty v=Ty()){
			nodeptr ans=new Node;
			ans->l=ans->r=null;
			ans->val=v;
			ans->deleted=false;
			ans->pushup();
			return ans;
		}
		nodeptr root=null;
		void disassemble(nodeptr p,vector<nodeptr> &vec){
			if (p==null) return;
			disassemble(p->l,vec);
			if (!p->deleted) vec.push_back(p);
			disassemble(p->r,vec);
			if (p->deleted) delete p;
		}
		nodeptr structure(vector<nodeptr> &vec,int l,int r){
			if (l>=r) return null;
			int mid=(l+r)>>1;
			nodeptr nxt=vec[mid];
			nxt->l=structure(vec,l,mid);
			nxt->r=structure(vec,mid+1,r);
			nxt->pushup();
			return nxt;
		}
		void restructure(nodeptr &p){
			vector<nodeptr> vec;
			disassemble(p,vec);
			p=structure(vec,0,vec.size());
		}
		void insert(nodeptr &p,Ty v){
			if (p==null){
				p=newNode(v);
				return;
			}
			p->size++;
			p->nodecnt++;
			if (p->val<v) insert(p->r,v);
			else insert(p->l,v);
			if (p->check()) restructure(p);
		}
		void erase(nodeptr &p,Ty v){
			if (p==null) return;
			if (p->val<v) erase(p->r,v);
			else if (v<p->val) erase(p->l,v);
			else if (!p->deleted) p->deleted=true;
			else erase(p->l,v);
			p->size--;
		}
		int getrank(nodeptr p,Ty v){
			int ans=1;
			while (p!=null){
				if (p->val<v){
					ans+=p->l->size+!p->deleted;
					p=p->r;
				}
				else p=p->l;
			}
			return ans;
		}
		Ty getval(nodeptr p,int k){
			while (p!=null){
				if (!p->deleted && p->l->size+(!p->deleted)==k) return p->val;
				if (p->l->size<k){
					k-=p->l->size+(!p->deleted);
					p=p->r;
				}
				else p=p->l;
			}
		}
		void debug(nodeptr p){
			if(p==null) return;
			debug(p->l);
			write(p->val,' ');
			debug(p->r);
		}
		Ty getpre(nodeptr p,Ty v){
			if (p==null) return MIN;
			if (p->val<v) return max(!p->deleted?p->val:MIN,getpre(p->r,v));
			else if (v<p->val) return getpre(p->l,v);
			else return getpre(p->l,v);
		}
		Ty getaft(nodeptr p,Ty v){
			if (p==null) return MAX;
			if (p->val<v) return getaft(p->r,v);
			else if (v<p->val) return min(!p->deleted?p->val:MAX,getaft(p->l,v));
			else return getaft(p->r,v);
		}
	public:
		ScapegoatTree(){
			null=new Node;
			null->l=null->r=null;
			null->val=Ty();
			null->deleted=false;
			null->size=0;
			null->nodecnt=0;
			root=null;
		}
		void insert(Ty v){
			insert(root,v);
		}
		void erase(Ty v){
			erase(root,v);
		}
		int getrank(Ty v){
			return getrank(root,v);
		}
		Ty getval(int k){
			return getval(root,k);
		}
		Ty getpre(Ty x){
			return getval(getrank(x)-1);
		}
		Ty getaft(Ty x){
			return getval(getrank(x+1));
		}
		void debug(){
			debug(root);
			putchar('\n');
		}
	#undef alpha
};
ScapegoatTree<int> st;
int n,opt,x;
signed main(){
	read(n);
	while (n--){
		read(opt),read(x);
		if (opt==1) st.insert(x);
		if (opt==2) st.erase(x);
		if (opt==3) write(st.getrank(x),'\n');
		if (opt==4) write(st.getval(x),'\n');
		if (opt==5) write(st.getpre(x),'\n');
		if (opt==6) write(st.getaft(x),'\n');
		if (opt==7) st.debug();
	}
}