#include <bits/stdc++.h>
using namespace std;
 
using ll = long long;
 
struct nod{
    int v, M, m, d, p;
    nod *l, *r; } *nil = new nod{0, (int)-2e9, (int)2e9, (int)2e9, 0, 0, 0 };
 
using ns = nod*;
struct pns { ns l, r; };
 
ns mod_fiu(ns __restrict__ b, int s, ns __restrict__ 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 __restrict__ l, ns __restrict__ 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 __restrict__ 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 ? new nod { x, x, x, (int)2e9, rand(), nil, nil } : u.l)),
                    u.r);
            else if(s == "S"){
                if(u.l == nil) g << -1 << '\n';
                else delete u.l;
                r = join(t.l, u.r); }
            else{
                g << (u.l != nil) << '\n';
                r = join(join(t.l, u.l), u.r); } } }
    return 0; }