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

using namespace std;

class Zeap {
private:
    set<int> elements;
    map<int, int> differences;

    void updateDifferences(int x) {
        auto it = elements.find(x);
        if (it != elements.end()) {
            auto next_it = std::next(it);
            auto prev_it = (it == elements.begin()) ? elements.end() : std::prev(it);

            if (next_it != elements.end()) {
                int diff = *next_it - x;
                differences[diff]++;
                if (prev_it != elements.end()) {
                    int oldDiff = *next_it - *prev_it;
                    if (--differences[oldDiff] == 0) differences.erase(oldDiff);
                }
            }

            if (prev_it != elements.end()) {
                int diff = x - *prev_it;
                differences[diff]++;
            }
        }
    }

    void removeDifferences(int x) {
        auto it = elements.find(x);
        if (it != elements.end()) {
            auto next_it = std::next(it);
            auto prev_it = (it == elements.begin()) ? elements.end() : std::prev(it);

            if (next_it != elements.end() && prev_it != elements.end()) {
                int newDiff = *next_it - *prev_it;
                differences[newDiff]++;
            }

            if (next_it != elements.end()) {
                int diff = *next_it - x;
                if (--differences[diff] == 0) differences.erase(diff);
            }

            if (prev_it != elements.end()) {
                int diff = x - *prev_it;
                if (--differences[diff] == 0) differences.erase(diff);
            }
        }
    }

public:
    void insert(int x) {
        if (elements.insert(x).second) {
            updateDifferences(x);
        }
    }

    int remove(int x) {
        if (elements.erase(x) == 0) {
            return -1;
        }
        removeDifferences(x);
        return 0;
    }

    int search(int x) {
        return elements.count(x);
    }

    int maxDiff() {
        if (elements.size() < 2) {
            return -1;
        }
        return *elements.rbegin() - *elements.begin();
    }

    int minDiff() {
        if (elements.size() < 2) {
            return -1;
        }
        return differences.begin()->first;
    }
};

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

    Zeap zeap;
    string operation;
    int x;

    while (fin >> operation) {
        if (operation == "I") {
            fin >> x;
            zeap.insert(x);
        } else if (operation == "S") {
            fin >> x;
            int result = zeap.remove(x);
            if (result == -1) {
                fout << result << "\n";
            }
        } else if (operation == "C") {
            fin >> x;
            fout << zeap.search(x) << "\n";
        } else if (operation == "MAX") {
            fout << zeap.maxDiff() << "\n";
        } else if (operation == "MIN") {
            fout << zeap.minDiff() << "\n";
        }
    }

    fin.close();
    fout.close();

    return 0;
}