#include<stdio.h>
#include<algorithm>
#include<cstring>
#include<vector>
#define pb push_back
#define mp make_pair
#define v first
#define index second
#define NMax 300005
#define MOD 3000013
#define INFINIT 99999999999
using namespace std;

struct Query
{
    int type;
    int val;
    int key;
} Q[NMax],sorted[NMax];

struct Arbore
{
    int minn;
    int maxx;
    int diff;
} Arb[1<<21];
char s[20];
int ind,nr,nrs,nri;
int poz[NMax];
bool inside[NMax];
vector < pair<int,int> > norm[MOD];

int HashKey(int k)
{
    return k%MOD;
}

int normalize(int val)
{
    int k=HashKey(val);
    for(unsigned int i=0;i<norm[k].size();i++)if(norm[k][i].v==val)
        return norm[k][i].index;

    norm[k].pb(mp(val,++ind));return ind;
}

int number()
{
    int val=0;
    for(int i=2;s[i]>='0' && s[i]<='9';i++)
    val=val*10+s[i]-'0';
    return val;
}

void add(int t,int num,int k)
{
    Q[nr].type=t;Q[nr].val=num;Q[nr].key=k;
}

void read()
{
    int valc;
    while(!feof(stdin))
    {
        memset(s,'n',sizeof(s));
        fgets(s,sizeof(s),stdin);
        if(s[0]=='I')
        {
            nr++; valc=number();
            add(1,valc,normalize(valc));
            sorted[++nrs]=Q[nr];
            continue;
        }
        if(s[0]=='S')
            {nr++; valc=number(); add(2,valc,normalize(valc)); continue;}
        if(s[0]=='C')
            {nr++; valc=number(); add(3,valc,normalize(valc)); continue;}
        if(s[0]=='M' && s[1]=='A')
            {Q[++nr].type=4; continue;}
        if(s[0]=='M' && s[1]=='I')
            {Q[++nr].type=5; continue;}
        scanf("\n");
    }
}

int comp(Query x,Query y)
{
    return x.val<y.val;
}

void build(int nod,int left,int right)
{
    Arb[nod].minn=INFINIT; Arb[nod].maxx=-INFINIT; Arb[nod].diff=INFINIT;
    if(left==right)
        return;
    int mid=(left+right)/2;
    build(2*nod,left,mid);build(2*nod+1,mid+1,right);
}

void Initializare()
{
    int i; sort(sorted+1,sorted+nrs+1,comp);
    sorted[0].val=-1;

    for(i=1;i<=nrs;i++)
        if(sorted[i].val!=sorted[i-1].val)
             sorted[++nri]=sorted[i];

    for(i=1;i<=nri;i++)
        poz[sorted[i].key]=i;

    build(1,1,nri);
}

void update(int nod,int left,int right,int pozz,int value)
{
    if(left==right)
    {
        Arb[nod].minn=value;
        Arb[nod].maxx=value;
        if(!value) {
                Arb[nod].minn=INFINIT;
                Arb[nod].maxx=-INFINIT;
                   }
        return ;
    }

    int mid=(left+right)/2;
    if(pozz<=mid)
        update(2*nod,left,mid,pozz,value);
    else
        update(2*nod+1,mid+1,right,pozz,value);

    Arb[nod].minn=min(Arb[2*nod].minn,Arb[2*nod+1].minn);
    Arb[nod].maxx=max(Arb[2*nod].maxx,Arb[2*nod+1].maxx);
    Arb[nod].diff=min(Arb[2*nod].diff,Arb[2*nod+1].diff);
    Arb[nod].diff=min(Arb[nod].diff,Arb[2*nod+1].minn-Arb[2*nod].maxx);
}

void solve()
{
    for(int i=1;i<=nr;i++)
    {
        if(Q[i].type==1)
        {
            if(!inside[Q[i].key])
                update(1,1,nri,poz[Q[i].key],Q[i].val);
            inside[Q[i].key]=true;
            continue;
        }
        if(Q[i].type==2)
        {
            if(!inside[Q[i].key]) printf("-1\n");
            else
             update(1,1,nri,poz[Q[i].key],0),inside[Q[i].key]=false;
            continue;
        }
        if(Q[i].type==3)
        {
            if(inside[Q[i].key]) printf("1\n");
            else printf("0\n");
            continue;
        }
        if(Q[i].type==4)
        {
            if(Arb[1].minn>=Arb[1].maxx) printf("-1\n");
            else printf("%d\n",Arb[1].maxx-Arb[1].minn);
            continue;
        }
        if(Q[i].type==5)
        {
            if(Arb[1].minn>=Arb[1].maxx) printf("-1\n");
            else printf("%d\n",Arb[1].diff);
        }
    }
}

int main()
{
    freopen("zeap.in","r",stdin);
    freopen("zeap.out","w",stdout);
    read();
    Initializare();
    solve();
}