#include <bits/stdc++.h>

using namespace std;

const int NR_NODES = 1 << 16;
const int INF = 1 << 30;

struct Treap
{
    int st, dr;
    int key, priority;

    Treap(int k = 0, int p = 0)
    {
        key = k;
        priority = p;
        st = dr = 0;
    }
};

Treap T[NR_NODES];
int root, size;

inline void rol( int &node )
{
    int aux = T[node].st;
    T[node].st = T[aux].dr;
    T[aux].dr = node;

    node = aux;
}

inline void ror( int &node )
{
    int aux = T[node].dr;
    T[node].dr = T[aux].st;
    T[aux].st = node;

    node = aux;
}
inline void balance( int &node )
{
    if ( T[node].st && T[ T[node].st ].priority > T[node].priority )
            rol( node );

    if ( T[node].dr && T[ T[node].dr ].priority > T[node].priority )
            ror( node );
}

void insert(int &node, int k, int p = rand() % INF)
{
    if ( !node )
    {
        node = ++size;
        T[node] = Treap(k, p);
    }
    else
    {
        if ( k < T[node].key )
            insert( T[node].st, k, p );
        else
            if ( k > T[node].key )
                insert( T[node].dr, k, p );

        balance(node);
    }
}

bool find(int node, int k)
{
    if ( !node ) return false;
    if ( T[node].key == k ) return true;
    if ( k < T[node].key ) return find( T[node].st, k );
    else                   return find( T[node].dr, k );
}

void erase(int &node, int k)
{
   if ( !node ) return;

   if ( k < T[node].key )
        erase( T[node].st, k );
   else
        if ( k > T[node].key )
            erase( T[node].dr, k );
        else
        {
            if ( T[node].st == 0 && T[node].dr == 0 )
            {
                T[node] = Treap(0, 0);
                node = 0;
            }
            else
            {
                if ( T[ T[node].st ].priority > T[ T[node].dr ].priority )
                {
                    rol( node );
                    erase( node, k );
                }
                else
                {
                    ror( node );
                    erase( node, k );
                }
            }
        }
}

void print(int node)
{
    if ( !node ) return;
    print( T[node].st );
    cout << T[node].key << " ";
    print( T[node].dr );
}

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

    ios_base::sync_with_stdio( false );

    int N;
    srand( time( 0 ) );

    in >> N;

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

        in >> tip >> x;

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

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

    return 0;
}