#include <fstream>
#include <ctime>
#include <string>
#include <cstdlib>
#define inf 2000000000
using namespace std;
ifstream fin("zeap.in");
ofstream fout("zeap.out");
int i,n,poz,j,a,ul,mini;
struct nod{
    int  info;
    int pri;
    int minim,maxim;
    int dif;
    nod *st, *dr;
    nod(int info, int pri, nod *st, nod *dr)
    {
        this->dr = dr;
        this->st = st;
        this->info = this->maxim = this-> minim = info;
        this->pri = pri;
        this->dif = inf;

    }
};
nod *T,*nil;

void upd(nod *&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 rotateleft(nod *&n)
{
    nod *x = n->st;
    n->st = x->dr;
    x->dr = n;
    n = x;
}

void rotateright(nod *&n)
{
    nod *x = n->dr;
    n->dr = x->st;
    x->st = n;
    n = x;
}

void balance(nod *&n)
{
    if(n->pri < n->st->pri)
        rotateleft(n);
    else
        if(n->pri < n->dr->pri)
            rotateright(n);
    if(n->st!=nil)
    upd(n->st);
    if(n->dr!=nil)
    upd(n->dr);
    upd(n);
}

void insert(nod *&n, int info, int prioritate)
{
    if(n == nil)
    {
        n = new nod(info,prioritate,nil,nil);
        return;
    }

    if(info < n->info)
        insert(n->st,info,prioritate);
    else
        insert(n->dr,info,prioritate);

    balance(n);
}

void del(nod *&n,int info)
{
    if(n == nil)
        return;
    if(info > n->info)
        del(n->dr, info);
    else
    if(info < n->info)
        del(n->st, info);
    else
    if(n->st == nil && n->dr == nil){
        delete n, n = nil;return;}
    else
    {
        if(n->st->pri > n->dr->pri){
            rotateleft(n);
            del(n->dr,info);}
        else
            rotateright(n),del(n->st,info);

    }
    upd(n);
}
void split(nod *&T, nod *&Ts, nod *&Td, int info)
{
    insert(T,info,inf+100);
    Ts = T->st;
    Td = T->dr;
    delete T, T=nil;
}

void join(nod *&T, nod *&Ts, nod *&Td)
{
    T = new nod(0,0,Ts,Td);
    del(T,T->info);
}
int find(nod *&n)
{
    if(n->info == a)
        return 1;
    if(n == nil)
        return 0;
    if(n->info > a)
        return find(n->st);
    else
        return find(n->dr);

}
void afisare(nod *&n)
{
    if(n == nil)
        return;
    afisare(n->st);
    fout<<n->info;
    afisare(n->dr);
}
int main()
{
    srand(time(0));

    T = nil = new nod(0,0,nil,nil);
    char c[30];;
    while(fin >> c)
    {
        if(c[0]=='I')
        {
            fin >> a;
            if(find(T) == 0)
            insert(T,a,rand() + 1),j++;

        }else
        if(c[0]=='C')
        {
            fin >> a;
            fout<<find(T)<<'\n';
        }else
        if(c[0]=='S')
        {
            fin >> a;
            if(find(T))
                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;
}