#include <fstream>
#include <cstdlib>
using namespace std;

#define max 1000003
#define prim 670013

template <class T> // asa arata un nod din lista
class node
{
    public:
           T key;
           node * next;
};

template <class T> // tabelul hash - stl implementat de mana
class table
{
    node<T> *v;
    int table_size;
    
    public:
           table() { v = NULL; table_size = 0; }
           int size();
           bool empty();
           node<T> *first();
           node<T> *last();
           bool search(T);
           void insert(T);
           void erase(T);        
};

template <class T>
int table<T> :: size()
{
    return table_size;
}

template <class T>
bool table<T> :: empty()
{
    if(table_size) return false;
    return true;
}

template <class T>
node<T> *table<T> :: first()
{
    return v;
}

template <class T>
node<T> *table<T> :: last()
{
    node<T> *p = v;
    while(p->next) p = p->next;
    return p;
}

template <class T>
bool table<T> :: search(T x)
{
    node<T> *p;
    if(empty()) return false;
    p = first();
    while(p)
    {
         if(p->key == x) return true;
         p = p->next;
    }
    return false;
}

template <class T>
void table<T> :: insert(T x)
{
    node<T> *p, *q;
    if(search(x)) return;
    
    q = new node<T>;
    q->key = x;
    q->next = NULL;
    
    if(empty()) v = q;
    else { p = last(); p->next = q; }
    
    table_size++;
}

template <class T>
void table<T> :: erase(T x)
{
    node<T> *p, *q;
    if(!search(x)) return;
    
    // daca exista in tabel
    if(table_size == 1) v = NULL;
    else
    {
         // daca e pe prima pozitie
         q = first();
         if(q->key == x) q = q->next;
         else // daca nu
         {
              p = q->next;
              while(p)
              {
                   if(p->key == x)
                   {
                        q->next = p->next;
                        delete p;
                        break;
                   }
                   q = p;
                   p = p->next;
              }
         }
    }
    
    table_size--;
}


template <class T>
class hash
{
    table<T> *H;
    int a, b;
    
    public:
           hash() { H = new table<T> [prim]; }
           void random() { a = rand()%13; b = rand()%13 + 1; }
           int h(T x) 
           {
                int index = a*x+b;
                index %= prim;
                index %= max; 
                return index; 
           } 
           bool search(T);
           bool insert(T);
           bool erase(T);
};

template <class T>
bool hash<T> :: search(T x)
{
    int index = h(x);
    if(H[index].search(x)) return 1;
    return 0;
}

template <class T>
bool hash<T> :: insert(T x)
{
    int index = h(x);
    H[index].insert(x);
    return true;
}

template <class T>
bool hash<T> :: erase(T x)
{
    int index = h(x);
    H[index].erase(x);
    return true;
}


int main ()
{
    ifstream f("hashuri.in");
    ofstream g("hashuri.out");
    
    hash <int> hsh;
    hsh.random();
    
    int N, i, t, x;
    f>>N;
    for(i=1;i<=N;++i)
    {
         f>>t>>x; 
         if(t == 1)
              hsh.insert(x);
         else if(t == 2)
              hsh.erase(x);
         else if(t == 3)
         { 
              g<<hsh.search(x)<<endl;
         }
    }
    f.close(); g.close();
    
    
    return 0;
}