#include <fstream>
#include <cstring>
#include <vector>

using namespace std;


template <typename T>
class Deque {

    private:
        struct Node {

            T item;
            Node * prev, * next;

            Node(T newItem) {
                prev = next = nullptr;
                item = newItem;
            }
        };

        Node * first, * last;

    public:
        Deque() {
            first = last = nullptr;
        }

        void push_front(T newItem) {

            Node * node = new Node(newItem);

            if(first == nullptr)
                first = last = node;
            else {
                first->prev = node;
                node->next = first;
                first = node;
            }
        }

        void pop_front() {

            if(first == nullptr)
                return;

            if(first->next == nullptr) {
                delete first;
                first = last = nullptr;
            }
            else {
                first = first->next;
                delete first->prev;
                first->prev = nullptr;
            }
        }

        void push_back(T newItem) {

            Node * node = new Node(newItem);

            if(last == nullptr)
                first = last = node;
            else {
                last->next = node;
                node->prev = last;
                last = node;
            }
        }

        void pop_back() {

            if(last == nullptr)
                return;

            if(last->prev == nullptr) {
                delete last;
                first = last = nullptr;
            }
            else {
                last = last->prev;
                delete last->next;
                last->next = nullptr;
            }
        }

        T front() {
            return first->item;
        }

        T back() {
            return last->item;
        }

        Node * begin() {
            return first;
        }

        Node * end() {
            return last;
        }

        bool empty() {
            return (first == nullptr);
        }

};

template <typename T>
class Queue {

    private:
        struct Node {

            T item;
            Node * next;
            Node(T newItem) {
                item = newItem;
                next = nullptr;
            }
        };

        Node * first, * last;

    public:
        Queue() {
            first = last = nullptr;
        }

        void push(T newItem) {

            Node * node = new Node(newItem);

            if(last == nullptr)
                first = last = node;
            else {
                last->next = node;
                last = node;
            }
        }

        void pop() {

            if(first == nullptr)
                return;

            Node * node = first;

            if(first->next == nullptr)
                first = last = nullptr;
            else
                first = first->next;

            delete node;
        }

        T front() {
            return first->item;
        }

        T back() {
            return last->item;
        }

        Node * begin() {
            return first;
        }

        Node * end() {
            return last;
        }

        bool empty() {
            return (first == nullptr);
        }

};

template <typename T>
class Stack {

    private:
        struct Node {

            T item;
            Node * prev;
            Node(T newItem) {
                item = newItem;
                prev = nullptr;
            }
        };

        Node * last;

    public:
        Stack() {
            last = nullptr;
        }

        void push(T newItem) {

            Node * node = new Node(newItem);
            node->prev = last;
            last = node;
        }

        void pop() {

            if(last == nullptr)
                return;

            Node * node = last;
            last = last->prev;
            delete node;
        }

        T top() {
            return last->item;
        }

        bool empty() {
            return (last == nullptr);
        }

};

class Hash {

    #define mod 666013

    private:
        vector <int> H[mod];

        int find(int key) {

            int i, normal = key % mod;

            for(i = 0; i < H[normal].size(); i++)
                if(H[normal][i] == key)
                    return i;

            return -1;
        }

    public:
        Hash() {
        }

        void insert(int key) {
            if(find(key) == -1)
                H[key % mod].push_back(key);
        }

        bool search(int key) {
            return (find(key) != -1);
        }

        void erase(int key) {

            int i = find(key);

            if(i != -1) {
                int normal = key % mod;
                H[normal][i] = H[normal][H[normal].back()];
                H[normal].pop_back();
            }
        }

};

class HashOpenAdressing {

    #define mod 666013

    private:
        struct Node {
            int key;
            char state;
            };

        Node A[mod];

        int find_slot(int key) {

            int i = key % mod;

            while(A[i].state != 0 && A[i].key != key)
                i = (i == mod - 1 ? 0 : i + 1);

            return i;
        }

    public:
        HashOpenAdressing() {
            memset(A, 0, sizeof(A));
        }

        void insert(int key) {

            int i = key % mod;

            while(A[i].state == 1 && A[i].key != key)
                i = (i == mod - 1 ? 0 : i + 1);

            if(A[i].state != 1) {
                A[i].key = key;
                A[i].state = 1;
            }
        }

