#include <bits/stdc++.h>

using namespace std;
typedef int var;


struct AVL {

    struct nod {
        var key, height;
        bool del;
        nod *ls, *ld;
        nod(var k, var h, nod *s, nod *d) {
            key = k; height = h;
            ls = s; ld = d; del=0;
        }
    };
    typedef nod* pnod;

    pnod root, nill;

    AVL() {
        nill = new nod(-1, 0, nill, nill);
        nill->ls = nill->ld = nill;
        root = nill;
    }

    void upd(pnod &p) {
        if(p != nill)
            p->height = max(p->ls->height, p->ld->height) + 1;
    }

    void rot_left(pnod &p) {
        pnod aux = p->ld;
        p->ld = aux->ls;
        aux->ls = p;
        upd(p);
        upd(aux);
        p = aux;
    }
    void rot_right(pnod &p) {
        pnod aux = p->ls;
        p->ls = aux->ld;
        aux->ld = p;
        upd(p);
        upd(aux);
        p = aux;
    }

    void balance(pnod &p) {
        upd(p);
        if(p->ls->height > p->ld->height + 1) {
            rot_right(p);
        } else if(p->ld->height > p->ls->height + 1) {
            rot_left(p);
        }
    }

    bool ins(pnod &p, const var &key) {
        if(p == nill) {
            p = new nod(key, 1, nill, nill);
            return true;
        }

        bool r = 0;
        if(key < p->key) r = ins(p->ls, key);
        else if(key > p->key) r = ins(p->ld, key);
        else p->del = 0, r = 0;

        if(r) balance(p);
        return r;
    }
    void insert(var val) {
        ins(root, val);
    }

    void del(pnod &p, const var &key) {
        if(p == nill) return;

        if(key < p->key)      del(p->ls, key);
        else if(key > p->key) del(p->ld, key);
        else p->del = 1;
    }
    void erase(const var &key) {
        del(root, key);
    }

    pnod fnd(pnod &p, const var &key) {
        if(p == nill) return NULL;

        if(key < p->key) return fnd(p->ls, key);
        if(key > p->key) return fnd(p->ld, key);
        if(p->del) return NULL;
        return p;
    }
    pnod find(const var &key) {
        return fnd(root, key);
    }

};
AVL T;

#define DIM 100000
char buff[DIM];
var poz = DIM - 1;
void Read(var &a) {
    while(!isdigit(buff[poz]))
        if(++poz == DIM)
            fread(buff, 1, DIM, stdin), poz=0;
    a = 0;
    while(isdigit(buff[poz])) {
        a = a * 10 + buff[poz] - '0';
        if(++poz == DIM)
            fread(buff, 1, DIM, stdin), poz=0;
    }
}


int main() {

    freopen("hashuri.in", "r", stdin);
    freopen("hashuri.out", "w", stdout);

    var m, t, a;
    Read(m);

    while(m--) {
        Read(t); Read(a);
        if(t == 1) T.insert(a);
        else if(t == 2) T.erase(a);
        else printf("%d\n", (T.find(a) != NULL));
    }
    return 0;
}