#include <bits/stdc++.h>
#define pp pair<int,int>
#define x first
#define y second
#define inf 2000000000
using namespace std;
ifstream fin("zeap.in");
ofstream fout("zeap.out");
struct Treap
{
    Treap *st, *dr;
    int maxim, minim, pri, info, dif;
    Treap(int info, int pri, Treap *st, Treap *dr)
    {
        this->dr = dr;
        this->st = st;
        this->info = info;
        this->pri = pri;
    }

}*T,*nil;

void upd(Treap *&n)
{
    n -> maxim = n -> info;
    n -> minim = n -> info;
    n -> dif = inf;
    if(n->st != nil)
    {
        n->maxim = max(n->maxim,n->st->maxim);
        n->minim = min(n->minim,n->st->minim);
        n->dif = min(n->dif,n->info - n->st->maxim);
        n->dif = min(n->dif,n->st->dif);
    }
    if(n->dr != nil)
    {
        n->maxim = max(n->maxim,n->dr->maxim);
        n->minim = min(n->minim,n->dr->minim);
        n->dif = min(n->dif,n->dr->minim - n->info);
        n->dif = min(n->dif,n->dr->dif);
    }
}

void rotate_left(Treap  *&n)
{
    Treap *aux = n->st;
    n->st = aux->dr;
    aux->dr = n;
    n = aux;
}

void rotate_right(Treap  *&n)
{
    Treap *aux = n->dr;
    n->dr = aux->st;
    aux->st = n;
    n = aux;
}

void balance(Treap  *&n)
{
    if(n->pri < n->st->pri)
        rotate_left(n);
    else
        if(n->pri < n->dr->pri)
            rotate_right(n);
    if(n->st!=nil)
    upd(n->st);
    if(n->dr!=nil)
    upd(n->dr);
    upd(n);
}

void insert(Treap *&nod, int info, int prioritate)
{
    if(nod == nil)
    {
        nod = new Treap(info, prioritate, nil, nil);
        return;
    }
    if(info > nod->info)
        insert(nod->dr, info, prioritate);
    else
        insert(nod->st, info, prioritate);
    balance(nod);
}
void del(Treap *&nod, int info)
{
    if(nod->info == info)
    {
        if(nil == nod->dr && nod->st == nil)
        {
            delete nod;
            nod = nil;
            return;
        }
        else
        {
            if(nod->st->pri > nod->dr->pri)
            {
                rotate_left(nod);
                del(nod->dr, info);
            }
            else
            {
                rotate_right(nod);
                del(nod->st, info);
            }
        }
    }
    else
    {
        if(nod->info < info)
            del(nod->dr, info);
        else
            del(nod->st, info);
    }
    balance(nod);
}
bool find(Treap *&nod, int info)
{
    if(nod == nil)
        return 0;
    if(nod->info == info)
        return 1;
    if(nod->info > info)
        return find(nod->st, info);
    else
        return find(nod->dr, info);
}
int main()
{
    srand(time(0));
    T = nil = new Treap(0, 0, nil, nil);
    char c[30];
    int a,j=0;
    while(fin >> c)
    {
        if(c[0]=='I')
        {
            fin >> a;
            if(find(T,a) == 0)
            insert(T,a,rand() + 1),j++;

        }else
        if(c[0]=='C')
        {
            fin >> a;
            fout<<find(T,a)<<'\n';
        }else
        if(c[0]=='S')
        {
            fin >> a;
            if(find(T,a))
                del(T,a),j--;
            else
                fout<<-1<<'\n';
        }else
        if(c[1]=='A')
        {
            if(j < 2)
                fout<<-1<<'\n';
           else
                fout<<T->maxim - T->minim<<'\n';
        }
        else
        {
            if(j < 2)
                fout<<-1<<'\n';
            else
            {
                fout<<T->dif<<'\n';
            }
        }
    }
    return 0;
}