        bool search(int key) {
            return (A[find_slot(key)].key == key);
        }

        void erase(int key) {

            int i = find_slot(key);

            if(A[i].state == 1) {
                A[i].key = -1;
                A[i].state = -1;
            }
        }

};

class priorityQueue {

    #define Nmax 100100
    #define Root 1
    #define father(x) (x >> 1)
    #define left(x) (x << 1)
    #define right(x) (left(x) | 1)
    #define compare(a, b) (heap[a] < heap[b])

    private:
        int top, heap[Nmax];

        void up(int Node) {

            while(Node != Root && compare(Node, father(Node))) {
                swap(heap[Node], heap[father(Node)]);
                Node = father(Node);
            }
        }

        void down(int Node) {

            int son;

            do {
                son = 0;

                if(left(Node) <= top) {
                    son = left(Node);
                    if(right(Node) <= top && compare(right(Node), son))
                        son = right(Node);
                    if(compare(Node, son))
                        son = 0;
                }

                if(son != 0) {
                    swap(heap[Node], heap[son]);
                    Node = son;
                }
            } while(son != 0);
        }

    public:
        priorityQueue() {
            top = 0;
        }

        void insert(int value) {
            heap[++top] = value;
            up(top);
        }

        void pop() {
            heap[1] = heap[top--];
            down(1);
        }

        int front() {
            return heap[1];
        }

        int size() {
            return top;
        }

        bool empty() {
            return (top == 0);
        }

};

template <typename T>
class AVL {

    private:
        struct Node {

            T key;
            int height;
            Node * left, * right;

            Node(Node * node, int Height, T Key) {
                key = Key;
                height = Height;
                left = right = node;
            }
        };

        Node * root, * NIL;

        Node * insert(Node * node, T & key) {

            if(node == NIL) {
                node = new Node(NIL, 0, key);
                return node;
            }

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

            return balance(node);
        }

        bool search(Node * node, T & key) {

            if(node == NIL)
                return false;
            else
            if(key == node->key)
                return true;
            else
            if(key < node->key)
                return search(node->left, key);
            else
                return search(node->right, key);
        }

        Node * erase(Node * node, T & key) {

            if(node == NIL)
                return NIL;

            if(node->key == key) {

                Node * p;

                if(node->left == NIL || node->right == NIL) {
                    p = (node->left == NIL ? node->right : node->left);
                    delete node;
                    return p;
                }

                for(p = node->left; p->right != NIL; p = p->right);

                node->key = p->key;
                node->left = erase(node->left, node->key);
            }
            else if(key < node->key)
                node->left = erase(node->left, key);
            else
                node->right = erase(node->right, key);

            return balance(node);
        }

        inline void setHeight(Node * node) {
            node->height = 1 + max(node->left->height, node->right->height);
        }

        Node * leftRotate(Node * node) {
            Node * p = node->right;
            node->right = p->left;
            p->left = node;

            setHeight(node);
            setHeight(p);

            return p;
        }

        Node * rightRotate(Node * node) {
            Node * p = node->left;
            node->left = p->right;
            p->right = node;

            setHeight(node);
            setHeight(p);

            return p;
        }

        Node * balance(Node * node) {

            setHeight(node);

            if(node->left->height > node->right->height + 1) {
                if(node->left->right->height > node->left->left->height)
                    node->left = leftRotate(node->left);
                node = rightRotate(node);
            }
            else if(node->right->height > node->left->height + 1) {
                if(node->right->left->height > node->right->right->height)
                    node->right = rightRotate(node->right);
                node = leftRotate(node);
            }

            return node;
        }

    public:
        AVL() {
            NIL = new Node(NIL, -1, 0);
            root = NIL;
        }

        void insert(T key) {
            root = insert(root, key);
        }

        bool search(T key) {
            return search(root, key);
        }

        void erase(T key) {
            root = erase(root, key);
        }

};

int main() {

    int type, x, queries;
    AVL <int> avl;

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

    in >> queries;

    while(queries--) {

        in >> type >> x;

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

        }

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

    return 0;
}