#include <bits/stdc++.h>

using namespace std;

struct Node
{
    int key;
    int priority;

    Node *st, *dr;

    Node(int k, int p, Node *s, Node *d)
    {
        key = k;
        priority = p;
        st = s;
        dr = d;
    }
};

Node *root, *NIL;

void initTreap()
{
    srand(time(NULL));
    NIL = new Node(0, 0, NULL, NULL);
    root = NIL;
}

void rotateToRight(Node *&T)
{
    Node *aux = T->st;
    T->st = aux->dr;
    aux->dr = T;

    T = aux;
}

void rotateToLeft(Node *&T)
{
    Node *aux = T->dr;
    T->dr = aux->st;
    aux->st = T;

    T = aux;
}

void balance(Node *&T)
{
    if (T->st->priority > T->priority)
        rotateToRight(T);
    else if (T->dr->priority > T->priority)
        rotateToLeft(T);
}

void insert(Node *&T, int k, int p)
{
    if (T == NIL)
    {
        T = new Node(k, p, NIL, NIL);
    }
    else
    {
        if (k < T->key)
            insert(T->st, k, p);
        else if (k > T->key)
            insert(T->dr, k, p);

        balance(T);
    }
}

bool find(Node *&T, int k)
{
    if (T == NIL) return false;
    if (k == T->key) return true;
    if (k < T->key) return find(T->st, k);
    else            return find(T->dr, k);
}

void erase(Node *&T, int k)
{
    if (T == NIL) return;

    if (k < T->key)
        erase(T->st, k);
    else if (k > T->key)
        erase(T->dr, k);
    else
    {
        if (T->st == NIL && T->dr == NIL)
        {
            delete T;
            T = NIL;
        }
        else
        {
            if (T->st->priority > T->dr->priority)
            {
                rotateToRight(T);
                erase(T->dr, k);
            }
            else
            {
                rotateToLeft(T);
                erase(T->st, k);
            }
        }
    }
}

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

    ios_base::sync_with_stdio( false );

    int N;
    in >> N;

    initTreap();

    while ( N-- )
    {
        int tip, x;

        in >> tip >> x;

        switch(tip)
        {
            case 1: insert(root, x, 1 + rand()); break;
            case 2: erase(root, x); break;
            case 3: out << find(root, x) << "\n"; break;

            default: cerr << "Error\n";
        }
    }

    return 0;
}