#include <iostream>
#include <string>
#include <fstream>
#include <queue>
#include <set>
#include <tuple>

using namespace std;

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

set <int> zeap; //elementele din zeap vor fi puse in ordine crescatoare
priority_queue <tuple<int,int,int>, vector<tuple<int,int,int>>, greater<tuple<int,int,int>>> hip; //<<diferenta, el1, el2>>

void inserare (const int &input)
{
    if(zeap.find(input)==zeap.end())
    {
        zeap.insert(input);  //se insereaza elementul in zeap
        auto it =zeap.find(input);
        auto it_st = it;
        auto it_dr = it;
        it_dr++;
        it_st--;
        if(it_dr != zeap.end())
        {
            hip.push( make_tuple(*it_dr - *it, *it, *it_dr) );  //se pune diferenta dintre el. si vecinul din dr. in min_heap
        }
        if(it != zeap.begin())
        {
            hip.push( make_tuple(*it - *it_st, *it_st, *it) );  // se pune diferenta dintre el. si vecinul din st. in min_heap
        }

    }
}

void stergere (const int &input)
{
    if(zeap.find(input)==zeap.end())
    {
        fout<<-1<<"\n";
    }
    else
    {
        auto it = zeap.find(input);
        auto it_st = it;
        auto it_dr = it;
        it_dr++;
        it_st--;

        if(it!=zeap.begin() && it_dr!=zeap.end())
        {
            hip.push( make_tuple( *it_dr-*it_st, *it_st, *it_dr ) ); //cand se sterge un element, se pune in min_heap dif. dintre vecinii sai
        }
        zeap.erase(it); //se sterge elementul din zeap
    }
}

void cautare (const int &input)
{
    if(zeap.find(input) == zeap.end())
    {
        fout<<0<<"\n";
    }
    else
    {
        fout<<1<<"\n";
    }
}

void diferenta_max()
{   if(zeap.size() >= 2)
    {
        auto it_start = zeap.begin();
        auto it_final = zeap.end();
        it_final--;
        int dif = *it_final - *it_start; //el. cel mai mic e la inceput, iar cel mai mare la sfarsit
        fout<<dif<<"\n";
    }
    else
    {
        fout<<-1<<"\n";
    }
}

void diferenta_min()
{
    if(zeap.size() >= 2)
    {
        while( (zeap.find(get<1>(hip.top())) == zeap.end()) || (zeap.find(get<2>(hip.top()))== zeap.end()) )
        {
            hip.pop();  //eliminam diferentele minime care au fost generate de elemente care au fost sterse
        }

        fout<<get<0>(hip.top())<<"\n"; //ce ramane in vf min_heap este minimul
    }
    else
    {
        fout<<-1<<"\n";
    }
}

int main()
{   string aux;
    int nr;
    while(fin>>aux)
    {
        if(aux == "I")
        {
            fin>>nr;
            inserare(nr);
        }
        else if(aux == "S")
        {
            fin>>nr;
            stergere(nr);
        }
        else if(aux == "C")
        {
            fin>>nr;
            cautare(nr);
        }
        else if(aux == "MAX")
        {
            diferenta_max();
        }
        else if(aux == "MIN")
        {
            diferenta_min();
        }

    }

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