#include <bits/stdc++.h>

#pragma optimize GCC ("Ofast")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")

///#include <tryhardmode>
///#include <GODMODE::ON>

using namespace std;

ifstream fin ("zeap.in");
ofstream fout ("zeap.out");

const int INF=2e9;
mt19937 rnd(time(NULL));

class treap{
    public:
    treap *left;
    treap *right;
    int priority;
    int key;
    int maxi;
    int mini;
    int difmax;
    int difmin;

    treap(treap *left,treap *right,int key,int priority)
    {
        this->left=left;
        this->right=right;
        this->key=key;
        this->priority=priority;
        maxi=key;
        mini=key;
        difmax=0;
        difmin=INF;
    }

    void compute()
    {
        maxi=key;
        mini=key;
        difmax=0;
        difmin=INF;
        if(left!=NULL)
        {
            maxi=max(maxi,left->maxi);
            mini=min(mini,left->mini);
            difmin=min(left->difmin,key-left->maxi);
        }
        if(right!=NULL)
        {
            maxi=max(maxi,right->maxi);
            mini=min(mini,right->mini);
            difmin=min({difmin,right->mini-key,right->difmin});
        }
        difmax=maxi-mini;
    }
};

void rotate_left(treap* &node)
{
    treap* aux;
    aux=node->right;
    node->right=aux->left;
    aux->left=node;
    node->compute();
    aux->compute();
    node=aux;
}

void rotate_right(treap* &node)
{
    treap* aux;
    aux=node->left;
    node->left=aux->right;
    aux->right=node;
    node->compute();
    aux->compute();
    node=aux;
}

void balance(treap* &node)
{
    if(node->left!=NULL)
    {
        if(node->left->priority<node->priority)
            rotate_right(node);
    }
    if(node->right!=NULL)
    {
        if(node->right->priority<node->priority)
            rotate_left(node);
    }
}

void insert_value(treap* &node,int key)
{
    if(node==NULL)
        node=new treap (NULL,NULL,key,rnd());
    else
    {
        if(node->key>key)
            insert_value(node->left,key);
        else if((node->key<key))
            insert_value(node->right,key);
    }
    node->compute();
    balance(node);
}

void delete_value(treap* &node,int key)
{
    if(node->key>key)
        delete_value(node->left,key);
    else if(node->key<key)
        delete_value(node->right,key);
    else
    {
        if(node->left==NULL && node->right==NULL)
        {
            delete(node);
            node=NULL;
        }
        else if(node->right==NULL)
        {
            rotate_right(node);
            delete_value(node->right,key);
        }
        else if(node->left==NULL)
        {
            rotate_left(node);
            delete_value(node->left,key);
        }
        else
        {
            if(node->left->priority<node->right->priority)
            {
                rotate_right(node);
                delete_value(node->right,key);
            }
            else
            {
                rotate_left(node);
                delete_value(node->left,key);
            }
        }
    }
    if(node!=NULL)
        node->compute();

}

bool search_value(treap* node,int key)
{
    if(node==NULL)
        return 0;
    if(node->key==key)
        return 1;
    else
    {
        if(node->key>key)
            return search_value(node->left,key);
        else if((node->key<key))
            return search_value(node->right,key);
    }
}

int main()
{
    ios_base::sync_with_stdio(false);
    fin.tie(NULL);
    fout.tie(NULL);

    int x,kon=0;
    treap* node=NULL;
    string s;
    while(fin>>s)
    {
        if(s.size()==1)
        {
            fin>>x;
            if(s[0]=='I')
            {
                insert_value(node,x);
                kon++;
            }
            else if(s[0]=='S')
            {
                if(!search_value(node,x))
                    fout<<-1<<"\n";
                else
                {
                    delete_value(node,x);
                    kon--;
                }
            }
            else
                fout<<search_value(node,x)<<"\n";
        }
        else
        {
            if(s=="MIN")
            {
                if(kon<=1)
                    fout<<-1<<"\n";
                else
                    fout<<node->difmin<<"\n";
            }
            else if(s=="MAX")
            {
                if(kon<=1)
                    fout<<-1<<"\n";
                else
                    fout<<node->difmax<<"\n";
            }
        }
    }
    fin.close();
    fout.close();
    return 0;
}