#include <bits/stdc++.h>

#define MaxN 100005
#define INF 1000000001
#define MOD 1000000007

using namespace std;

FILE*IN,*OUT;

int N,X,Y,Size=0;
char C[100];
struct Treap
{
    int priority,value,Min,Max,MinDif;
    Treap *left,*right;
    Treap(int val=0,Treap *NILL=NULL)
    {
        Max=Min=val;
        MinDif=INF;
        priority=rand();
        value=val;
        left=right=NILL;
    }
}*NIL;
void recalculate(Treap *T)
{
    if(T==NIL)return;
    T->MinDif=INF;
    T->Max=T->Min=T->value;
    if(T->right!=NIL)
    {
        T->Min=min(T->Min,T->right->Min);
        T->Max=max(T->Max,T->right->Max);
        T->MinDif=min(T->MinDif,T->value-T->right->Max);
        T->MinDif=min(T->MinDif,T->right->MinDif);
    }
    if(T->left!=NIL)
    {
        T->Min=min(T->Min,T->left->Min);
        T->Max=max(T->Max,T->left->Max);
        T->MinDif=min(T->MinDif,T->left->Min-T->value);
        T->MinDif=min(T->MinDif,T->left->MinDif);
    }
}
Treap *join(Treap *Treap1,Treap *Treap2)
{
    if(Treap1==NIL)
        return Treap2;
    if(Treap2==NIL)
        return Treap1;
    if(Treap1->priority>Treap2->priority)
    {
        Treap1->left=join(Treap1->left,Treap2);
        recalculate(Treap1);
        return Treap1;
    }
    else
    {
        Treap2->right=join(Treap1,Treap2->right);
        recalculate(Treap2);
        return Treap2;
    }
}
pair<Treap*,Treap*> split(Treap *T,int val)
{
    if(T==NIL)
        return make_pair(NIL,NIL);
    if(T->value>val)
    {
        pair<Treap*,Treap*>Temp;
        Temp=split(T->right,val);
        T->right=Temp.second;
        recalculate(T);
        return make_pair(Temp.first,T);
    }
    else
    {
        pair<Treap*,Treap*>Temp;
        Temp=split(T->left,val);
        T->left=Temp.first;
        recalculate(T);
        return make_pair(T,Temp.second);
    }
}
void Insert(Treap *&T,int val)
{
    Treap* Added=new Treap(val,NIL);
    pair<Treap*,Treap*>Temp=split(T,val);
    T=join(Temp.first,join(Added,Temp.second));
}
void Delete(Treap *&T,int key)
{
    pair<Treap*,Treap*>Temp=split(T,key-1);
    pair<Treap*,Treap*>Temp2=split(Temp.second,key);
    T=join(Temp.first,Temp2.second);
}
bool Search(Treap *T,int val)
{
    bool p=true;
    if(T==NIL)
        return 0;
    if(T->value<val)
        p&=Search(T->left,val);
    else if(T->value==val)
        return 1;
    else
        p&=Search(T->right,val);
    return p;
}
int main()
{

    IN=fopen("zeap.in","r");
    OUT=fopen("zeap.out","w");

    srand(time(NULL));
    NIL=new Treap();
    Treap*Root=NIL;
    while(fscanf(IN,"%s ",C)!=EOF)
    {
        if(C[0]=='I')
        {
            fscanf(IN,"%d ",&X);
            if(!Search(Root,X))
                Insert(Root,X),Size++;
        }
        else if(C[0]=='S')
        {

            fscanf(IN,"%d ",&X);
            if(Search(Root,X))
                Delete(Root,X),Size--;
            else fprintf(OUT,"-1\n");
        }
        else if(C[0]=='C')
        {
            fscanf(IN,"%d ",&X);
            fprintf(OUT,"%d\n",Search(Root,X));
        }
        else if(C[1]=='A')
        {
            if(Size==1)
                fprintf(OUT,"-1\n");
            else fprintf(OUT,"%d\n",Root->Max-Root->Min);
        }
        else
        {
            if(Size==1)
                fprintf(OUT,"-1\n");
            else fprintf(OUT,"%d\n",Root->MinDif);
        }
    }
    return 0;
}