#include <bits/stdc++.h>

using namespace std;

constexpr int INF = 2e9;
constexpr int SEED = 314159265;
mt19937 rng(SEED);

struct Treap {
    Treap *left, *right;
    int key, priority;
    int min_val, max_val;
    int min_diff, max_diff;
    int size;

    inline Treap(int key)
        : left(), right(), key(key), priority(rng()), min_val(key), 
          max_val(key), min_diff(INF), max_diff(-INF),  size(1) {}

    inline ~Treap() {
        delete left;
        delete right;
    }
};

inline void update(Treap *treap) {
    treap->size = 1;
    treap->min_val = treap->max_val = treap->key;
    treap->min_diff = INF;
    if (treap->left) {
        treap->min_val = treap->left->min_val;
        treap->size += treap->left->size;
        treap->min_diff = min(treap->min_diff, treap->left->min_diff);
        treap->min_diff = min(treap->min_diff, treap->key - treap->left->max_val);
    }
    if (treap->right) {
        treap->max_val = treap->right->max_val;
        treap->size += treap->right->size;
        treap->min_diff = min(treap->min_diff, treap->right->min_diff);
        treap->min_diff = min(treap->min_diff, treap->right->min_val - treap->key);
    }
    treap->max_diff = treap->max_val - treap->min_val;
}

inline pair<Treap *, Treap *> split(Treap *treap, int key) {
    if (!treap) return make_pair(nullptr, nullptr);
    if (key <= treap->key) {
        const auto[left, right] = split(treap->left, key);
        treap->left = right;
        update(treap);
        return make_pair(left, treap);
    } else {
        const auto[left, right] = split(treap->right, key);
        treap->right = left;
        update(treap);
        return make_pair(treap, right);
    }
}

inline Treap * merge(Treap *treap1, Treap *treap2) {
    if (!treap1 || !treap2) 
        return treap1 ? treap1 : treap2;
    if (treap1->priority >= treap2->priority) {
        treap1->right = merge(treap1->right, treap2);
        update(treap1);
        return treap1;
    } else {
        treap2->left = merge(treap1, treap2->left);
        update(treap2);
        return treap2;
    }
}

inline Treap * insert(Treap *treap, int key) {
    const auto[left, right] = split(treap, key);
    return merge(merge(left, new Treap(key)), right);
}

inline Treap * erase(Treap *treap, int key) {
    const auto[left, right] = split(treap, key);
    const auto[right1, right2] = split(right, key + 1);
    return merge(left, right2);
}

inline bool search(Treap *treap, int key) {
    if (!treap) return false;
    if (treap->key == key) return true;
    if (key <= treap->key)
        return search(treap->left, key);
    return search(treap->right, key);
}

inline void fast_io() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
}

int main() {
    fast_io();
    freopen("zeap.in", "r", stdin);
    freopen("zeap.out", "w", stdout);

    Treap *treap = nullptr;

    string str;
    int val;

    while (cin >> str) {
        if (str.empty() || !isalpha(str[0]))
            return 0;
        if (str == "I") {
            cin >> val;
            if (!search(treap, val))
                treap = insert(treap, val);
        } else if (str == "S") {
            cin >> val;
            if (search(treap, val))
                treap = erase(treap, val);
            else cout << "-1\n";
        } else if (str == "C") {
            cin >> val;
            cout << search(treap, val) << '\n';
        } else {
            if (!treap || treap->size < 2) cout << "-1\n";
            else if (str == "MIN")
                cout << treap->min_diff << '\n';
            else if (str == "MAX")
                cout << treap->max_diff << '\n';
            else exit(-1);
        }
    }

    delete treap;
    
    return 0;
}