#include <bits/stdc++.h>

using namespace std;

constexpr int INF = 2e9;

struct Treap {
    Treap *l, *r;
    int key, prior;
    int mn, mx, min_diff;

    Treap(int key) 
        : l(), r(), key(key), prior(rand()),
          mn(key), mx(key), min_diff(INF) {}

    void push_up() {
        mn = mx = key;
        min_diff = INF;

        for (Treap *t : { l, r }) {
            if (!t) continue;
            mn = min(mn, t->mn);
            mx = max(mx, t->mx);
            min_diff = min(min_diff, t->min_diff);
            if (t->key < key) min_diff = min(min_diff, key - t->mx);
            else min_diff = min(min_diff, t->mn - key);
        }
    }
};

pair<Treap *, Treap *> split(Treap *t, int key) {
    if (!t) return { nullptr, nullptr };
    if (key < t->key) {
        auto[l, r] = split(t->l, key);
        t->l = r;
        t->push_up();
        return { l, t };
    } else {
        auto[l, r] = split(t->r, key);
        t->r = l;
        t->push_up();
        return { t, r };
    }
}

Treap * merge(Treap *l, Treap *r) {
    if (!l || !r) return l ?: r;
    if (l->prior > r->prior) {
        l->r = merge(l->r, r);
        l->push_up();
        return l;
    } else {
        r->l = merge(l, r->l);
        r->push_up();
        return r;
    }
}

Treap * insert(Treap *t, int key) {
    auto[l, r] = split(t, key);
    if (l && l->key == key) return merge(l, r);
    return merge(merge(l, new Treap(key)), r);
}

pair<Treap *, int> erase(Treap *t, int key) {
    auto[mid, r] = split(t, key);
    auto[l, _] = split(mid, key - 1);
    return { merge(l, r), !_ };
}

bool search(Treap *t, int key) {
    if (!t) return false;
    if (t->key == key) return true;
    return key < t->key ? search(t->l, key) : search(t->r, key);
}

int main() {
    ifstream fin("zeap.in");
    ofstream fout("zeap.out");

    Treap *t = nullptr;

    while (!fin.eof()) {
        string str;
        fin >> str;

        int x;
        if (str == "I") {
            fin >> x;
            t = insert(t, x);
        } else if (str == "S") {
            fin >> x;
            auto p = erase(t, x);
            t = p.first;
            if (p.second) fout << "-1\n";
        } else if (str == "C") {
            fin >> x;
            fout << search(t, x) << '\n';
        } else if (str == "MAX") fout << t->mx - t->mn << '\n';
        else fout << t->min_diff << '\n';
    }

    fin.close();
    fout.close();
    return 0;
}