#include <fstream>
#include <algorithm>
#include <cmath>
#define nmax 300100
#define oo (1<<30)-1
using namespace std;

struct nod{int Min,Max,D;}Arb[4*nmax];
struct query{int Type,Val,nVal;}Query[nmax];
int N,M,Nr,V[nmax];

int Search(int Nod,int Left,int Right,int K) {

    if(Left==Right)
        return (Arb[Nod].Min==Arb[Nod].Max);

    int Mid=(Left+Right)>>1;

    if(K<=Mid) return Search(2*Nod,Left,Mid,K);
    else return Search(2*Nod+1,Mid+1,Right,K);

}
void Update(int Nod,int Left,int Right,int K,int Val) {

    if(Left==Right) {
        if(Val==0) Arb[Nod].Max=-oo,Arb[Nod].Min=oo;
        else Arb[Nod].Max=Arb[Nod].Min=Val;
        return;
        }

    int Mid=(Left+Right)>>1;

    if(K<=Mid) Update(2*Nod,Left,Mid,K,Val);
    else Update(2*Nod+1,Mid+1,Right,K,Val);

    Arb[Nod].Max=max(Arb[2*Nod].Max,Arb[2*Nod+1].Max);
    Arb[Nod].Min=min(Arb[2*Nod].Min,Arb[2*Nod+1].Min);
    Arb[Nod].D=min(min(Arb[2*Nod].D,Arb[2*Nod+1].D),Arb[2*Nod+1].Min-Arb[2*Nod].Max);

}
void Build(int Nod,int Left,int Right) {

    Arb[Nod].Max=-oo;
    Arb[Nod].Min=oo;
    Arb[Nod].D=oo;

    if(Left==Right)
        return;

    int Mid=(Left+Right)>>1;

    Build(2*Nod,Left,Mid);
    Build(2*Nod+1,Mid+1,Right);

}
bool compare(int A,int B) {

    return Query[A].Val<Query[B].Val;

}
void Normalize() {

    int i;

    sort(V+1,V+Nr+1,compare);

    Query[V[1]].nVal=1;
    for(i=2;i<=Nr;i++) {

        Query[V[i]].nVal=Query[V[i-1]].nVal;
        if(Query[V[i]].Val!=Query[V[i-1]].Val)
            Query[V[i]].nVal++;

        }

    M=Query[V[Nr]].nVal;

}
void Solve() {

    Normalize();
    Build(1,1,M);
    ofstream out("zeap.out");

    for(int i=1;i<=N;i++) {

        switch(Query[i].Type) {
            case 1:Update(1,1,M,Query[i].nVal,Query[i].Val);break;
            case 2:if(!Search(1,1,M,Query[i].nVal)) out<<"-1\n";
                    else Update(1,1,M,Query[i].nVal,0);break;
            case 3:out<<Search(1,1,M,Query[i].nVal)<<'\n';break;
            case 4:if(Arb[1].Max!=Arb[1].Min) out<<(Arb[1].Max-Arb[1].Min)<<'\n';
                    else out<<"-1\n";break;
            case 5:if(Arb[1].Max!=Arb[1].Min) out<<(Arb[1].D)<<'\n';
                    else out<<"-1\n";break;
            }

        }

    out.close();

}
void Read() {

    char C;
    ifstream in("zeap.in");

    for(N=1;!in.eof();N++) {

        in>>C;
        if(in.eof()) break;

        switch(C) {
            case 'I':Query[N].Type=1,in>>Query[N].Val;V[++Nr]=N;break;
            case 'S':Query[N].Type=2,in>>Query[N].Val;V[++Nr]=N;break;
            case 'C':Query[N].Type=3,in>>Query[N].Val;V[++Nr]=N;break;
            default:in>>C>>C;
                    switch(C) {
                        case 'X':Query[N].Type=4;break;
                        case 'N':Query[N].Type=5;break;
                        }
            }

        }

    --N;
    in.close();

}
int main() {

    Read();
    Solve();

    return 0;

}