#include <iostream>
#include <fstream>
#include <set>
#include <map>
#include <string>

using namespace std;

const int INF = 1000000001;

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

class Zeap {
private:
    set<int> elemente;
    multiset<int> diferente;

public:
    void inserareElement(int x) {
        auto it = elemente.upper_bound(x);
        if (*(--it) != x) {
            int anterior, urmator;
            urmator = *(++it);
            anterior = *(--it);

            auto it2 = diferente.upper_bound(urmator - anterior);

            diferente.erase(--it2);
            elemente.insert(x);
            diferente.insert(urmator - x);
            diferente.insert(x - anterior);
        }
    }

    void stergereElement(int x) {
        auto it = elemente.upper_bound(x);

        if (*(--it) == x) {
            int anterior, urmator;
            urmator = *(++it);

            it--;
            anterior = *(--it);
            elemente.erase(++it);

            auto it2 = diferente.upper_bound(urmator - x);
            diferente.erase(--it2);

            it2 = diferente.upper_bound(x - anterior);
            diferente.erase(--it2);
            diferente.insert(urmator - anterior);
        } else {
            fout << -1 << "\n";
        }
    }

    void verificaElement(int x) {
        auto it = elemente.upper_bound(x);
        if (*(--it) == x) {
            fout << 1 << "\n";
        } else {
            fout << 0 << "\n";
        }
    }

    void maximDiferenta() {
        if (elemente.size() < 4)
            fout << -1 << "\n";
        else {
            int rez = 0;
            auto it = elemente.end();
            it--;

            rez = *(--it);
            it = elemente.begin();

            rez -= (*(++it));
            fout << rez << "\n";
        }
    }

    void minimDiferenta() {
        if (elemente.size() < 4)
            fout << -1 << "\n";
        else {
            auto it = diferente.begin();
            fout << (*it) << "\n";
        }
    }

    void setup() {
        elemente.insert(-INF);
        elemente.insert(INF);
        diferente.insert(2 * INF);
    }
};

class Menu {
private:
    Menu() = default;

    ~Menu() = default;

    static Menu *instance;

    Zeap zeap;

    string operatie;

    int x;
public:

    Menu(const Menu &) = delete;

    Menu &operator=(const Menu &) = delete;

    static Menu *getInstance() {
        if (instance == nullptr)
            instance = new Menu();
        return instance;
    }

    void run() {
        zeap.setup();
        while (fin >> operatie) {
            if (operatie == "I") {
                fin >> x;
                zeap.inserareElement(x);
            } else if (operatie == "S") {
                fin >> x;
                zeap.stergereElement(x);
            } else if (operatie == "C") {
                fin >> x;
                zeap.verificaElement(x);
            } else if (operatie == "MAX") {
                zeap.maximDiferenta();
            } else if (operatie == "MIN") {
                zeap.minimDiferenta();
            }
        }
    }
};

Menu *Menu::instance = nullptr;

int main() {
    Menu *menu = Menu::getInstance();
    menu->run();
    return 0;
}