#include <fstream>
#include <iostream>

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)
                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)
                first = last = nullptr;
            else {
                last = last->prev;
                delete last->next;
                last->next = nullptr;
            }
        }

        Node * begin() {
            return first;
        }

        Node * end() {
            return last;
        }

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

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

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

template <typename T>
class Queue {

    private:
        struct Node {

            T item;
            Node * next;

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

        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 end() {
            return last->item;
        }

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

template <typename T>
class Stack {

    private:
        struct Node {

            T item;
            Node * prev;

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

        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->prev;
            delete last;
            last = node;
            }

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

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

class Hash {

    #define mod 2000001

    private:
        struct Node {
            int key;
            short state;
            Node() {
                state = 0;
            }
        };

        Node H[mod];

        int findSlot(int key, int constraint1, int constraint2) {

            int index = key % mod;

            while(H[index].state != constraint1 && H[index].state != constraint2 && H[index].key != key) {
                ++index;
                if(index == mod)
                    index = 0;
            }

            return index;
        }

    public:
        Hash() {
        }

        void insert(int key) {

            int index = findSlot(key, -1, 0);
            H[index].key = key;
            H[index].state = 1;
        }

        bool search(int key) {
            return (H[findSlot(key, 0, 0)].key == key);
        }

        void remove(int key) {

            int index = findSlot(key, 0, 0);

            if(H[index].state != 0) {
                H[index].key = -1;
                H[index].state = -1;
            }
        }
} h;

int main() {

    int type, x, queries;
    ifstream in("hashuri.in");
    ofstream out("hashuri.out");

    in >> queries;
    while(queries--) {

        in >> type >> x;

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

        }

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

    return 0;
}