#include<cstdio>
#include<cstdlib>
#include<ctime>
enum rotate_dir{left=1,right=0};
template<typename T>
class BSTree{
    private:
        struct Node{
            T val;
            Node* ch[2];
            int size,amount,prio;
            Node(){
                ch[0]=ch[1]=NULL;
                size=amount=1;
                prio=rand();
            }
            void updateSize(){
                size=amount;
                if(ch[0])
                    size+=ch[0]->size;
                if(ch[1])
                    size+=ch[1]->size;
            }
        }*root;
        void rotate(Node*& u,rotate_dir dir){
        	Node *tmp=u->ch[dir];
        	u->ch[dir]=tmp->ch[dir^1];
        	tmp->ch[dir^1]=u;
        	tmp->updateSize();
        	u->updateSize();
        	u=tmp;
		}
        void Insert(Node*& u,T val){
            if(!u){
                u=new Node();
                u->val=val;
                return;
            }
            if(u->val==val)
                u->amount++,u->size++;
            else if(u->val<val){
            	Insert(u->ch[1],val);
            	if(u->prio>u->ch[1]->prio)
            		rotate(u,left);
            	u->updateSize();
			}
            else{
            	Insert(u->ch[0],val);
            	if(u->prio>u->ch[0]->prio)
            		rotate(u,right);
            	u->updateSize();
			}
        }
        void Erase(Node*& u,T val){
        	if(!u)
        		return;
        	if(u->val>val)
        		Erase(u->ch[0],val),u->updateSize();
        	else if(u->val<val)
        		Erase(u->ch[1],val),u->updateSize();
        	else if(u->val==val){
        		if(u->amount>1){
        			u->amount--;
        			return;
				}
				Node* tmp=u;
				unsigned int cs=0|(u->ch[0]!=NULL)|((u->ch[1]!=NULL)<<1);
        		switch(cs){
        			case 0:delete u;u=NULL;break;
        			case 1:u=tmp->ch[0];delete tmp;break;
        			case 2:u=tmp->ch[1];delete tmp;break;
        			case 3:{
        				if(u->ch[0]->prio<u->ch[1]->prio)
        					rotate(u,right),Erase(u->ch[1],val);
        				else
        					rotate(u,left),Erase(u->ch[0],val);
        				u->updateSize();
						break;
					}
				}
			}
		}
        void dfs(Node* u){
            if(!u)
                return;
            dfs(u->ch[0]);
            for (int i=0;i<u->amount;i++) 
				printf("%d ",u->val);
            dfs(u->ch[1]);
        }
        int Rank(Node* u,T val){
            if(!u)
                return 0;
            int siz=u->ch[0]?(u->ch[0]->size+1):1;
            if(u->val<val)
                return siz+Rank(u->ch[1],val);
            if(u->val==val)
                return siz;
            if(u->val>val){
                return Rank(u->ch[0],val);
            }
        }
        T Kth(Node* u,int rk){
            if(!u)
                return 2147483647;
            int siz=u->ch[0]?u->ch[0]->size+1:1;
            if(rk==siz)
                return u->val;
            else if(rk<siz)
                return Kth(u->ch[0],rk);
            else
                return Kth(u->ch[1],rk-siz);
        }
        T Lower_bound(Node* u,T val,T tmp){
            if(!u)
                return tmp;
            if(u->val<val)
                return Lower_bound(u->ch[1],val,u->val);
            if(u->val>=val)
                return Lower_bound(u->ch[0],val,tmp);
        }
        T Upper_bound(Node* u,T val,T tmp){
            if(!u)
                return tmp;
            if(u->val>val)
                return Upper_bound(u->ch[0],val,u->val);
            if(u->val<=val)
                return Upper_bound(u->ch[1],val,tmp);
        }
    public:
        BSTree(){
            root=NULL;
            srand(time(0));
        }
        void insert(T val){
            Insert(root,val);
        }
        void erase(T val){
        	Erase(root,val);
		}
        int rank(T val){
            return Rank(root,val);
        }
        T kth(int rk){
            return Kth(root,rk);
        }
        T lower_bound(T val){
            return Lower_bound(root,val,-2147483647);
        }
        T upper_bound(T val){
            return Upper_bound(root,val,2147483647);
        }
        void show(){
            dfs(root);
        }
        int size(){
            return root?root->size-1:0;
        }
};
BSTree<long long>h;
int q,a;
long long x;
int main(){
    scanf("%d",&q);
    while(q--){
        scanf("%d%lld",&a,&x);
        switch(a){
            case 3:printf("%d\n",h.rank(x));break;
            case 4:printf("%lld\n",h.kth(x));break;
            case 5:printf("%lld\n",h.lower_bound(x));break;
            case 6:printf("%lld\n",h.upper_bound(x));break;
            case 1:h.insert(x);break;
            case 2:h.erase(x);break; 
        }
    }
    return 0;
}