#include <bits/stdc++.h>
using namespace std;
 
using ll = long long;

char buf[(int)4e6] = {}, cur_thing = 0;

template <typename T>
struct fake_ptr{
    int p;
    fake_ptr(){}
    fake_ptr(const int x): p(x){}
    bool operator==(const fake_ptr& rhs){
        return p == rhs.p; }
    T& operator*(){
        return *(T*)(buf+p); }
    T* operator->(){
        return (T*)(buf+p); } };
 
struct nod{
    int v, M, m, d, p;
    fake_ptr<nod> l, r; };
 
using ns = fake_ptr<nod>;

fake_ptr<nod> mk_nod(const int x, const int y, const int z, const int p, const int q, fake_ptr<nod> a, fake_ptr<nod>b){
    fake_ptr<nod> rez { cur_thing };
    cur_thing += 32;

    *rez = nod { x, y, z, p, q, a, b };
    return rez; }

fake_ptr<nod> nil = mk_nod(0, (int)-2e9, (int)2e9, (int)2e9, 0, 0, 0);

struct pns { ns l, r; };
 
ns mod_fiu(ns b, int s, ns f){
    (s ? b->r : b->l) = f;
    b->M = max({b->v, b->l->M, b->r->M});
    b->m = min({b->v, b->l->m, b->r->m});
    b->d = min({(ll)b->v - b->l->M, (ll)b->r->m - b->v, (ll)b->l->d , (ll)b->r->d });
    return b; };
 
ns join(ns l, ns r){
    return l == nil      ? r :
           r == nil      ? l : 
           (l->p > r->p) ? mod_fiu(l, 1, join(l->r, r   )) :
                           mod_fiu(r, 0, join(l   , r->l)); }
 
pns split(ns n, int m){
    pns t;
    return (n->M < m)  ? pns{n, nil} :
           (n->m >= m) ? pns{nil, n} :
           (n->v < m)  ? (t = split(n->r, m), t.l = mod_fiu(n, 1, t.l), t) :
                         (t = split(n->l, m), t.r = mod_fiu(n, 0, t.r), t); }
 
ns r = nil;
 
ifstream f("zeap.in");
ofstream g("zeap.out");
 
int main(){
    srand(time(0));
    for(string s; f >> s; ){
        if     (s == "MAX") g << (r->M <= r->m ? -1 : r->M - r->m) << '\n';
        else if(s == "MIN") g << (r->M <= r->m ? -1 : r->d       ) << '\n';
        else{
            int x;
            f >> x;
            pns t = split(r, x), u = split(t.r, x+1);
            if(s == "I")
                r = join(join(t.l,
                    (u.l == nil ? mk_nod( x, x, x, (int)2e9, rand(), nil, nil ) : u.l)),
                    u.r);
            else if(s == "S"){
                if(u.l == nil) g << -1 << '\n';
                r = join(t.l, u.r); }
            else{
                g << !(u.l == nil) << '\n';
                r = join(join(t.l, u.l), u.r); } } }
    return 0; }