#include <fstream>
#include <stdlib.h>
#include <time.h>
#define INF 2000000000
using namespace std;

ifstream fin ("zeap.in");
ofstream fout ("zeap.out");
char c[20];
int nr,ok,n;
struct treap{
    int val;
    int priority;
    int mini;
    int maxi;
    int dif;
    treap *left, *right;
    treap (int val, int priority, treap *left, treap*right, int mini, int maxi, int dif){
        this->val = val;
        this->priority = priority;
        this->left = left;
        this->right = right;
        this->mini = mini;
        this->maxi = maxi;
        this->dif = dif;
    }
};
treap *rad, *nil;

void get_min_max_dif (treap *rad){
    rad->mini = min (rad->val,min(rad->left->mini, rad->right->mini));
    rad->maxi = max (rad->val,max(rad->left->maxi, rad->right->maxi));
    //rad->dif = min (rad->val - rad->left->maxi, rad->right->mini - rad->val);
    //rad->dif = min (rad->dif, min(rad->left->dif, rad->right->dif));
     rad->dif = min(rad->val - rad->left->maxi, min( rad->right->mini - rad->val, min(rad->left->dif, rad->right->dif)  )  );
}

void rotate_left (treap *&rad){
    treap *aux = rad->left;
    rad->left = aux->right;
    aux->right = rad;
    rad = aux;
    get_min_max_dif (rad->right);
    get_min_max_dif (rad);
}
void rotate_right (treap *&rad){
    treap *aux = rad->right;
    rad->right = aux->left;
    aux->left = rad;
    rad = aux;
    get_min_max_dif (rad->left);
    get_min_max_dif (rad);
}
void balance (treap *&rad){
    if (rad->left != NULL && rad->left->priority > rad->priority)
        rotate_left (rad);
    else
        if (rad->right != NULL && rad->right->priority > rad->priority)
            rotate_right(rad);
}

void add_node (treap *&rad, int key, int priority){
    if (rad == nil){
        rad = new treap (key,priority,nil,nil,key,key,INF);
        n++;
        return;
    } else {
        if (rad->val > key)
            add_node(rad->left,key,priority);
        else
            if (rad->val < key)
                add_node(rad->right,key,priority);
    }
    balance (rad);
    get_min_max_dif (rad);

}

void delete_node (treap *&rad, int key){
    if (rad != nil){
        if (rad->val > key)
            delete_node (rad->left,key);
        else{
            if (rad->val < key)
                delete_node (rad->right,key);
            else { /// inseamna ca am gasit valoarea
                if (rad->left == nil && rad->right == nil){ /// ins ca e frunza
                    delete rad;
                    rad = nil;
                    n--;
                    ok = 1;
                } else {
                    if (rad->left->priority > rad->right->priority)
                        rotate_left (rad);
                    else rotate_right (rad);
                    delete_node (rad,key);
                }

            }
        }
        if (rad != nil) /// trebuie sa updatez iar mini, maxi si dif
            get_min_max_dif (rad);
    }
}

int search_node (treap *rad, int nr){
    if (rad == nil)
        return 0;
    else {
        if (rad->val > nr)
            return search_node (rad->left,nr);
        else {
            if (rad->val < nr)
                return search_node (rad->right,nr);
            else{
                //ok = 1;
                return 1;
            }
        }
    }
}

int main (){

    srand( time(0) );
    rad = nil = new treap (0,0,NULL,NULL,INF,-INF,INF);
    while (fin>>c){
        if (c[0] == 'I'){
            fin>>nr;
            add_node (rad,nr,rand());

        } else {
            if (c[0] == 'S'){
                fin>>nr;
                ok = 0;
                delete_node (rad,nr);
                if (!ok) fout<<"-1\n";

            } else {
                if (c[0] == 'C'){
                    fin>>nr;
                    ok = 0;
                    fout<<search_node (rad,nr)<<"\n";
                    //fout<<ok<<"\n";
                } else {
                    if (c[0] == 'M' && c[1] == 'I'){ /// minim
                        if (n >= 2)
                            fout<<rad->dif<<"\n";
                        else fout<<"-1\n";
                    } else {
                        if (n >= 2)
                            fout<<rad->maxi - rad->mini<<"\n";
                        else fout<<"-1\n";
                    }}}}}
    return 0;
}