#include <bits/stdc++.h>

using namespace std;

ifstream f("zeap.in");
ofstream g("zeap.out");


struct pereche //retinem perechile vecine din zeap
{
    int st,dr;
    pereche() {}
    pereche(int x, int y)
    {
        st = x;
        dr = y;
    }
};


int insereaza(set<int> &Z,int x)//inseram elementul daca nu exista sau returnam -1 daca exista
{
    if(!Z.count(x))
    {
        Z.insert(x);
        return 1;
    }
    else return -1;

}
class cmp //cu clasa aceasta comparam
{
public:
    bool operator () (const pereche& a, const pereche& b)
    {
        return abs(a.st - a.dr) > abs(b.st - b.dr);
    }
};

int sterge(set<int> &Z,int x)// sterge elementul sau returneaza -1 daca elementul nu exista
{
    if(Z.count(x))
    {
        set<int>::iterator it1 = Z.find(x); //retinem pozitia elementului
        set<int>::iterator it2 = it1;
        it2++;//retinem pozitia vecinului din dreapta
        if(it1 != Z.begin() && it2 != Z.end())
        {
            --it1; //retinem pozitia vecinului din stanga
            PQ.push(pereche(*it1, *it2));//formez perechea
        }
        Z.erase(x); //stergem elementul
        return 1;
    }else
    return -1;
}


//verifica daca exista elementul
int cauta(set<int> &Z,int x)
{
    if(Z.count(x))
        return 1;
    else
        return 0;
}


int max_dif(set<int> &Z)//returneaza diferenta maxima dintre doua elemente
{
    //tinem cont de faptul ca set ul este implementat ca un arbore binar de cautare, deci
    //primul element e cel mai mic, iar ultimul cel mai mare

    if(Z.size() < 2) //returnam -1 daca exista doar un element
        return -1;
    else
    {
        set<int>::iterator prim = Z.begin(), ultim = Z.end() - 1;
        return *ultim - *prim;
    }
}


int min_dif(set<int> &Z)//returneaza diferenta minima dintre doua elemente
{
    if(Z.size() < 2) //returnam -1 daca exista doar un element
        return -1;
    else
    {

        while(!Z.count(PQ.top().dr) || !Z.count(PQ.top().st) )
        {
            PQ.pop();
        }
        return abs(PQ.top().st - PQ.top().dr);
    }
}
priority_queue<pereche, vector<pereche>, cmp> PQ;

int main()
{
    set<int> Z;

    string s;
    int x;
    while(fin >> s)
    {
        if(s == "I")
        {
            fin >> x;
            int rez = insereaza(Z, x);
            if(rez == 1) //daca am reusit sa inseram
            {
                set<int>::iterator it = Z.find(x);

                if(it != Z.begin())
                {
                    set<int>::iterator it2 = it; //vecin stang
                    --it2;
                    PQ.push(pereche(*it2, x));
                }

                set<int>::iterator it3 = it; //vecinul drept
                ++it3;
                if(it3 != Z.end())
                {
                    PQ.push(pereche(x, *it3));
                }
            }
        }
        else if(s == "C")
        {
            f >> x;
            g << cauta(Z, x) << "\n";
        }
        else if(s == "S")
        {
            f >> x;
            int rez = sterge(Z, x) ;
            if(rez == -1)
                g << "-1\n";
        }
        else if(s == "MIN")
        {
            g << min_dif(Z) << "\n";
        }
        else
        {
            g << max_dif(Z) << "\n";
        }
    }
    return 0;
}