йц

#include <iostream>
#include <algorithm>

struct Node {
    int size;
    int value;
    int height;
    struct Node *left;
    struct Node *right;
};

class AVLTree {
private:
    Node *root_;

    void clear(Node *n) {
        if (n == nullptr) {
            return;
        }
        clear(n->left);
        clear(n->right);
        delete n;
    }

    int height(Node *n) {
        if (n == nullptr) {
            return 0;
        }
        return n->height;
    }

    int balance(Node *n) {
        if (n == nullptr) {
            return 0;
        }
        return height(n->left) - height(n->right);
    }

    Node *insert(int val, Node *n) {
        if (n == nullptr) {
            n = new Node;
            n->value = val;
            n->left = nullptr;
            n->right = nullptr;
            n->height = 1;
            n->size = 1;
            return n;
        }
        if (val < n->value) {
            n->left = insert(val, n->left);
        } else if (val > n->value) {
            n->right = insert(val, n->right);
        } else {
            return n;
        }
        update(n);
        return rebalance(n);
    }

    Node *erase(Node *n, int val) {
        if (n == nullptr) {
            return nullptr;
        }
        if (n->value > val) {
            n->left = erase(n->left, val);
        } else if (n->value < val) {
            n->right = erase(n->right, val);
        } else {
            Node *left = n->left;
            Node *right = n->right;
            delete n;
            if (left == nullptr) {
                return right;
            } else if (right == nullptr) {
                return left;
            }
            Node *tmp = right;
            while (tmp->left != nullptr) {
                tmp = tmp->left;
            }
            tmp->left = left;
            update(tmp);
            return rebalance(tmp);
        }
        update(n);
        return rebalance(n);
    }

    Node *rebalance(Node *n) {
        int b = balance(n);
        if (b > 1 && balance(n->left) < 0) {
            n->left = leftRotate(n->left);
            return rightRotate(n);
        } else if (b < -1 && balance(n->right) > 0) {
            n->right = rightRotate(n->right);
            return leftRotate(n);
        } else if (b > 1) {
            return rightRotate(n);
        } else if (b < -1) {
            return leftRotate(n);
        }
        return n;
    }

    Node *rightRotate(Node *n) {
        Node *rotated = n->left;
        Node *right = rotated->right;
        rotated->right = n;
        n->left = right;
        update(n);
        update(rotated);
        return rotated;
    }

    Node *leftRotate(Node *n) {
        Node *rotated = n->right;
        Node *left = rotated->left;
        rotated->left = n;
        n->right = left;
        update(n);
        update(rotated);
        return rotated;
    }

    void update(Node *n) {
        n->height = std::max(height(n->left), height(n->right)) + 1;
        n->size = size(n->left) + size(n->right) + 1;
    }

    int size(Node *n) {
        return n ? n->size : 0;
    }

    int at(Node *n, int i) {
        if (!n) {
            return 0;
        }
        if (size(n->left) >= i) {
            return at(n->left, i);
        } else if (size(n->left) + 1 < i) {
            return at(n->right, i - size(n->left) - 1);
        } else {
            return n->value;
        }
    }

public:
    AVLTree() {
        root_ = nullptr;
    }

    void insert(int val) {
        root_ = insert(val, root_);
    }

    void erase(int value) {
        root_ = erase(root_, value);
    }

    int at(int index) {
        return at(root_, index);
    }

    ~AVLTree() {
        clear(root_);
    }
};

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    AVLTree s;
    int x, n;
    char ch;
    std::cin >> n;
    for (int i = 0; i < n; ++i) {
        std::cin >> ch >> x;
        if (ch == '?') {
            std::cout << s.at(x) << std::endl;
        } else if (ch == '+') {
            s.insert(x);
        } else if (ch == '-') {
            s.erase(x);
        }
    }
    return 0;
}