using namespace std;
#define NULL dead

class node
{
public:
    int value,h;
    node *left,*right;
};
class BST : public node
{
    private:
        node *root,*dead;
		node * insertP(int x, node *current)
        {
            if(current==NULL)
            {
                node*p;
                p=new node;
                p->value=x;
				p->left=p->right=NULL;
                return p;
            }
			if(current->value == x) return current;
			
            if(current->value > x)
                current->left=insertP(x, current->left);
            else current->right=insertP(x,current->right);
            
            return balance(current);
        }
        
        node *delP(int x, node * current)
        {
            if(current==NULL) return NULL;
            
            if(current->value==x)
            {
                node *p;
                if(current->left==NULL || current->right==NULL)
                {
                    current->left==NULL? p=current->right:p=current->left;
					delete current;
                    return p;
                }
                
                p=current->left;
                while(p->right!=NULL) p=p->right;

                current->value=p->value;
                current->left=delP(p->value,current->left);

                return balance(current);
            }
			
			if(current->value>x)
				current->left=delP(x,current->left);
			else current->right=delP(x,current->right);
			
			return balance(current);
        }
        
		void setHeight(node *p)
		{
			int best;
			p->left->h>p->right->h ? best=p->left->h : best=p->right->h;
			
			p->h=1+best;
		}
		
		node * leftRotate( node *p)
		{
			node *q=p->right;
			p->right=p->right->left;
			q->left=p;;
			
			setHeight(p); setHeight(q);
			return q;
		}
		
		node * rightRotate(node *p)
		{
			node *q=p->left;
			p->left=p->left->right;
			q->right=p;
			
			setHeight(p); setHeight(q);
			return q;
		}
		
		node * balance(node *p)
		{
			setHeight(p);
			
			if(p->right->h - p->left->h > 1)
			{
				if(p->right->left->h > p->right->right->h)
					p->right=rightRotate(p->right);
				p=leftRotate(p);
			}
			if(p->left->h - p->right->h >1)
			{
				if(p->left->right->h > p->left->left->h)
					p->left=leftRotate(p->left);
				p=rightRotate(p);
			}
			
			return p;
		}
			
    public:
        BST()
        {
			dead=new node;
			dead->h=-1;
			dead->left=dead->right=dead;
			root=NULL;
        }
        bool lookup(int x)
        {
            node * p=root;
            while(p!=NULL && p->value!=x)
            {
                if(p->value>x)
                    p=p->left;    
                else p=p->right;
            }

            if(p==NULL)
                return 0;
            else return 1;
        }
		
		void insert(int x)
		{
			root=insertP(x,root);
		}
		void del(int x)
		{
			root=delP(x,root);
		}
       
}AVL;
    
#include <fstream>
ifstream f("hashuri.in");
ofstream g("hashuri.out");
int main()
{
	int T;
	f>>T;
	
	int q,x;
	while(T--)
	{
		f>>q>>x;
		switch (q)
		{
		case 1: AVL.insert(x); break;
		case 2: AVL.del(x); break;
		case 3: g<<AVL.lookup(x)<<'\n'; break;
		}
	}
}