#include <cstdlib>
#include <ctime>
#include <fstream>
#include <algorithm>

using namespace std;

struct Treap
{
    int key, val;
    Treap *lf, *rg;

    Treap() {};
    Treap(int _key, int _val, Treap *_lf, Treap *_rg)
    {
        key = _key;
        val = _val;
        lf = _lf;
        rg = _rg;
    }
};

Treap *nil = new Treap(0, 0, 0, 0);
Treap *R = nil;

void rotateL(Treap *&T)
{
    Treap *aux = T->lf;
    T->lf = aux->rg;
    aux->rg = T;

    T = aux;
}
void rotateR(Treap *&T)
{
    Treap *aux = T->rg;
    T->rg = aux->lf;
    aux->lf = T;

    T = aux;
}
void balanceT(Treap *&T)
{
    if (T->val < T->lf->val) rotateL(T);
    if (T->val < T->rg->val) rotateR(T);
}
void insertT(Treap *&T, int key, int val)
{
    if (T == nil)
    {
        T = new Treap(key, val, nil, nil);
        return;
    }

    if (key < T->key) insertT(T->lf, key, val);
    else              insertT(T->rg, key, val);

    balanceT(T);
}
void eraseT(Treap *&T, int key)
{
    if (key < T->key) eraseT(T->lf, key);
    else if (key > T->key) eraseT(T->rg, key);
    else
    {
        if (T->lf == nil && T->rg == nil)
        {
            delete T;
            T = nil;
        }
        else if (T->lf->key > T->rg->key)
        {
            rotateL(T);
            eraseT(T->rg, key);
        }
        else
        {
            rotateR(T);
            eraseT(T->lf, key);
        }
    }
}
bool findT(Treap *&T, int key)
{
    if (T->key == key) return true;
    if (T == nil) return false;

    if (key < T->key) return findT(T->lf, key);
    else              return findT(T->rg, key);
}

int main()
{
    ifstream fin("hashuri.in");
    ofstream fout("hashuri.out");

    srand(time(0));

    int N;

    fin >> N;
    for (int i = 1, type, num; i <= N; ++i)
    {
        fin >> type >> num;
        if (type == 1)
        {
            if (!findT(R, num))
                insertT(R, num, rand() + 1);
        }
        else if (type == 2)
        {
            if (findT(R, num))
                eraseT(R, num);
        }
        else
            fout << findT(R, num) << '\n';
    }

    fin.close();
    fout.close();
}