#include <fstream>
#include <vector>

#define Nmax 200100
#define mod 666013

using namespace std;

template <typename T>
class binarySearchTree {

    private:
        struct Node {
            T Value;
            Node * leftSon, * rightSon;
            Node() {
                Value = 0;
                leftSon = rightSon = NULL;
            };
        };

    private:
        Node * Root;

    public:
        binarySearchTree() {
            Root = NULL;
        }

        void insert(const T & Value) {
            Root = insert(Root, Value);
        }

        bool search(const T & Value) {
            return search(Root, Value);
        }

        void erase(const T & Value) {
            Root = erase(Root, Value);
        }

    private:
        Node * insert(Node * node, const T & Value) {

            if(node == NULL) {
                node = new Node;
                node->Value = Value;
                return node;
            }

            if(Value < node->Value)
                node->leftSon = insert(node->leftSon, Value);
            if(Value > node->Value)
                node->rightSon = insert(node->rightSon, Value);

            return node;
        }

        bool search(Node * node, const T & Value) {

            if(node == NULL)
                return 0;
            else
            if(Value == node->Value)
                return true;
            else
            if(Value < node->Value)
                return search(node->leftSon, Value);
            else
                return search(node->rightSon, Value);
        }

        Node * erase(Node * node, const T & Value) {

            if(node == NULL)
                return NULL;

            if(node->Value == Value) {

                if(node->leftSon == NULL && node->rightSon == NULL) {
                    delete node;
                    return NULL;
                }
                else if(node->leftSon == NULL || node->rightSon == NULL) {
                    Node * p = (node->leftSon == NULL ? node->rightSon : node->leftSon);
                    delete node;
                    return p;
                }
                else {
                    Node * p;
                    p = node->leftSon;

                    while(p->rightSon != NULL)
                        p = p->rightSon;

                    node->Value = p->Value;
                    node->leftSon = erase(node->leftSon, p->Value);
                }
            } else if(Value < node->Value)
                node->leftSon = erase(node->leftSon, Value);
            else
                node->rightSon = erase(node->rightSon, Value);
        }
};

int main() {

    int type, x, T;
    binarySearchTree <int> bst;

    ifstream in("hashuri.in");
    ofstream out("hashuri.out");

    in >> T;

    while(T--) {

        in >> type >> x;

        switch(type) {
            case 1: bst.insert(x); break;
            case 2: bst.erase(x); break;
            case 3: out << (bst.search(x) == 1) << '\n';
            }

        }

    in.close();
    out.close();

    return 0;

}