#include <algorithm>
#include <fstream>

#define NULL dead
using namespace std;
ifstream f("hashuri.in");
ofstream g("hashuri.out");


class BST
{
    private:
        struct node
        {
            int key,h;
            node *l,*r;
            node ()
            {
                h=0;
            }
        };
        node *root,*dead;
        
        node *privateInsert(node *p, int key)
        {
            if(p==NULL)
            {
                p=new node;
                p->l=p->r=dead;
                p->key=key;
                return p;
            } 
            if(p->key==key) return p;
            
            if(p->key > key)
                p->l=privateInsert(p->l,key);
            else
                p->r=privateInsert(p->r,key);
			
            return balance(p);
        }

        node *privateDel(node *p, int key)
        {
        
            if(p==NULL) return p;
			if(p->key == key)
			{
				node *q;
				if(p->l==NULL || p->r==NULL)
				{
					if(p->l == NULL ) q=p->r; else q=p->l;
					delete p;
					return q;
				}
				q=p->l;
				while(q->r!=NULL) q=q->r;

				p->key=q->key;
				p->l=privateDel(p->l,q->key);
				return balance(p);
			}
			
			if(p->key > key)
				p->l=privateDel(p->l,key);    
			else p->r=privateDel(p->r,key);
			
			return balance(p);
		}

		void setHeight(node *p)
		{
			p->h=1+max(p->l->h,p->r->h);
		}
		
		node * rightRotate( node *p)
		{
			node *q=p->l;
			p->l=q->r;
			q->r=p;
			
			setHeight(p),setHeight(q);
			return q;
		}
		
		node *leftRotate( node *p) 
		{
			node *q=p->r;
			p->r=q->l;
			q->l=p;
					
			setHeight(p),setHeight(q);
			return q;
		}
				
		node * balance(node *p)
		{
			setHeight(p);
			if( p->r->h - p->l->h >1 )
			{
				if(p->r->l->h > p->r->r->h)
					p->r=rightRotate(p->r);
				p=leftRotate(p);
			}
			if( p->l->h - p->r->h > 1 )
			{
				if(p->r->r->h > p->r->l->h)
					p->l=leftRotate(p->l);
				p=rightRotate(p);
			}
			
			return p;
		}

    
    public:
        BST()
        {
            dead=new node;
            dead->l=dead->r=dead;
            dead->h=-1;
            root=NULL;
        }
		
        void insert(int key)
        {
            root=privateInsert(root,key);
        }
		
        bool lookup(int key)
        {
            node *p=root;
            while(p!=NULL && p->key!=key)
                if(p->key > key) p=p->l;
                else p=p->r;

            if(p==NULL) return 0; 
            else return 1;
        }
		
        void del(int key)
        {
            root=privateDel(root,key);
        }
    
}T;

#include <iostream>
int main()
{
	int N,q,x;
	f>>N;
	while(N--)
	{
		f>>q>>x;
		switch (q)
		{
			case 1: T.insert(x); break;
			case 2:	T.del(x); break;
			case 3: g<<T.lookup(x)<<'\n'; break;
		}
	}
}