#include <bits/stdc++.h>
using namespace std;
#ifndef SIZE_BALANCED_TREE
#define SIZE_BALANCED_TREE
namespace Size_Balanced_Tree 
{
template<typename T>
struct Less {
    inline bool operator()(register const T &a, register const T &b) 
    {
        return a < b;
    }
};
template<typename T>
struct Greater {
    inline bool operator()(register const T &a, register const T &b) 
    {
        return b < a;
    }
};
template<typename T, typename Comper = Less<T>>
struct SBT {
#define nullptr NILL
#define ls ch[0]
#define rs ch[1]
private:
    Comper cmp;
    struct node 
    {
        node *ch[2];
#ifdef SIZE_BALANCED_TREE_ITERATOR
        node *father;
#endif
        T key;
        int size;
    } *root, *nullptr;
#ifdef SIZE_BALANCED_TREE_ITERATOR
    inline void remeber_father(register node *&son, register node *&fa) 
    {
        if (son == nullptr)
            return;

        son->father = fa;
    }
#endif
    inline void update(register node *p) 
    {
        p->size = p->ls->size + p->rs->size + 1;
    }
    inline node *newnode(register const T &asdfghjkl) 
    {
        register node *p(new node);
        return p->ls = p->rs = nullptr, p->size = 1, p->key = asdfghjkl, p;
    }
    inline void rotate(register node *&p, register const bool &f) 
    {
        register node *t(p->ch[f]);
#ifndef SIZE_BALANCED_TREE_ITERATOR
        p->ch[f] = t->ch[!f], t->ch[!f] = p;
#else
        p->ch[f] = t->ch[!f], remeber_father(p->ch[f], p), t->ch[!f] = p, remeber_father(t->ch[!f], t);
#endif
        t->size = p->size, update(p), p = t;
    }
    inline void maintain(register node *&p, register const bool &f) 
    {
        if (p == nullptr)
            return;

        if (p->ch[f]->ch[f]->size > p->ch[!f]->size)
            rotate(p, f);
        else if (p->ch[f]->ch[!f]->size > p->ch[!f]->size)
            rotate(p->ch[f], !f), rotate(p, f);
        else
            return;

        maintain(p->ch[f], f), maintain(p, f);
    }
    inline void INSERT(register node *&p, register const T &k) 
    {
        if (p == nullptr) 
        {
            p = newnode(k);
            return;
        }

        register bool asdfghjkl(cmp(p->key, k));
        ++p->size, INSERT(p->ch[asdfghjkl], k);
#ifdef SIZE_BALANCED_TREE_ITERATOR
        remeber_father(p->ls, p), remeber_father(p->rs, p);
#endif
        maintain(p, asdfghjkl);
    }
    inline node *FIND(register node *p, register const T &k) 
    {
        if (p == nullptr)
            return nullptr;

        if (!(cmp(p->key, k) || cmp(k, p->key)))
            return p;

        return FIND(p->ch[cmp(p->key, k)], k);
    }
    inline T del(register node *&p, register const T &k) 
    {
        register T res;

        if (--p->size, !(cmp(p->key, k) || cmp(k, p->key)) || (p->ls == nullptr && cmp(k, p->key)) ||
                (p->rs == nullptr && cmp(p->key, k))) 
                {
            res = p->key;

            if (p->ls == nullptr || p->rs == nullptr) 
            {
                register node *temp;

                if (p->ls == nullptr) 
                {
                    temp = p->rs;
#ifdef SIZE_BALANCED_TREE_ITERATOR
                    remeber_father(temp, p->father);
#endif
                } 
                else 
                {
                    temp = p->ls;
#ifdef SIZE_BALANCED_TREE_ITERATOR
                    remeber_father(temp, p->father);
#endif
                }

                delete p, p = temp;
            } 
            else
                p->key = del(p->ls, k);
        } 
        else
            res = del(p->ch[!cmp(k, p->key)], k);

        return res;
    }
    inline node *upper__bound(register node *p, register const T &k) 
    {
        if (p == nullptr)
            return nullptr;

        if (!cmp(k, p->key))
            return upper__bound(p->rs, k);

        register node *temp(upper__bound(p->ls, k));

        if (temp == nullptr)
            return p;

        return temp;
    }
    inline node *pre(register node *p, register const T &k) 
    {
        if (p == nullptr)
            return nullptr;

        if (!cmp(p->key, k))
            return pre(p->ls, k);

        register node *temp(pre(p->rs, k));

        if (temp == nullptr)
            return p;

        return temp;
    }
    inline void CLEAR(register node *p) 
    {
        if (p == nullptr)
            return;

        CLEAR(p->ls), CLEAR(p->rs), delete p;
    }
    inline void print(register node *p) 
    {
        if (p == nullptr)
            return;

        print(p->ls), cout << p->key << ' ', print(p->rs);
    }
public:
    inline SBT() 
    {
        root = nullptr = new node, nullptr->ls = nullptr->rs = nullptr, nullptr->size = 0;
#ifdef SIZE_BALANCED_TREE_ITERATOR
        root->father = nullptr->father = nullptr;
#endif
    }
    inline ~SBT() 
    {
        CLEAR(root);
        delete nullptr;
    }
    struct iterator 
    {
    public:
        inline iterator() {}
        inline iterator(register node *o): p(o) {}
        inline const node *what()const 
        {
            return p;
        }
        inline const T &operator*()const 
        {
            return p->key;
        }
        inline bool operator!=(register const iterator &asdfghjkl)const 
        {
            return p != asdfghjkl.what();
        }
        inline bool operator==(register const iterator &asdfghjkl)const 
        {
            return p == asdfghjkl.what();
        }
#ifdef SIZE_BALANCED_TREE_ITERATOR
        inline iterator &operator++() 
        {
            if (p->rs->size)
                for (p = p->rs; p->ls->size; p = p->ls);
            else 
            {
                register node *now(p), *father(p->father);

                while ((father->size) && (now == father->rs))
                    now = father, father = father->father;

                p = father;
            }

            return *this;
        }
        inline iterator &operator--() 
        {
            if (p->ls->size)
                for (p = p->ls; p->rs->size; p = p->rs);
            else 
            {
                register node *now(p), *father(p->father);

                while ((father->size) && (now == father->ls))
                    now = father, father = father->father;

                p = father;
            }

            return *this;
        }
        inline const iterator operator++(int) 
        {
            register iterator temp(*this);
            return ++*this, temp;
        }
        inline const iterator operator--(int) 
        {
            register iterator temp(*this);
            return --*this, temp;
        }
#endif
    private:
        node *p;
    };
    inline void insert(register const T &k) 
    {
        INSERT(root, k);
#ifdef SIZE_BALANCED_TREE_ITERATOR
        root->father = nullptr;
#endif
    }
    inline void erase(register const T &k) 
    {
        if (FIND(root, k) != nullptr) 
        {
            del(root, k);
#ifdef SIZE_BALANCED_TREE_ITERATOR
            root->father = nullptr;
#endif
        }
    }
    inline void erase(register iterator it) 
    {
        register T k(*it);

        if (FIND(root, k) != nullptr) 
        {
            del(root, k);
#ifdef SIZE_BALANCED_TREE_ITERATOR
            root->father = nullptr;
#endif
        }
    }
    inline iterator find(register const T &k) 
    {
        return FIND(root, k);
    }
    inline int order_of_key(register const T &k) 
    {
        register int res(0);

        for (register node * p(root); p != nullptr;)
            if (!cmp(p->key, k))
                p = p->ls;
            else
                res += p->ls->size + 1, p = p->rs;

        return res;
    }
    inline iterator find_by_order(register int k) 
    {
        for (register node * p(root); p != nullptr;) 
        {
            if (p->ls->size + 1 == k)
                return p;

            if (k <= p->ls->size)
                p = p->ls;
            else
                k -= p->ls->size + 1, p = p->rs;
        }

        return nullptr;
    }
    inline iterator begin() 
    {
        register node *i(root);

        while (i->ls != nullptr)
            i = i->ls;

        return i;
    }
    inline iterator end() 
    {
        return nullptr;
    }
    inline iterator upper_bound(register const T &k) 
    {
        return upper__bound(root, k);
    }
    inline iterator lower_bound(register const T &k) 
    {
        register node *temp(FIND(root, k));

        if (temp != nullptr)
            return temp;

        return upper__bound(root, k);
    }
    inline iterator prev(register const T &k) 
    {
        return pre(root, k);
    }
    inline iterator next(register const T &k) 
    {
        return upper__bound(root, k);
    }
    inline int size() 
    {
        return root->size;
    }
    inline bool empty() 
    {
        return root == nullptr;
    }
    inline void output() 
    {
        print(root);
    }
    inline void clear() 
    {
        CLEAR(root), root = nullptr;
#ifdef SIZE_BALANCED_TREE_ITERATOR
        root->father = nullptr;
#endif
    }
#undef nullptr
#undef ls
#undef rs
};
}
using Size_Balanced_Tree::Less;
using Size_Balanced_Tree::Greater;
using Size_Balanced_Tree::SBT;
#endif
namespace FAST_IO 
{
char buf[1048576], *p1, *p2, ch;
int x;
#define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1048576,stdin),p1==p2)?EOF:*p1++)
inline int read() {
    x = 0, ch = getchar();

    while (!isdigit(ch))
        ch = getchar();

    do
        x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();

    while (isdigit(ch));

    return x;
}
inline void write_ans(const int &p) 
{
    if (9 < p)
        write_ans(p / 10);

    putchar(p % 10 | 48);
}
inline void write(const int &p, const char &c = '\n') 
{
    write_ans(p), putchar(c);
}
#undef getchar
}
using FAST_IO::read;
using FAST_IO::write;
SBT<int>tree;
SBT<int>::iterator it;
int main() 
{
    for (int n(read()), x, op; n--;) 
    {
        op = read(), x = read();

        switch (op) 
        {
        case 0:
            tree.insert(x);
            break;

        case 1:
            tree.erase(x);
            break;

        case 3:
            write(tree.order_of_key(x));
            break;

        case 2:
            write(*tree.find_by_order(x));
            break;

        case 4:
            it = tree.prev(x);

            if (it != tree.end())
                write(*it);
            else
                fputs("-1\n", stdout);

            break;

        default:
            it = tree.next(x);

            if (it != tree.end())
                write(*it);
            else
                fputs("-1\n", stdout);
        }
    }

    return 0;
}