#include <fstream>

using namespace std;

template <class T>
class nod
{
    public:
    T info;
    nod *next;
};
template <class T>
class hash_table
{
    nod<T> *q;
    int marime_hash;
    public:
        hash_table<T>();
        void adauga(T);
        void sterge(T);
		bool cauta(T);
        bool gol();
        int marime();
        nod<T>* prim();
        nod<T>* ultim();
};

template <class T>
hash_table<T>::hash_table()
{
    q = NULL;
    marime_hash = 0;
}

template <class T>
nod<T>* hash_table<T>::prim()
{
    return q;
}

template <class T>
nod<T>* hash_table<T>::ultim()
{
    nod<T> *p;
    p=q;
    while (p->next != NULL) p = p->next;
    return p;
}
template <class T>
bool hash_table<T>::gol()
{
    return marime_hash ? false : true;
}

template <class T>
int hash_table<T>::marime()
{
    return marime_hash;
}


template <class T>
bool hash_table<T>::cauta(T x)
{
    nod<T> *p;
    if (gol()) return false;
    p = prim();
    while (p != NULL)
    {
        if (p->info == x)  return true;
        p = p->next;
    }
    return false;
}
template <class T>
void hash_table<T>::sterge(T x)
{
    nod<T> *p, *u;
    if (!cauta(x))
        return;

    if (marime_hash == 1)
    {
        q = NULL;
    }
    else
    {
        u = prim();
        if (u->info == x)
		q = q->next;
        else
        {
            p = u->next;
    while (p != NULL)
            {
         if (p->info == x)
         {
           u->next = p->next;
            delete p;
        break;
     }
        u = p;
    p = p->next;
            }
        }
    }

    marime_hash--;
}
template <class T>
void hash_table<T>::adauga(T x)
{
    nod<T> *p,*nn;
    if (cauta(x))
        return;

    nn = new nod<T>;
    nn->info = x;
    nn->next = NULL;

    if (gol())
    {
        q = nn;
    }
    else
    {
        p = ultim();
        p->next = nn;
    }

    marime_hash++;
}

template <class T>
class hash
{
    hash_table<T> *tables;
    int P;
    public:
        hash<T>();
        bool adauga(T);
        bool sterge(T);
        short int cauta(T);

};

template <class T>
hash<T>::hash()
{
    P = 666013;
    tables = new hash_table<T>[P];
}
template <class T>
short int hash<T>::cauta(T x)
{
    int table = x%P;

    if (tables[table].cauta(x))
        return 1;
    return 0;
}
template <class T>
bool hash<T>::adauga(T x)
{
    int table = x%P;

    tables[table].adauga(x);
    return true;
}

template <class T>
bool hash<T>::sterge(T x)
{
    int table = x%P;

    tables[table].sterge(x);
    return true;
}




int main()
{
    int n,op,x;
    ifstream in("hashuri.in");
    ofstream out("hashuri.out");

    hash<int> H;
    in>>n;
    for (; n; --n)
    {
        in>>op>>x;
        switch (op)
        {
            case 1:
                H.adauga(x);
                break;
            case 2:
                H.sterge(x);
                break;
            case 3:
                out<<H.cauta(x)<<'\n';
                break;
        }
    }

    return 0;
}