#include <iostream>
#include <cstring>
#include <fstream>
using namespace std;

class Nod{
public:
    int valoare;
    int indice;
    int indice_tata;
    int indice_fiu_stanga;
    int indice_fiu_dreapta;
    Nod();
    Nod(int);
    Nod( int, int );
    Nod(int, int, int, int, int);
    ~Nod(){};
    Nod &operator = ( Nod &ob );
    Nod( const Nod &ob );
    friend istream &operator >> ( istream &in, Nod &ob );
    friend ostream &operator << ( ostream &out, Nod &ob );
    void citire();
    void afisare();
};

Nod::Nod(){
    valoare = 0;
    indice = 0;
    indice_tata = -1;
    indice_fiu_stanga = -1;
    indice_fiu_dreapta = -1;
}
Nod::Nod( int x ){
    valoare = x;
    indice = 0;
    indice_tata = -1;
    indice_fiu_stanga = -1;
    indice_fiu_dreapta = -1;
}
Nod::Nod( int x, int y ){
    valoare = x;
    indice = y;
    indice_tata = -1;
    indice_fiu_stanga = -1;
    indice_fiu_dreapta = -1;
}
Nod::Nod( int x, int y,int h, int z, int a ){
    valoare = x;
    indice = y;
    indice_tata = h;
    indice_fiu_stanga = z;
    indice_fiu_dreapta = a;
}
Nod &Nod::operator = ( Nod &ob ){
    if( this != &ob ){
        valoare = ob.valoare;
        indice = ob.indice;
        indice_tata = ob.indice_tata;
        indice_fiu_stanga = ob.indice_fiu_stanga;
        indice_fiu_dreapta = ob.indice_fiu_dreapta;
    }
    return *this;
}
Nod::Nod( const Nod &ob ){
    valoare = ob.valoare;
    indice = ob.indice;
    indice_tata = ob.indice_tata;
    indice_fiu_stanga = ob.indice_fiu_stanga;
    indice_fiu_dreapta = ob.indice_fiu_dreapta;
}
istream &operator >> ( istream &in, Nod &ob ){
    cout << "Introduceti valoarea nodului: ";
    in >> ob.valoare;
    return in;
}
ostream &operator << ( ostream &out, Nod &ob ){
    out << "Valoare: " << ob.valoare << endl;
    out << "Indice: " << ob.indice << endl;
    out << "Indice tata: " << ob.indice_tata << endl;
    out << "Indice fiu stanga: " << ob.indice_fiu_stanga << endl;
    out << "Indice fiu dreapta: " << ob.indice_fiu_dreapta << endl;
    return out;
}
void Nod::citire(){
    cout << "Introduceti valoarea nodului: ";
    cin >> valoare;
}
void Nod::afisare(){
    cout << "Valoare: " << valoare << endl;
    cout << "Indice: " << indice << endl;
    cout << "Indice tata: " << indice << endl;
    cout << "Indice fiu stanga: " << indice_fiu_stanga << endl;
    cout << "Indice fiu dreapta: " << indice_fiu_dreapta << endl;
}

