#include <bits/stdc++.h>

using namespace std;

class Node
{
public:
    long long key;
    Node *left;
    Node *right;
    int height;
};

int height(Node *N)
{
    if (N == NULL)
        return 0;
    return N->height;
}

Node* newNode(long long key)
{
    Node* node = new Node();

    node->key = key;
    node->left = NULL;
    node->right = NULL;
    node->height = 1;

    return(node);
}

Node *rightRotate(Node *y)
{
    Node *x = y->left;
    Node *T2 = x->right;

    x->right = y;
    y->left = T2;

    y->height = max(height(y->left),
                    height(y->right)) + 1;
    x->height = max(height(x->left),
                    height(x->right)) + 1;

    return x;
}

Node *leftRotate(Node *x)
{
    Node *y = x->right;
    Node *T2 = y->left;

    y->left = x;
    x->right = T2;

    x->height = max(height(x->left),
                    height(x->right)) + 1;
    y->height = max(height(y->left),
                    height(y->right)) + 1;

    return y;
}

int GetBalance(Node *N)
{
    if (N == NULL)
        return 0;
    return height(N->left) - height(N->right);
}

Node* insert(Node* node, long long key)
{
    if (node == NULL)
        return(newNode(key));

    if (key < node->key)
        node->left = insert(node->left, key);
    else if (key > node->key)
        node->right = insert(node->right, key);
    else
        return node;

    node->height = 1 + max(height(node->left),
                           height(node->right));

    int balance = GetBalance(node);

    if (balance > 1 && key < node->left->key)
        return rightRotate(node);

    if (balance < -1 && key > node->right->key)
        return leftRotate(node);

    if (balance > 1 && key > node->left->key)
    {
        node->left = leftRotate(node->left);
        return rightRotate(node);
    }

    if (balance < -1 && key < node->right->key)
    {
        node->right = rightRotate(node->right);
        return leftRotate(node);
    }

    return node;
}

Node* minValue( Node* n)
{
    Node *min = n;

    while( min -> left != NULL)
        min -> left = min -> left;

    return min;

}

Node* deleteNode(Node* node, long long key)
{

    if (node == NULL)
        return node;

    if ( key < node -> key )
        node->left = deleteNode(node -> left, key);
    else
    if( key > node -> key )
        node -> right = deleteNode(node -> right, key);
    else
    {
        if( (node -> left == NULL) || (node -> right == NULL) )
        {
            Node *temp = NULL;
            if (node -> left  != NULL )
                temp = node -> left;
            else
                temp = node -> right;

            if (temp == NULL)
            {
                temp = node;
                node = NULL;
            }
            else
                *node = *temp;

            delete temp;
        }
        else
        {
            Node* temp = minValue(node -> right);
            node -> key = temp -> key;
            node -> right = deleteNode(node -> right, temp -> key);
        }
    }

    if (node == NULL)
        return node;

    node -> height = 1 + max(height(node -> left),
                             height(node -> right));

    int balance = GetBalance(node);

    if (balance > 1 && GetBalance(node -> left) >= 0)
        return rightRotate(node);

    if (balance > 1 && GetBalance(node -> left) < 0)
    {
        node -> left = leftRotate(node -> left);
        return rightRotate(node);
    }

    if (balance < -1 && GetBalance(node -> right) <= 0)
        return leftRotate(node);

    if (balance < -1 && GetBalance(node -> right) > 0)
    {
        node -> right = rightRotate(node -> right);
        return leftRotate(node);
    }
    return node;
}
void preOrder(Node *node)
{
    if(node != NULL)
    {
        cout << node -> key << " ";
        preOrder(node -> left);
        preOrder(node -> right);
    }
}

void afis_crescator(Node *node )
{
    if( node != NULL )
    {
        afis_crescator(node -> left);
        cout << node -> key << " ";
        afis_crescator(node -> right);
    }
}

Node *findMaxim ( Node *root){

    while( root -> right )
        root = root -> right;

    return root;

}

void findPredecessor (Node *node, Node *&pred, int key){

    if(node == NULL){       // daca arborele este null, nu are elemente
        pred = NULL;
        return ;
    }

    if ( node -> key == key ){

        if ( node -> left != NULL )
            pred = findMaxim(node -> left);

    }
    else
    if ( node -> key > key )    //daca cheia este mai mica decat nodul curent
        findPredecessor(node -> left,pred, key);
    else                        ///daca cheia este mai mare decat nodul curent
    {
        pred = node;
        findPredecessor(node -> right, pred, key);
    }

}

void findSuccessor(Node *node, Node *&succ, int key)
{
    if(node == NULL)
    {
        succ = NULL;
        return ;
    }

    if( node -> key == key )
    {
        if(node -> right != NULL)
            succ = minValue(node -> right);

    }
    else
    if(node -> key < key)
        findSuccessor(node -> right, succ, key);
    else
    {
        succ = node;
        findSuccessor(node -> left, succ, key);
    }
}
Node * find_elem( Node *node, long long key){
    if(node == NULL )
        return NULL;
    if (node -> key == key )
        return node;
    else
        if ( node -> key > key )
            find_elem(node -> left, key);
        else
            if( node -> key < key)
            find_elem(node -> right, key);

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

    Node *root = NULL;

    int n;
    f >> n;

    int key;
    long long elem;
    for (int  i = 0; i < n; ++i){
        f >> key >> elem;
        if ( key == 1 )
            root = insert(root, elem);

        else if(key == 2)
            root = deleteNode(root, elem);

        else{
            Node *element = find_elem(root, elem);
            if ( element != NULL )
                g << 1 << '\n';
            else
                g << 0 << "\n";
        }
    }
    return 0;
}