#include <iostream>
#include <vector>
#include <fstream>
#include <string>

using namespace std;

// ifstream fin("intrare.txt");
// ofstream fout("iesire.txt");

ifstream fin("zeap.in");
ofstream fout("zeap.out");
int contor_del = -1;

struct nod {
    int data;
    nod *stang, *drept;

    nod(): data(-1), stang(NULL), drept(NULL) {};
    nod(int nr): data(nr), stang(NULL), drept(NULL) {};  
};

nod* inserare(nod *radacina, int nr) {
    if (!radacina) {
        return new nod(nr);
    }
    else if (radacina->data == -1) {
        radacina->data = nr;
        return radacina;
    }

    if (nr > radacina->data) {
       radacina->drept = inserare(radacina->drept, nr);
    }

    if (nr < radacina->data) {
        radacina->stang = inserare(radacina->stang, nr);
    }

    return radacina;
}

nod* cautare(nod *radacina, int nr) {
    if (!radacina) {
        return NULL;
    }

    if (nr > radacina->data) {
        return cautare(radacina->drept, nr);
    }

    if (nr < radacina->data) {
        return cautare(radacina->stang, nr);
    }

    else return radacina;
} 

nod* val_min(nod* radacina) {
    nod *temp = radacina;
    while (temp->stang != NULL)
        temp = temp->stang;

    return temp;
}

nod* stergere(nod *radacina, int val) {
    if (!radacina) 
        return NULL;

    if (val > radacina->data) 
        radacina->drept = stergere(radacina->drept, val);

    else if (val < radacina->data) 
        radacina->stang = stergere(radacina->stang, val);

    else {
        contor_del = 1;

        if (radacina->stang == NULL && radacina->drept == NULL) 
            return NULL;

        else if (radacina->stang == NULL) {
            nod *temp = radacina->drept;
            free(radacina);
            return temp;
        }

        else if (radacina->drept == NULL) {
            nod *temp = radacina->stang;
            free(radacina);
            return temp;
        }

        nod *temp = val_min(radacina->drept);

        radacina->data = temp->data;

        radacina->drept = stergere(radacina->drept, temp->data);
    }

    return radacina;
}

void inordine(nod *radacina) {
    if (!radacina) {
        return;
    }

    inordine(radacina->stang);
    cout << radacina->data << " ";
    inordine(radacina->drept);
}

vector<int> inordine_v(nod *radacina) {
    if (!radacina) {
        vector<int> v;
        return v;
    }
    
    vector<int> v1, v2;

    v1 = inordine_v(radacina->stang);
    v1.push_back(radacina->data);
    v2 = inordine_v(radacina->drept);
    v1.insert(v1.end(), v2.begin(), v2.end());

    return v1;
}

int max_dif(nod *radacina) {
    if (!radacina || (radacina->stang == NULL && radacina->drept ==NULL))
        return -1;

    nod *mic = radacina, *mare = radacina;

    while (mic->stang != NULL) 
        mic = mic->stang;

    while (mare->drept != NULL)
        mare = mare->drept;

    return mare->data - mic->data;
}

int min_dif(nod *radacina) {
    if (!radacina || (radacina->stang == NULL && radacina->drept ==NULL))
        return -1;

    vector<int> v = inordine_v(radacina);

    int minim = v[1] - v[0];
    for (int i = 1; i < v.size() - 1; i++) {
        if (v[i+1] - v[i] < minim) {
            minim = v[i+1] - v[i];
        }
    }

    return minim;
}

nod* bst_echilib(vector<int> v, int st, int dr) {
    if (st > dr) return NULL;

    int m = (st + dr)/2;
    nod *rad = new nod(v[m]);

    rad->stang = bst_echilib(v, st, m-1);
    rad->drept = bst_echilib(v, m+1, dr);

    return rad;
}

int main() {

    nod *rad = new nod;
    int i = 0;

    while(!fin.eof()) {
        if (i % 10000 == 0 && i != 0) {
            vector<int> v = inordine_v(rad);
            rad = bst_echilib(v, 0, v.size()-1);
        }

        string a;
        fin >> a;
        int x;

        if (a == "I") {
            fin >> x;
            inserare(rad, x);
            i++;
        }
        else if (a == "S") {
            fin >> x;
            stergere(rad, x);
            if (contor_del == -1)
                fout << contor_del << '\n';
            contor_del = -1;
        }
        else if (a == "C") {
            fin >> x;
            nod *p = cautare(rad, x);
            if (!p)
                fout << "0\n";
            else          
                fout << "1\n";       
        }
        else if (a == "MAX") {
            fout << max_dif(rad) << '\n';
        }
        else if (a == "MIN") {
            fout << min_dif(rad) << '\n';
        }
    }
    return 0;
}