using namespace std;
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <algorithm>
#include <string>

struct nod { int v, max, min, mindif, h; nod *l, *r;};

typedef nod * tree;

tree R, nil;

inline void init()
{
    nil=new nod;
    nil->l=nil->r=0;
    nil->v=nil->max=-0x3f3f3f3f;
    nil->min=nil->mindif=0x3f3f3f3f;
    nil->h=0;
    R=nil;
}

inline void geth(tree &n)
{
    if(n == nil) return;
    n->h=max(n->l->h, n->r->h)+1;
}

inline void update(tree &n)
{
    //if(n == 0) return ;
    if(n == nil) return;
    n->mindif=0x3f3f3f3f;
    n->max=n->min=n->v;
    n->h=max(n->l->h, n->r->h)+1;

    n->min=min(n->min, n->l->min);
    n->max=max(n->max, n->l->max);
    n->mindif=min(n->mindif,n->v - n->l->max);
    n->mindif=min(n->mindif, n->l->mindif);

    n->min=min(n->min, n->r->min);
    n->max=max(n->max, n->r->max);
    n->mindif=min(n->mindif,n->r->min - n->v);
    n->mindif=min(n->mindif, n->r->mindif);
}

inline void rotleft(tree &n)
{
    tree t=n->l;
    n->l=t->r;
    t->r=n;
    update(n);update(t);
    n=t;
}

inline void rotright(tree &n)
{
    tree t=n->r;
    n->r=t->l;
    t->l=n;
    update(n);update(t);
    n=t;
}

inline void balance(tree &n)
{
    if(n == nil) return;
    update(n);
    if(n->l->h > n->r->h +1)
    {
        if(n->l->r->h > n->l->l->h) rotright(n->l);
        rotleft(n);
    }
    else
    if(n->r->h > n->l->h + 1)
    {
        if(n->r->l->h > n->r->r->h) rotleft(n->r);
        rotright(n);
    }
    update(n);
}

inline bool find(tree &n, int v)
{
    if(n == nil) return 0;
    if(v < n->v) return find(n->l,v);
    if(v > n->v) return find(n->r, v);
    if(v == n->v) return 1;
}

inline void insert(tree &n, int v)
{
    if(n == nil)
    {
        n=new nod;
        n->l=n->r=nil;
        n->v=v;
    //  n->p=rand();
        n->h=1;
        n->min=n->max=v;
        n->mindif=0x3f3f3f3f;
        return ;
    }

    if(v < n->v)
    {
        insert(n->l, v);
//      if(n->l->p > n->p) rotleft(n);
    }

    if(v > n->v)
    {
        insert(n->r, v);
        //if(n->r->p > n->p) rotright(n);
    }
    balance(n);
    update(n);
}

inline void strg(tree &n, int v)
{
    if(n == nil) return ;

    if(v < n->v) strg(n->l, v);
    if(v > n->v) strg(n->r, v);
    if(v == n->v)
    {
        if(n->l == nil && n->r == nil)
        {
            delete n;
            n=nil;
            return;
        }

        if(n->l->h > n->r->h) rotleft(n);
        else rotright(n);

        strg(n,v);
    }
//  balance(n);
}

inline void sterge(tree &n, int v)
{
    if(!find(n, v)) printf("-1\n");
    else strg(n, v);
}

inline int max_dif(tree n)
{
    if(n == nil) return -1;
    if(n->l == nil && n->r == nil) return -1;
    return n->max-n->min;
}

inline int min_dif(tree n)
{
    if(n == nil) return -1;
    if(n->l == nil && n->r == nil) return -1;
    return n->mindif;
}

int main()
{
    srand(time(0));
    init();

    freopen("zeap.in","r",stdin);
    freopen("zeap.out","w",stdout);

    while(!feof(stdin))
    {
        char ax[16];
        memset(ax, 0, sizeof(ax));
        gets(ax);
        if(ax[0] == 'M')
        {
            if(ax[1] == 'A') printf("%d\n", max_dif(R));
            else printf("%d\n", min_dif(R));
        }
        else
        {
            int pz=1;
            while(ax[pz]<'0' || ax[pz]>'9') ++pz;
            int x=0;
            while(ax[pz]>='0' && ax[pz]<='9') x=x*10+ax[pz]-'0', ++pz;

            if(ax[0] == 'I') insert(R, x);
            if(ax[0] == 'S') sterge(R, x);
            if(ax[0] == 'C') printf("%d\n", find(R, x));
        }
    }
    return 0;
}