#include <bits/stdc++.h>
using namespace std;

template <typename T>
class WBLT {
  private:
    struct node {
        node *l, *r;
        int   val, size;

        node *merge(node *a, node *b) {
            node *res = new node(a, b, 0, 0);
            res->push_up();
            return res;
        }

        void push_up() {
            if (this->l != nullptr && this->r != nullptr) {
                this->val  = this->r->val;
                this->size = this->l->size + this->r->size;
            } else {
                this->size = 1;
            }
        }

        void rotate(bool flag) {
            if (this->l == nullptr || this->r == nullptr) {
                return;
            }

            if (flag) {
                this->l = merge(this->l, this->r->l);
                this->r = this->r->r;
            } else {
                this->r = merge(this->l->r, this->r);
                this->l = this->l->l;
            }
        }

        void matain() {

            if (this->size == 1) {
                return;
            }

            if (this->l->size > this->r->size * 3) {
                if (this->l->size != 1 && this->l->r->size > this->l->l->size * 2) {
                    this->l->rotate(1);
                }
                this->rotate(0);
            } else if (this->r->size > this->l->size * 3) {
                if (this->r->size != 1 && this->r->l->size > this->r->r->size * 2) {
                    this->r->rotate(0);
                }
                this->rotate(1);
            }
        }

        node() {}

        node(node *_l, node *_r, int _val, int _size)
            : l(_l), r(_r), val(_val), size(_size) {}

        node(int _val)
            : l(nullptr), r(nullptr), val(_val), size(1) {}
    } *root;

  public:
    WBLT()
        : root(new node(1e8)) {}

    ~WBLT() {}

    void insert(int v, node *p = nullptr) {

        if (p == nullptr) {
            p = root;
        }

        // cout << p << ' ' << p->l << ' ' << p->r << ' ' << p->size << ' ' << p->val << endl;

        if (p->size == 1) {
            p->l = new node(min(v, p->val));
            p->r = new node(max(v, p->val));

            // cout << "insert over " << p << ' ' << p->l << ' ' << p->r << ' ' << p->size << ' ' << p->val << endl;

            p->push_up();
            // cout << p << " pushup\n";

            p->matain();
            // cout << p << " matain\n";

            return;
        }

        if (p->l->val >= v) {
            insert(v, p->l);
        } else {
            insert(v, p->r);
        }

        p->push_up();
        // cout << p << " pushup\n";

        p->matain();
        // cout << p << " matain\n";

        return;
    }

    void del(int v, node *p = nullptr, node *f = nullptr) {
        if (p == nullptr && f == nullptr) {
            p = f = root;
        }

        if (p->size == 1) {
            if (f->l->val == v) {
                f = f->r;
            } else if (f->r->val == v) {
                f = f->l;
            }

            return;
        }

        if (p->l->val >= v) {
            del(v, p->l, p);
        } else {
            del(v, p->r, p);
        }

        p->push_up();
        p->matain();

        return;
    }

    int rank(int v, node *p = nullptr) {
        if (p == nullptr) {
            p = root;
        }

        if (p->size == 1) {
            return p->val <= v;
        }

        if (p->l->val > v) {
            return rank(v, p->l);
        } else {
            return rank(v, p->r) + p->l->size;
        }
    }

    int kth(int v, node *p = nullptr) {
        if (p == nullptr) {
            p = root;
        }

        if (p->size == v) {
            return p->val;
        }

        if (p->l->size >= v) {
            return kth(v, p->l);
        } else {
            return kth(v - p->l->size, p->r);
        }
    }

    int pre(int v) {
        return kth(rank(v - 1));
    }

    int nxt(int v) {
        return kth(rank(v) + 1);
    }
};

int       m;
WBLT<int> wblt;

int main() {

    // freopen("Weight Balanced Leafy Tree.in", "r", stdin);
    // freopen("Weight Balanced Leafy Tree.out", "w", stdout);

    scanf("%d", &m);

    while (m--) {
        int op, t;
        scanf("%d%d", &op, &t);

        if (op == 1) {
            wblt.insert(t);
        } else if (op == 2) {
            wblt.del(t);
        } else if (op == 3) {
            printf("%d\n", wblt.rank(t - 1) + 1);
        } else if (op == 4) {
            printf("%d\n", wblt.kth(t));
        } else if (op == 5) {
            printf("%d\n", wblt.pre(t));
        } else {
            printf("%d\n", wblt.nxt(t));
        }
    }

    // fclose(stdin);
    // fclose(stdout);

    // system("pause");

    return 0;
}

目前 RE。