测试 ： https://www.luogu.com.cn/record/170364447

#include <bits/stdc++.h>
using namespace std;
constexpr int N = 5e5 + 10, INF = 1e9;

void Read(int& a)
{
    char ch;
    bool flag = true;
    do
    {
        ch = getchar();
        if (ch == '-') flag = !flag;
    }
    while (ch < '0' || ch > '9');
    a = 0;
    while (ch >= '0' && ch <= '9')
    {
        a = a * 10 + ch - '0';
        ch = getchar();
    }
    if (!flag) a = -a;
}

void Write(int a)
{
    if (a < 0)
    {
        putchar('-');
        a = -a;
    }
    if (a / 10) Write(a / 10);
    putchar(a % 10 + '0');
}

struct treap
{
    int l{}, r{}, size{}, val{}, key{};
} tree[N];

int idx, root;

void update(const int u)
{
    tree[u].size = tree[tree[u].l].size + tree[tree[u].r].size + 1;
}

int new_node(const int v)
{
    tree[++idx].val = v;
    tree[idx].key = rand();
    tree[idx].size = 1;
    return idx;
}

void Split(const int id, int& x, int& y, const int v)
{
    if (!id)
    {
        x = y = 0;
        return;
    }
    if (tree[id].val <= v)
    {
        x = id, Split(tree[id].r, tree[id].r, y, v);
    }
    else
    {
        y = id, Split(tree[id].l, x, tree[id].l, v);
    }
    update(id);
}

int merge(const int x, const int y)
{
    if (!x || !y) return x | y;
    if (tree[x].key < tree[y].key)
    {
        tree[x].r = merge(tree[x].r, y);
        update(x);
        return x;
    }
    else
    {
        tree[y].l = merge(x, tree[y].l);
        update(y);
        return y;
    }
}

int Search(const int id, const int k)
{
    if (!id) return -INF;
    if (k <= tree[tree[id].l].size) return Search(tree[id].l, k);
    else if (tree[tree[id].l].size + 1 == k) return id;
    else return Search(tree[id].r, k - tree[tree[id].l].size - 1);
}

void solve();

int main()
{
    // srand(static_cast<unsigned>(time(nullptr)));
    int T;
    Read(T);
    while (T--) solve();
    return 0;
}

void add(const int v)
{
    int x, y;
    const int z = new_node(v);
    Split(root, x, y, v);
    root = merge(merge(x, z), y);
}

void reverse(const int v)
{
    int x, y, z;
    Split(root, x, y, v);
    Split(root, x, z, v - 1);
    root = merge(merge(x, merge(tree[z].l, tree[z].r)), y);
}

int get_rank(const int v)
{
    int x, y;
    Split(root, x, y, v - 1);
    const int ret = tree[x].size + 1;
    root = merge(x, y);
    return ret;
}

int val(const int k)
{
    return tree[Search(root, k)].val;
}

int get_prev(const int v)
{
    int x, y;
    Split(root, x, y, v - 1);
    const int ret = Search(x, tree[x].size);
    root = merge(x, y);
    return tree[ret].val;
}

int get_next(const int v)
{
    int x, y;
    Split(root, x, y, v);
    const int ret = Search(y, 1);
    root = merge(x, y);
    return tree[ret].val;
}

void solve()
{
    int opt, x;
    Read(opt), Read(x);
    if (opt == 1) add(x);
    if (opt == 2) reverse(x);
    if (opt == 3) Write(get_rank(x)), putchar('\n');
    if (opt == 4) Write(val(x)), putchar('\n');
    if (opt == 5) Write(get_prev(x)), putchar('\n');
    if (opt == 6) Write(get_next(x)), putchar('\n');
}