class Arbore{
public:
    int marime_totala;
    int lungime;
    Nod *arbore;
    Arbore();
    Arbore(int l);
    void adauga_nod( Nod nod );
    int minim();
    int maxim();
    int cauta(Nod nod);
    int succesor( Nod nod );
    int predecesor( Nod nod );
    void stergere( Nod nod );
    friend ostream &operator << ( ostream &out, Arbore &ob );
};
Arbore::Arbore(){
    lungime = 0;
    marime_totala = 0;
    arbore = new Nod [100];
}
Arbore::Arbore( int l ){
    lungime = 0;
    marime_totala = l;
    arbore = new Nod [l];
}
void Arbore::adauga_nod(Nod nod){
    int i = 0, ok = 1;
    nod.indice = lungime;
    while( ok == 1 ){
        if( nod.valoare > arbore[i].valoare && arbore[i].indice_fiu_dreapta != -1 ){
            i = arbore[i].indice_fiu_dreapta;
        }
        else{
            if( nod.valoare < arbore[i].valoare && arbore[i].indice_fiu_stanga != -1 ){
                i = arbore[i].indice_fiu_stanga;
            }
            else ok = 0;
        }
    }
    if( nod.valoare >= arbore[i].valoare ){
        arbore[i].indice_fiu_dreapta = nod.indice;
        if( lungime != 0 ) nod.indice_tata = i;
    }
    else{
        arbore[i].indice_fiu_stanga = nod.indice;
        if( lungime != 0 ) nod.indice_tata = i;
    }
    arbore[lungime] = nod;
    lungime++;
}
int Arbore::minim(){
    int i = 0;
    while( arbore[i].indice_fiu_stanga != -1 ){
        i = arbore[i].indice_fiu_stanga;
    }
    return arbore[i].valoare;
}
int Arbore::maxim(){
    int i = 0;
    while( arbore[i].indice_fiu_dreapta != -1 ){
        i = arbore[i].indice_fiu_dreapta;
    }
    return arbore[i].valoare;
}
int Arbore::cauta(Nod nod){
    int i = 0, ok = 1, gasit = 0;
    while( ok == 1 && gasit == 0 ){
        if( nod.valoare > arbore[i].valoare ){
            if( arbore[i].indice_fiu_dreapta != -1 ){
                i = arbore[i].indice_fiu_dreapta;
            }
            else ok = 0;
        }
        else{
            if( nod.valoare < arbore[i].valoare ){
                if( arbore[i].indice_fiu_stanga != -1 ){
                    i = arbore[i].indice_fiu_stanga;
                }
                else ok = 0;
            }
            else gasit = 1;
        }
    }
    if( gasit == 1 ) return i;
    else return -1;
}
int Arbore::succesor( Nod nod ){
    int i = cauta( nod );
    if( arbore[i].indice_fiu_dreapta != -1 ){
        int ok = 1;
        i = arbore[i].indice_fiu_dreapta;
        while( ok ){
            if( arbore[i].indice_fiu_stanga != -1 ){
                i = arbore[i].indice_fiu_stanga;
            }
            else ok = 0;
        }
        return i;
    }
    else{
        int contor_stanga = 0;
        while( contor_stanga == 0 && arbore[i].indice_tata != -1 ){
            if( arbore[ arbore[i].indice_tata ].valoare >= arbore[i].valoare ){
                contor_stanga++;
                i = arbore[i].indice_tata;
            }
            else i = arbore[i].indice_tata;
        }
        if( contor_stanga != 0 ){
            return i;
        }
        else return -1;
    }
}
int Arbore::predecesor( Nod nod ){
    int i = cauta( nod );
    if( arbore[i].indice_fiu_stanga != -1 ){
        int ok = 1;
        i = arbore[i].indice_fiu_stanga;
        while( ok ){
            if( arbore[i].indice_fiu_dreapta != -1 ){
                i = arbore[i].indice_fiu_dreapta;
            }
            else ok = 0;
        }
        return i;
    }
    else{
        int contor_dreapta = 0;
        while( contor_dreapta == 0 && arbore[i].indice_tata != -1 ){
            if( arbore[ arbore[i].indice_tata ].valoare <= arbore[i].valoare ){
                contor_dreapta++;
                i = arbore[i].indice_tata;
            }
            else i = arbore[i].indice_tata;
        }
        if( contor_dreapta != 0 ){
            return i;
        }
        else return -1;
    }
}
ostream &operator << ( ostream &out, Arbore &ob ){
    out << "NUMAR TOTAL DE NODURI: " << ob.lungime << endl << endl;
    for( int i = 0; i < ob.lungime; i++ ){
        out << "Valoare: " << ob.arbore[i].valoare << endl;
        out << "Tata: " << ob.arbore[ob.arbore[i].indice_tata].valoare << endl;
        out << "Fiu stanga: " << ob.arbore[ ob.arbore[i].indice_fiu_stanga ].valoare << endl;
        out << "Fiu dreapta: " << ob.arbore[ ob.arbore[i].indice_fiu_dreapta ].valoare << endl << endl;
    }
    return out;
}
void Arbore::stergere(Nod nod){

// daca nu are fii
    int i = cauta( nod );
    if( arbore[i].indice_fiu_stanga == -1 && arbore[i].indice_fiu_dreapta == -1 ){
        if( arbore[i].indice_tata != -1 ){
            if( arbore[ arbore[i].indice_tata ].valoare < arbore[i].valoare ){
                arbore[ arbore[i].indice_tata ].indice_fiu_dreapta = -1;
            }
            else arbore[ arbore[i].indice_tata ].indice_fiu_stanga = -1;
        }
    }

// daca are doar fiul stanga
    if( arbore[i].indice_fiu_stanga != -1 && arbore[i].indice_fiu_dreapta == -1 ){
        if( arbore[i].indice_tata != -1 ){
            int w = arbore[ arbore[i].indice_tata ].valoare;
            if( w > arbore[i].valoare ){
                arbore[ arbore[i].indice_tata ].indice_fiu_stanga = arbore[i].indice_fiu_stanga;
                arbore[ arbore[i].indice_fiu_stanga ].indice_tata = arbore[i].indice_tata;
            }
            else{
                arbore[ arbore[i].indice_tata ].indice_fiu_dreapta = arbore[i].indice_fiu_stanga;
                arbore[ arbore[i].indice_fiu_stanga ].indice_tata = arbore[i].indice_tata;
            }
        }
        else{
            arbore[ arbore[i].indice_fiu_stanga ].indice_tata = -1;
        }
    }
// daca are doar fiu dreapta
    if( arbore[i].indice_fiu_stanga == -1 && arbore[i].indice_fiu_dreapta != -1 ){
        if( arbore[i].indice_tata != -1 ){
            int w = arbore[ arbore[i].indice_tata ].valoare;
            if( w > arbore[i].valoare ){
                arbore[ arbore[i].indice_tata ].indice_fiu_stanga = arbore[i].indice_fiu_dreapta;
                arbore[ arbore[i].indice_fiu_dreapta ].indice_tata = arbore[i].indice_tata;
            }
            else{
                arbore[ arbore[i].indice_tata ].indice_fiu_dreapta = arbore[i].indice_fiu_dreapta;
                arbore[ arbore[i].indice_fiu_dreapta ].indice_tata = arbore[i].indice_tata;
            }
        }
        else{
            arbore[ arbore[i].indice_fiu_dreapta ].indice_tata = -1;
        }
    }

// daca are ambii fii
    if( arbore[i].indice_fiu_stanga != -1 && arbore[i].indice_fiu_dreapta != -1 ){

        Nod w( arbore[succesor(arbore[i])] );
        stergere(w);
        arbore[i].valoare = w.valoare;
        return ;
    }

    if( arbore[i].indice_fiu_stanga == -1 || arbore[i].indice_fiu_dreapta == -1 ){
            arbore[i] = arbore[lungime-1];
    arbore[i].indice = i;
    if( arbore[i].indice_tata != -1 ){
        if( arbore[i].valoare < arbore[ arbore[i].indice_tata ].valoare ){
            arbore[ arbore[i].indice_tata ].indice_fiu_stanga = i;
        }
        else arbore[ arbore[i].indice_tata ].indice_fiu_dreapta = i;
    }
    if( arbore[i].indice_fiu_stanga != -1 ){
        arbore[ arbore[i].indice_fiu_stanga ].indice_tata = i;
    }
    else arbore[ arbore[i].indice_fiu_dreapta ].indice_tata = i;
    lungime--;
    }
}

