#include <fstream>
#include <iostream>
#include <time.h>
#include <string.h>
#include <stdlib.h>
#define prim  100000019
#define maxim 1000001

using namespace std;

template <class tip>
class CuckooHash
{
private:
    long random1,random2,nr;
    tip *T1,*T2;
    bool *ope;
    tip *values;

    void genereaza();
    long h1(long value, long a,long b){return(((long long)a*(long long)value+(long long )b)%prim)%maxim;};
    long h1(int value, long a,long b){return (((long long)a*(long long)value+(long long )b)%prim)%maxim;};
    long h1(float value, long a,long b){return (((long long)a*(long long)value+(long long )b)%prim)%maxim;};
    long h1(double value, long a,long b){return (((long long)a*(long long)value+(long long )b)%prim)%maxim;};
    long h1(char value, long a,long b){return (((long long)a*(long long)value+(long long )b)%prim)%maxim;};
    long h1(string value,long random){
    long suma=0;
    for (int contor=0;contor<value.length();contor++)
        suma=suma+value[contor]*contor;
        return suma%random;
    }
    void rehash();

public :
    CuckooHash();
    ~CuckooHash();
    bool operator+=(tip);//adauga
    int  operator!=(tip);//intreaba
    bool operator-=(tip);//sterge

};
template <class tip>
CuckooHash<tip> :: CuckooHash()
{
    srand(time(NULL));
    genereaza();

    nr=0;
    T1= new tip[maxim];
    T2= new tip[maxim];
    ope=new bool[maxim];
    values=new tip[maxim];
    fill(T1,T1+maxim,0);
    fill(T2,T2+maxim,0);


}

template <class tip>
CuckooHash<tip> :: ~CuckooHash(){

    delete[]T1;
    delete[]T2;
    delete[]ope;
    delete[]values;
    random1=random2=0;
}

template <class tip>
void CuckooHash<tip> :: genereaza(){

    random1=rand() % maxim;
    random2=rand() % maxim;
}


template <class tip>
void CuckooHash<tip> :: rehash()
{
    delete[] T1;
    delete[] T2;

    T1=new tip[maxim];
    T2=new tip[maxim];
    genereaza();

    for (int i=0;i<nr;i++)
     if (ope[i]==true) *this+=values[i];
                 else *this-=values[i];
}

template <class tip>
int CuckooHash<tip>:: operator!=(tip value)
{
    long hash1=h1(value,random1,random2);
    long hash2=h1(value,random2,random1);
    if (T1[hash1]==value || T2[hash2]==value) return 1;
                                         else return 0;
}


template <class tip>
bool CuckooHash<tip> :: operator-=( tip value)
{
    ope[nr]=false;
    values[nr++]=value;

    long hash1=h1(value,random1,random2);
    long hash2=h1(value,random2,random1);

    if (T1[hash1]==value){
        T1[hash1]=0;
        return true;
    }
    if (T2[hash2]==value){
        T2[hash2]=0;
        return true;
    }
    return false;
}


template <class tip>
bool CuckooHash<tip> ::operator+=( tip value)
{
    bool ok=false;

    long hash1 = h1(value,random1,random2);
    long hash2 = h1(value,random2,random1);

    ope[nr]=true;
    values[nr++]=value;

    if ((*this!=value)==0){//daca nu e in hash

    for(int i=1;i<=50;i++)
    {
        if(T1[hash1]==0){
            T1[hash1]=value;
            return true;
        }
       tip auxiliar=T1[hash1];
        T1[hash1]=value;
        value=auxiliar;
        if(T2[hash2]==0){
            T2[hash2]=value;
            return true;
        }
        auxiliar=T2[hash2];
        T2[hash2]=value;
        value=auxiliar;
    }
    if (ok==false) rehash();
}
}



int main()
{
    ifstream in("hashuri.in");
    ofstream out("hashuri.out");
    int n;
    in>>n;
    CuckooHash<long> Hashul;
    for (int i=0;i<n;i++)
    {
      long op;
      long val;
        in>>op>>val;
        switch(op)
        {
            case 1: Hashul+=val;

                    break;
            case 2: Hashul-=val;

                    break;
            case 3: int a=Hashul!=val;
                    out<<a<<'\n';
                    break;
        }
    }
    return 0;
}