struct node {
    int x, y;
    unique_ptr<node> l = nullptr, r = nullptr;

    node(int x) : x(x), y(rand()) {}
};

typedef unique_ptr<node> pnode;

auto split(pnode t, int k) -> pair<pnode, pnode> {
    if (t == nullptr) {
        return {nullptr, nullptr};
    }

    int key, pri;
    tie(key, pri) = {t->x, t->y};

    if (key >= k) {
        auto pa = split(move(t->l), k);
        t->l = move(pa.second);
        return {move(pa.first), move(t)};
    } else {
        auto pa = split(move(t->r), k);
        t->r = move(pa.first);
        return {move(t), move(pa.second)};
    }
}

auto merge(pnode l, pnode r) -> pnode {
    if (l == nullptr || r == nullptr) {
        return l ? move(l) : move(r);
    }

    if (l->y > r->y) {
        l->r = merge(move(l->r), move(r));
        return l;
    } else {
        r->l = merge(move(l), move(r->l));
        return r;
    }
}

auto insert(pnode t, int x) -> pnode {
    auto pa = split(move(t), x);

    return merge(move(pa.first), merge(make_unique<node>(x), move(pa.second)));
}

auto erase(pnode t, int x) -> pnode {
    auto pa = split(move(t), x);
    auto pa1 = split(move(pa.second), x + 1);
    return merge(move(pa.first), move(pa1.second));
}

auto left(pnode& t)-> int {
    if (t->l == nullptr) return t->x;
    return left(t->l);
}

auto lower_bound(pnode& t, int x) -> int {
    auto pa = split(move(t), x);

    int ans = pa.second? left(pa.second): -1;

    t = merge(move(pa.first), move(pa.second));

    return ans;
}

auto into_vec(pnode t, vector<int>& a) -> void {
    if (t->l) into_vec(move(t->l), a);
    a.push_back(t->x);
    if (t->r) into_vec(move(t->r), a);
}

auto into_vec(pnode t) -> vector<int> {
    vector<int> res;
    into_vec(move(t), res);
    return res;
}

auto from_vec(vector<int>& from) -> pnode {
    pnode res = nullptr;
    for (auto& i: from) res = insert(move(res), i);
    return res;
}