int dif_min( Arbore x ){
    int d;
    if( x.arbore[1].valoare > x.arbore[0].valoare ){
        d = x.arbore[1].valoare - x.arbore[0].valoare;
    }
    else d = x.arbore[0].valoare - x.arbore[1].valoare;
    for( int i = 0; i < x.lungime; i++ ){
        for( int j = i+1; j < x.lungime; j++ ){
            if( x.arbore[i].valoare > x.arbore[j].valoare && x.arbore[i].valoare - x.arbore[j].valoare < d ){
                d = x.arbore[i].valoare - x.arbore[j].valoare;
            }
            else{
                if( x.arbore[i].valoare < x.arbore[j].valoare && x.arbore[j].valoare - x.arbore[i].valoare < d ){
                    d = x.arbore[i].valoare - x.arbore[j].valoare;
                }
            }
        }
    }
    return d;
}

int main(){
    Arbore z(300000);
    ifstream fin("zeap.in");
    ofstream fout("zeap.out");
    string x;
    while(fin >> x ){
        if( x == "I" ){
            int y;
            fin >> y;
            Nod w(y);
            z.adauga_nod(w);
        }
        if( x == "S" ){
            int y;
            fin >> y;
            Nod w(y);
            if( z.cauta(w) != -1 ){
                z.stergere(w);
            }
            else fout << -1 << endl;
        }
        if( x == "C" ){
            int y;
            fin >> y;
            Nod w(y);
            if( z.cauta(w) != -1 ){
                fout << 1 << endl;
            }
            else fout << 0 << endl;
        }
        if( x == "MAX" ){
            fout << z.maxim() - z.minim() << endl;
        }
        if( x == "MIN" ){
            fout << dif_min(z) << endl;
        }


    }
}