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

using namespace std;

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

    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 *root = nil;

void rotate_lf(Treap* &nod)
{
    Treap* aux = nod->lf;
    nod->lf = nod->lf->rg;
    aux->rg = nod;
    nod = aux;
}
void rotate_rg(Treap* &nod)
{
    Treap* aux = nod->rg;
    nod->rg = nod->rg->lf;
    aux->lf = nod;
    nod = aux;
}
void balance(Treap* &nod)
{
    if (nod->lf->val > nod->val) rotate_lf(nod);
    if (nod->rg->val > nod->val) rotate_rg(nod);
}
void insert(Treap* &nod, int key, int val)
{
    if (nod == nil)
    {
        nod = new Treap(key, val, nil, nil);
        return;
    }

    if (nod->key > key) insert(nod->lf, key, val);
    else                insert(nod->rg, key, val);

    balance(nod);
}
void erase(Treap* &nod, int key)
{
    if (nod->key > key)
    {
        erase(nod->lf, key);
        balance(nod);
    }
    else if (nod->key < key)
    {
        erase(nod->rg, key);
        balance(nod);
    }
    else
    {
        if (nod->lf == nil && nod->rg == nil)
        {
            delete nod;
            nod = nil;
            return;
        }
        if (nod->lf->val > nod->rg->val)
        {
            rotate_lf(nod);
            erase(nod->rg, key);
            balance(nod);
        }
        else
        {
            rotate_rg(nod);
            erase(nod->lf, key);
            balance(nod);
        }
    }
}
bool findt(Treap* &nod, int key)
{
    if (nod == nil) return false;
    if (nod->key == key) return true;

    if (nod->key > key) return findt(nod->lf, key);
    else                return findt(nod->rg, key);
}

int N;

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

    srand(time(0));

    fin >> N;
    for (int i = 1, type; i <= N; ++i)
    {
        fin >> type;
        if (type == 1)
        {
            int val;
            fin >> val;

            if (!findt(root, val))
                insert(root, val, rand() + 1);
        }
        else if (type == 2)
        {
            int val;
            fin >> val;

            if (findt(root, val))
                erase(root, val);
        }
        else
        {
            int val;
            fin >> val;

            fout << findt(root, val) << '\n';
        }
    }

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