#include <bits/stdc++.h>
#define INF 1000000001
using namespace std;
ifstream fin("zeap.in");
ofstream fout("zeap.out");
 
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
 
struct treap
{
    int val, pri;
    int maxi,mini,mind;
    treap *l=nullptr, *r=nullptr;
 
    treap(int val)
    {
        this->val=val;
        maxi=val;
        mini=val;
        mind=INF;
 
        pri=rng();
    }
};
 
treap * T=nullptr;
 
treap * l, *r, *mij;
void _update(treap * &root)
{
    if(!root)
        return ;
    root->maxi=root->mini=root->val;
    root->mind=INF;
    if((root->l))
    {
        root->mini=min(root->mini, (root->l)->mini);
        root->mind=min(root->mind, (root->l)->mind);
        root->mind=min(root->mind, root->val- (root->l)->maxi);
    }
    if((root->r))
    {
        root->maxi=max(root->maxi, (root->r)->maxi);
        root->mind=min(root->mind, (root->r)->mind);
        root->mind=min(root->mind, (root->r)->mini- root->val);
    }
}
 
void _split(treap * root, int val, treap * &left, treap * &right)
{
    if(!root){
        left=right=nullptr;
        return ;
    }
    else if (val<root->val)
    {
        right=root;
        _split(root->l, val, left, root->l);
    }
    else if (val>=root->val)
    {
        left=root;
        _split(root->r, val, root->r, right);
    }
    _update(root);
}
 
void _merge(treap * &root, treap * left, treap * right)
{
    if(!right){
        root=left;
        return ;
    }
    else if (!left){
        root=right;
        return ;
    }
    else if (left->pri > right->pri)
    {
        root=left;
        _merge(root->r, root->r, right);
    }
    else if (right->pri >= left->pri)
    {
        root=right;
        _merge(root->l, left, root->l);
    }
    _update(root);
}
 
 
void _insert(treap * &root,int val)
{
    l=nullptr; r=nullptr; mij=nullptr;
 
    _split(root,val-1, l, r);
    _split(r, val, mij, r);
    if(!mij)
        mij=new treap(val);
 
    _merge(l,l,mij);
    _merge(root,l,r);
}
void _erase(treap * &root, int val, int &ans)
{
    l=nullptr; r=nullptr; mij=nullptr;
 
    _split(root, val-1, l, r);
    _split(r, val, mij, r);
 
    if(!mij)
    {
        ans=-1;
        _merge(root,l,r);
        return ;
    }
    else{
        delete mij;
        ans=0;
    }
 
    _merge(root,l,r);
}
 
bool _search(treap * root, int val)
{
    l=nullptr; r=nullptr; mij=nullptr;
 
    _split(root, val-1, l, r);
    _split(r, val, mij, r);
    if(mij){
        _merge(l,l,mij);
        _merge(root,l,r);
        return 1;
    }
 
    _merge(l,l,mij);
    _merge(root,l,r);
    return 0;
}
 
char op, ch;
int main()
{
    int x, ex;
    ios_base::sync_with_stdio(false);
    fin.tie();
 
    while(fin>>op){
        if(op=='I'){
            fin>>x;
            _insert(T,x);
 
        }
        else if (op=='S')
        {
            fin>>x;
            ex=-1;
            _erase(T,x,ex);
            if(ex)
                fout<<-1<<'\n';
        }
        else if (op=='M')
        {
            fin>>ch;
            if(ch=='A')
            {
                if(!T || T->mini==T->maxi)
                    x=-1;
                else x=T->maxi- T->mini;
            }
            else
            {
                if(!T || T->mind==INF)
                    x=-1;
                else x=T->mind;
            }
            fin>>ch;
            fout<<x<<'\n';
        }
        else if (op=='C')
        {
            fin>>x;
            fout<<_search(T,x)<<'\n';
        }
        else break;
        fin.get();
    }
    fin.close();
    fout.close();
    return 0;
}