#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

#define DIM 66613
char buffer[DIM];
int poz = DIM - 1;

void scan(int &A)
{
    A = 0;
    while('0' > buffer[poz] || buffer[poz] > '9')
        if(++poz == DIM) fread(buffer,1,DIM,stdin),poz = 0;
    while('0' <= buffer[poz] && buffer[poz] <= '9')
    {
        A = A * 10 + buffer[poz] - 48;
        if(++poz == DIM)
            fread(buffer,1,DIM,stdin),poz = 0;
    }
}

class Treap{
public:
    Treap *left, *right;
    int info, priority;
    Treap() {
        left = right = 0;
        info = priority = 0;
    }
    Treap(Treap *l, Treap *r, int inf, int prio) {
        left = l;
        right = r;
        info = inf;
        priority = prio;
    }
};

Treap *Nil, *root;

void init()
{
    srand(time(0));
    Nil = new Treap();
    Nil->left = Nil->right = Nil;
    Nil->priority = -INF; Nil->info = 0;
    root = new Treap(Nil, Nil, 0, INT_MAX);
}

void rotateRight(Treap *&root)
{
    Treap *aux = root->left;
    root->left = aux->right;
    aux->right = root;
    root = aux;
}

void rotateLeft(Treap *&root)
{
    Treap *aux = root->right;
    root->right = aux->left;
    aux->left = root;
    root = aux;
}

void balance(Treap *&root)
{
    if(root->left->priority > root->priority)
        rotateRight(root);
    else
        if(root->right->priority > root->priority)
            rotateLeft(root);
}

void insert(Treap *&root, int k)
{
    if(root == Nil) {
        root = new Treap(Nil, Nil, k, rand());
        return;
    }

    if(k <= root->info)
        insert(root->left, k);
    else
        insert(root->right, k);
    balance(root);
}

void del(Treap *&root, int k)
{
    if(k == root->info) {
        if(root->left != Nil && root->right != Nil) {
            if(root->left->priority > root->right->priority) {
                rotateRight(root);
                del(root->right, k);
            }
            else {
                rotateLeft(root);
                del(root->left ,k);
            }
            return;
        }
        if(root->left != Nil) {
            Treap *aux = root;
            root = root->left;
            delete aux;
            return;
        }
        if(root->right != Nil) {
            Treap *aux = root;
            root = root->right;
            delete aux;
            return;
        }
        Treap *aux = root;
        root = Nil;
        delete aux;
        return;
    }

    if(k < root->info) {
        del(root->left, k);
    }
    else if(k > root->info) {
        del(root->right, k);
    }
}

/***********************************************
    BEGIN DELETION OF A NODE
***********************************************/
Treap* join(Treap *&left, Treap *&right)
{
    if(left == Nil)
        return right;
    if(right == Nil)
        return left;
    if(left->priority > right->priority) {
        left->right = join(left->right, right);
        return left;
    }
    right->left = join(left, right->left);
    return right;
}
void delet(Treap *&root, int k) {
    if(root->info == k) {
        Treap *aux = root;
        root = join(root->left, root->right);
        delete aux;
        return;
    }
    if(k < root->info)
        delet(root->left, k);
    else
        delet(root->right, k);
}
/***********************************************
    END DELETION OF A NODE
***********************************************/


/***********************************************
    BEGIN INSERTION OF A NODE
***********************************************/
pair<Treap*, Treap*> split(Treap *&root, int k)
{
    if(root == Nil)
        return make_pair(Nil, Nil);
    pair<Treap*, Treap*> aux;
    if(k < root->info) {
        aux = split(root->left, k);
        root->left = aux.second;
        aux.second = root;
        return aux;
    }
    aux = split(root->right, k);
    root->right = aux.first;
    aux.first = root;
    return aux;
}

void inset(Treap *&root, int k, int priority) {
    if(root->priority <= priority) {
        pair<Treap*, Treap*> aux = split(root, k);
        root = new Treap(aux.first, aux.second, k, priority);
        return;
    }
    if(k <= root->info)
        inset(root->left, k, priority);
    else
        inset(root->right, k, priority);
}

/***********************************************
    END INSERTION OF A NODE
***********************************************/


bool search(Treap *root, int k) {
    if(root == Nil)
        return false;
    if(root->info == k)
        return true;
    if(k < root->info)
        return search(root->left, k);
    return search(root->right, k);
}

int main()
{
    init();
    freopen("hashuri.in", "r", stdin);
    freopen("hashuri.out", "w", stdout);

    int N;
    scan(N);
    for(int i = 1; i <= N; ++i) {
        int tip, val;
        scan(tip);scan(val);
        if(tip == 1){
            if(!search(root->left, val)) {
                inset(root->left, val, rand());
            }
            continue;
        }
        if(tip == 2) {
            if(search(root->left, val)) {
                del(root->left, val);
            }
            continue;
        }
        printf("%d\n", search(root->left, val));
    }


    return 0;
}