#include<stdio.h>
#include<string>
#include<cstdlib>
using namespace std;

template <class T>
class NOD
{
	public:
	T info;
	NOD *leg;
};


template <class T>
class HASH_TABLE
{
private: 
	NOD<T> *elem;
	int size_of_hash;
public:
	
	HASH_TABLE<T>();
	void erase(T);
	void insert(T);
	int empty();
	int find(T);
	int size();
	NOD<T>* first();
	NOD<T>* last();
};


template <class T>
NOD<T>* HASH_TABLE<T> :: first()
{
return elem;
}


template <class T>
NOD<T>* HASH_TABLE<T> :: last()
{
	NOD<T>* i;
	i = elem;
	while(i->leg != NULL)
		i=i->leg;
	return i;
}

template <class T>
int HASH_TABLE<T>:: size()
{
	return size_of_hash;
}


template <class T>
HASH_TABLE<T>::HASH_TABLE()
{
	elem=NULL;
	size_of_hash=0;
}

template <class T>
int HASH_TABLE<T>::empty()
{
	return size_of_hash ? false : true;
}


template <class T>
int HASH_TABLE<T> :: find(T x)
{
	NOD<T> *i;
	if(empty())
		return 0;
	
	i = first();
	while(i!=NULL)
	{
		if(i->info == x)
			return 1;
		i=i->leg;
	}
	return 0;
}

template <class T>
void HASH_TABLE<T> :: insert(T x)
{
	NOD<T> *i, *node;
	if(find(x))
		return;
	
	node = new NOD<T>;
	node -> info = x;
	node -> leg = NULL;
	
	if(empty())
		elem = node;
	else
	{
		i = last();
		i->leg = node;
	}
	
	size_of_hash++;
}

template <class T>
void HASH_TABLE<T>::erase(T x)
{
	NOD<T> *p, *u;
		if (!find(x))
			return;
		
	if (size_of_hash == 1)
		elem = NULL;
	
	else
	{
		u = first();
		if (u->info == x)
			elem = elem->leg;
		else
		{
			p = u->leg;
			while (p != NULL)
			{
				if (p->info == x)
				{
					u->leg = p->leg;
					delete p;
					break;
				}
				u = p;
				p = p->leg;
			}

		}
	}
size_of_hash--;
}
	

template <class T>
class vector
{
    protected:
              HASH_TABLE<T> *A;
              int prim;
    
    public:
           vector();
           virtual int h(T) = 0;
           int insert(T);
           int erase(T);
					 int search(T);
    
};

template <class T>
vector<T> :: vector()
{
    prim = 666013;
    A = new HASH_TABLE<T>[prim];
}

template <class T>
int vector<T>::insert(T x)
{
    int key = h(x);

    A[key].insert(x);
    return 1;
}

template <class T>
int vector<T>::erase(T x)
{
    int key = h(x);

    A[key].erase(x);
    return 1;
}

template <class T>
int vector<T>::search(T x)
{
    int key = h(x);

    if (A[key].find(x))
        return 1;
    return 0;
}

template <class T>
class universal_hash : public vector<T>
{
    
    int xx, yy, max;

    public:
        universal_hash<T>();
        int h(T);
			
};

template <class T>
universal_hash<T>::universal_hash()
{
    max = 1000003;
    xx = rand()%4;
    yy = rand()%4+1;
}

template <class T>
int universal_hash<T>::h(T x)
{
    unsigned int key = xx*x+yy;
    key %= (this->prim);
    key %= max;
    return key;
}



template <class T>
class modulo : public vector<T>
{
    public:
        int h(T);
};

template <class T>
int modulo<T>::h(T x)
{
    int key = x%(this->prim);
    return key;
}


int main ()
{
    int numar_op,operatie,x;
    freopen("hashuri.in","r",stdin);
    freopen("hashuri.out","w",stdout);

    modulo<int> H;
    scanf("%d",&numar_op);
    for (int i=1; i<=numar_op; i++)
    {
        scanf("%d%d",&operatie, &x);
        if (operatie==2)
							H.erase(x);
          else 
							if(operatie==1)
                H.insert(x);
							 else 
                printf("%d\n",H.search(x));
			}
    
return 0;
    
}