#include <bits/stdc++.h>

using namespace std;

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

struct treap_node{

    int key,priority;
    treap_node *ls,*rs;
    int maxx,minn,dif_min;

    treap_node(int K, int P, treap_node *L, treap_node *R, int M, int m, int D){

        key=K;
        priority=P;
        ls=L;
        rs=R;
        maxx=M;
        minn=m;
        dif_min=D;
    }
};

treap_node *root,*nil;

bool treap_search(treap_node *node, const int &K){

    if(node==nil)
        return false;

    if(node->key==K)
        return true;

    return K<node->key ? treap_search(node->ls,K) : treap_search(node->rs,K);
}

void rot_left(treap_node *&node){

    treap_node *temp=node->ls;
    node->ls=temp->rs;
    temp->rs=node;
    node=temp;
}

void rot_right(treap_node *&node){

    treap_node *temp=node->rs;
    node->rs=temp->ls;
    temp->ls=node;
    node=temp;
}

void balance(treap_node *&node){

    if(node->ls->priority>node->priority)
        rot_left(node);
    else
        if(node->rs->priority>node->priority)
            rot_right(node);
}

void treap_update(treap_node *node){

    if(node!=nil){

        node->minn=node->maxx=node->key;
        node->dif_min=INT_MAX;

        if(node->ls!=nil){

            node->minn=min(node->minn,node->ls->minn);
            node->dif_min=min(node->dif_min,min(node->ls->dif_min,node->key-node->ls->maxx));
        }
        if(node->rs!=nil){

            node->maxx=max(node->maxx,node->rs->maxx);
            node->dif_min=min(node->dif_min,min(node->rs->dif_min,node->rs->minn-node->key));
        }
    }
}

void treap_insert(treap_node *&node, const int &K, const int &P){

    if(node==nil){

        node=new treap_node(K,P,nil,nil,K,K,INT_MAX);
        treap_update(node);
        return;
    }

    K<node->key ? treap_insert(node->ls,K,P) : treap_insert(node->rs,K,P);

    balance(node);
    treap_update(node);
}

void treap_erase(treap_node *&node, const int &K){

    if(node==nil) return;

    if(K<node->key)
        treap_erase(node->ls,K);
    else{

        if(K>node->key)
            treap_erase(node->rs,K);
        else{

            if(node->ls==nil and node->rs==nil){

                delete node;
                node=nil;
                treap_update(node);
            }
            else{

                node->ls->priority>node->rs->priority ? rot_left(node) : rot_right(node);
                treap_update(node);
                treap_erase(node,K);
            }
        }
    }
    treap_update(node);
}

int main(){

    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
    uniform_int_distribution <int> _random(1,INT_MAX);

    root=nil=new treap_node(0,0,nullptr,nullptr,0,0,0);

    int x,elem_no=0;
    string s;

    while(f>>s){


            if(s=="I"){

                f>>x;
                if(!treap_search(root,x)){

                    int P=_random(rng);
                    treap_insert(root,x,P);
                    ++elem_no;
                }
            }
            if(s=="S"){

                f>>x;
                if(treap_search(root,x)){

                    treap_erase(root,x);
                    --elem_no;
                }
                else g<<"-1\n";
            }
            if(s=="C"){

                f>>x;
                g<<treap_search(root,x)<<'\n';
            }
           if(s=="MAX"){

                if(elem_no>1)
                    g<<root->maxx-root->minn<<'\n';
                else g<<"-1\n";
            }
            if(s=="MIN"){

                if(elem_no>1)
                    g<<root->dif_min<<'\n';
                else g<<"-1\n";
            }
        }

    return 0;
}