#include<fstream>
#include<algorithm>

using namespace std;

ifstream f("hashuri.in");
ofstream g("hashuri.out");

int ciur(int dim) {

    int i, j, lim;
    bool *prim;

    prim = new bool[dim+1];
    fill(prim, prim+dim+1, false);
    for(i=4; i<=dim; i*=2)
        prim[i] = 1;
    lim = 2;
    for(i=3; i<=dim; i+=2) {
        if(!prim[i]) {
            lim = i;
            for(j=i*3; j<=dim; j+=i)
                prim[j] = 1;
        }
    }

    return lim;
}

template <class T>
class hash {
    int size;
    char *viz;
    T *H;
    public:
        hash<T>(int hash_size);
        ~hash();

        int hash_function1(T val);
        int hash_function2(T val);
        int hash_function(T val, int poz);
        int find(T val);
        void insert(T val);
        void erase(T val);
};

template <class T>
hash<T>::hash(int hash_size) {
    size = ciur(hash_size*3);
    H = new T[size+1];
    viz = new char[size+1];
    fill(viz, viz+size+1, -1);
}

template <class T>
hash<T>::~hash() {
    delete [] H;
    delete [] viz;
}

template <class T>
int hash<T>::hash_function1(T val) {
    return val % size;
}

template <class T>
int hash<T>::hash_function2(T val) {
    return (val % (size - 1)) + 1;
}

template <class T>
int hash<T>::hash_function(T val, int poz) {
    return (hash_function1(val) + poz * hash_function2(val)) % size;
}

template <class T>
int hash<T>::find(T val) {
    int i, key;
    for(i=0; i<size; ++i) {
        key = hash_function(val, i);
        if(viz[key] == 1)
            return key;
        if(viz[key] == -1)
            return -1;
    }
    return -1;
}

template <class T>
void hash<T>::insert(T val) {
    if(find(val) != -1)
        return;
    int i, key;
    for(i=0; i<size; ++i) {
        key = hash_function(val, i);
        if(viz[key] == 0 || viz[key] == -1) {
            H[key] = val;
            viz[key] = 1;
            return;
        }
    }
}

template <class T>
void hash<T>::erase(T val) {
    int key = find(val);
    if(key == -1)
        return;
    else
        viz[key] = -1;
}

int main() {
    int Q, op, x;

    f>>Q;
    hash<int> myHash(Q);
    while(Q--) {
        f>>op>>x;
        if(op == 1)
            myHash.insert(x);
        if(op == 2)
            myHash.erase(x);
        if(op == 3) {
            if(myHash.find(x) == -1)
                g<<0<<"\n";
            else
                g<<1<<"\n";
        }
    }

    f.close();
    g.close();

    return 0;
}