/**
 * Code by Patrick Sava
 * "Spiru Haret" National College of Bucharest
 **/

# include "fstream"
# include "cstring"
# include "vector"
# include "queue"
# include "bitset"
# include "algorithm"
# include "map"
# include "set"
# include "unordered_map"
# include "deque"
# include "string"
# include "iomanip"
# include "cmath"
# include "stack"
# include "cassert"

const char IN [ ] =  "hashuri.in" ;
const char OUT [ ] = "hashuri.out" ;

# define pb push_back
# define mp make_pair
# define FORN( a , b , c ) for ( int a = b ; a <= c ; ++ a )
# define FORNBACK( a , b , c ) for ( int a = b ; a >= c ; -- a )

using namespace std ;

ifstream cin ( IN ) ;
ofstream cout ( OUT ) ;

struct node {
    int k , p , l , r ;
    node ( )
    {
        p = rand ( ) ;
        l = 0 ;
        r = 0 ;
    }
};

node t [ 500000 ] ;
int nodes = 0 ;
int R = 0 ;

inline void split ( int root , int k , int &l , int &r )
{
    if ( root == 0 ){
        l = r = 0 ;
    }
    else if ( t [ root ].k > k ){
        split ( t [ root ].l , k , l , t [ root ].l ) ;
        r = root ;
    }
    else {
        split ( t [ root ].r , k , t [ root ].r , r ) ;
        l = root ;
    }
}

inline void join ( int l , int r , int & newroot )
{
    if ( !l or !r )
        newroot = max ( l , r ) ;
    else {
        if ( t [ l ].p >= t [ r ].p ){
            join ( t [ l ].r , r , t [ l ].r ) ;
            newroot = l ;
        }
        else {
            join ( l , t [ r ].l , t [ r ].l ) ;
            newroot = r ;
        }
    }
}

inline bool findd ( int root , int k )
{
    if ( root == 0 ) return 0 ;
    if ( t [ root ].k == k ) return 1 ;
    if ( t [ root ].k > k )
        return findd ( t [ root ].l , k ) ;
    else return findd ( t [ root ].r , k ) ;
}

inline void insertt ( int &root , int x )
{
    if ( t [ root ].p > t [ x ].p ){
        if ( t [ root ].k > t [ x ].k )
            insertt ( t [ root ].l , x ) ;
        else insertt ( t [ root ].r , x ) ;
    }
    else {
        split ( root , t [ x ].k , t [ x ].l , t [ x ].r ) ;
        root = x ;
    }
}

inline void erasee ( int &root , int k )
{
    if ( root == 0 )
        return ;
    if ( t [ root ].k == k ){
        join ( t [ root ].l , t [ root ].r , root ) ;
    }
    if ( t [ root ].k > k )
        erasee ( t [ root ].l , k ) ;
    else erasee ( t [ root ].r , k ) ;
}


int main ( void )
{
    srand ( time ( 0 ) ) ;
    int n ;
    cin >> n ;
    while ( n-- )
    {
        int op , x ;
        cin >> op >> x ;
        if ( op == 1 ){
            if ( !findd ( R , x ) ){
                t [ ++ nodes ].k = x ;
                insertt ( R , nodes ) ;
            }
        }
        else if ( op == 2 ){
            if ( findd ( R , x ) == 1 ){
                erasee ( R , x ) ;
            }
        }
        else {
            cout << findd ( R , x ) << '\n' ;
        }
    }
    return 0;
}