#include <iostream>
#include <fstream>
#define max(a,b)(((a)>(b))?(a):(b))
using namespace std;
ifstream fin("zeap.in");
ofstream fout("zeap.out");
class AVL{
private:
    class Nod{
    public:
        int val,h;
        Nod* st,*dr;
    };
    Nod* rad;
    int inaltime(Nod* rad){
        if(rad==nullptr)
            return 0;
        return rad->h;
    }
    Nod* rotireSt(Nod *rad){
        Nod* newNod=rad->dr;
        rad->dr=newNod->st;
        newNod->st=rad;

        rad->h=max(inaltime(rad->st),inaltime(rad->dr))+1;
        newNod->h=max(inaltime(newNod->st),inaltime(newNod->dr))+1;
        return newNod;
    }
    Nod* rotireDr(Nod* rad){
        Nod* newNod=rad->st;
        rad->st=newNod->dr;
        newNod->dr=rad;

        rad->h=max(inaltime(rad->st),inaltime(rad->dr))+1;
        newNod->h=max(inaltime(newNod->st),inaltime(newNod->dr))+1;
        return newNod;
    }
    Nod* balansat(Nod *rad, int val){
        int dif_inalt=inaltime(rad->st)-inaltime(rad->dr);
        if(dif_inalt<-1 && val>rad->dr->val)
            return rotireSt(rad);

        if(dif_inalt>1 && val<rad->st->val)
            return rotireDr(rad);

        if(dif_inalt>1 && val>rad->st->val){
            rad->st=rotireSt(rad->st);
            return rotireDr(rad);
        }
        if(dif_inalt<-1 && val<rad->dr->val){
            rad->dr=rotireDr(rad->dr);
            return rotireSt(rad);
        }
        return rad;
    }
    Nod* insert_(Nod *rad,int val){
        if(rad==nullptr){
            Nod* newNod=new Nod();
            newNod->val=val;
            newNod->st=nullptr;
            newNod->dr=nullptr;
            newNod->h=1;
            return newNod;
        }
        if(val<rad->val)
            rad->st=insert_(rad->st,val);
        else
            rad->dr=insert_(rad->dr,val);
        rad->h=max(inaltime(rad->st),inaltime(rad->dr))+1;
        return balansat(rad,val);
    }
    void parcurgereInordine(Nod *rad){
        if(rad!=nullptr){
            parcurgereInordine(rad->st);
            cout<<rad->val<<" ";
            parcurgereInordine(rad->dr);
        }
    }
    Nod* min_nod_(Nod *rad){
        if(rad==nullptr)
            return nullptr;
        while(rad->st!=nullptr)
            rad=rad->st;
        return rad;
    }
    Nod* max_nod_(Nod* rad){
        if(rad==nullptr)
            return nullptr;
        while(rad->dr!=nullptr)
            rad=rad->dr;
        return rad;
    }
    Nod* sterge_(Nod* rad,int val){
        if(rad==nullptr) {fout<<"-1\n"; return nullptr; }
        if(val<rad->val)
            rad->st=sterge_(rad->st,val);
        else if(val>rad->val)
            rad->dr=sterge_(rad->dr,val);
        else{
            if(rad->st==nullptr && rad->dr==nullptr){
                delete rad;
                return nullptr;
            }
            if(rad->st==nullptr){
                Nod* aux=rad->dr;
                delete rad;
                return aux;
            }
            if(rad->dr==nullptr){
                Nod*aux=rad->st;
                delete rad;
                return aux;
            }
            Nod* minDr=min_nod_(rad->dr);
            rad->val=minDr->val;
            rad->dr=sterge_(rad->dr,minDr->val);
        }
        return rad;
    }
    bool cauta_(Nod* rad,int val){
        if(rad==nullptr)
            return false;
        if(val==rad->val)
            return true;
        if(val<rad->val)
            return cauta_(rad->st,val);
        return cauta_(rad->dr,val);
    }
//    void min_min_(Nod* rad,int& mn1,int& mn2){
//        if(rad==nullptr)
//            return;
//        if(rad->val<mn1){
//            mn2=mn1;
//            mn1=rad->val;
//        }
//        else if(rad->val<mn2 && rad->val!=mn1)
//            mn2=rad->val;
//
//        min_min_(rad->st,mn1,mn2);
//        min_min_(rad->dr,mn1,mn2);
//    }

public:
    AVL(){};
    void insert(int val){
        rad=insert_(rad,val);
    }
    void afis(){
        parcurgereInordine(rad);
    }
    void sterge(int val){
        rad=sterge_(rad,val);
    }
    bool cauta(int val){
        return cauta_(rad,val);
    }
    int maxmin(){
        Nod* mx=max_nod_(rad);
        Nod* mn=min_nod_(rad);
        if(mx==nullptr or mn==nullptr or mx==mn)
            return -1;

        return mx->val-mn->val;
    }
    int minmin(){
        if(rad==nullptr)
            return -1;
        int mn1=min_nod_(rad)->val;
        rad=sterge_(rad,mn1);
        if(rad==nullptr)
            return -1;
        int mn2=min_nod_(rad)->val;
        rad=insert_(rad,mn1);
        return mn2-mn1;
    }
};
int main() {
    AVL avl;
    string op;
    while(getline(fin,op)){
        if(op[0]=='I')
            avl.insert(stoi(op.substr(2)));

        if(op[0]=='S')
            avl.sterge(stoi(op.substr(2)));

        if(op[0]=='C')
            fout<<avl.cauta(stoi(op.substr(2)))<<"\n";

        if(op=="MAX")
            fout<<avl.maxmin()<<"\n";

        if(op=="MIN")
            fout<<avl.minmin()<<"\n";
    }
    return 0;
}