#include <iostream>
#include <fstream>
#include <algorithm>

using namespace std;

ifstream in("zeap.in");
ofstream out("zeap.out");

const int dim = 300011;
const int INF = 1000000005;

struct todo
{
    int tip;
    int cand;
    int val;
    int cate;
};

struct aint
{
    int mini,maxi,diff;
};

aint arb[4*dim];
int n,capat;
char t[5];
todo q[dim];

bool cmp_1(todo a,todo b)
{
    if (a.tip > 2)
    {
        return false;
    }
    if (b.tip > 2)
    {
        return true;
    }
    return a.val < b.val;
}

bool cmp_2(todo a,todo b)
{
    return a.cand < b.cand;
}

void build(int nod,int st,int dr)
{
    arb[nod].maxi = -INF;
    arb[nod].mini = INF;
    arb[nod].diff = INF;
    if (st == dr)
    {
        return ;
    }
    int mid = (st+dr)/2;
    build(2*nod, st,mid);
    build(2*nod+1,mid+1,dr);
}

void update(int nod,int st,int dr,int index,int val)
{
    if (st == dr)
    {
        if (val == 0)
        {
            arb[nod].maxi = -INF;
            arb[nod].mini = INF;
        }
        else
        {
            arb[nod].maxi = arb[nod].mini = val;
        }
        return ;
    }

    int mid = (st+dr)/2;
    if (index <= mid)
    {
        update(2*nod , st, mid , index,val);
    }
    else update(2*nod+1,mid+1,dr,index,val);

    arb[nod].mini = min(arb[2*nod].mini , arb[2*nod+1].mini);
    arb[nod].maxi = max(arb[2*nod].maxi , arb[2*nod+1].maxi);
    arb[nod].diff = min(min(arb[2*nod].diff , arb[2*nod+1].diff) , arb[2*nod+1].mini - arb[2*nod].maxi);
}

int query(int nod,int st,int dr,int index)
{
    if (st == dr)
    {
        return (arb[nod].maxi == arb[nod].mini);
    }
    int mid = (st+dr)/2;
    if (index <= mid)
    {
        return query(2*nod,st,mid,index);
    }
    else return query(2*nod+1,mid+1,dr,index);
}

int main()
{
    while (in >> t)
    {
        n++;
        q[n].cand = n;
        if (t[0] == 'I')
        {
            q[n].tip = 0;
            in >> q[n].val;
        }
        if (t[0] == 'S')
        {
            q[n].tip = 1;
            in >> q[n].val;
        }
        if (t[0] == 'C')
        {
            q[n].tip = 2;
            in >> q[n].val;
        }
        if (t[0] == 'M')
        {
            if (t[1] == 'A')
            {
                q[n].tip = 3;
            }
            if (t[1] == 'I')
            {
                q[n].tip = 4;
            }
        }
    }
    sort(q+1,q+n+1 , cmp_1);
    q[1].cate = 1;
    for (int i=1; i<=n && q[i].tip <= 2; i++)
    {
        if (q[i].val > q[i-1].val)
        {
            q[i].cate = q[i-1].cate + 1;
        }
        else q[i].cate = q[i-1].cate;
        capat = max(capat , q[i].cate);
    }
    sort(q+1,q+n+1,cmp_2);
    build(1,1,capat);

    for (int i=1; i<=n; i++)
    {
        if (q[i].tip == 0)
        {
            update(1,1,capat,q[i].cate , q[i].val);
        }
        if (q[i].tip == 1)
        {
            if (query(1,1,capat,q[i].cate) == 0)
            {
                out << "-1\n";
            }
            else update(1,1,capat,q[i].cate,0);
        }
        if (q[i].tip == 2)
        {
            out << query(1,1,capat,q[i].cate) << "\n";
        }
        if (q[i].tip == 3)
        {
            if (arb[1].maxi > arb[1].mini)
            {
                out << arb[1].maxi - arb[1].mini << "\n";
            }
            else out << "-1\n";
        }
        if (q[i].tip == 4)
        {
            if (arb[1].maxi > arb[1].mini)
            {
                out << arb[1].diff << "\n";
            }
            else out << "-1\n";
        }
    }
    return 0;
}