#include <bits/stdc++.h>

using namespace std;

ifstream f("zeap.in");
ofstream g("zeap.out");

int random_number(){
    return abs((rand()<<15)+rand())+1;
}

struct TreapNode{
    int value, minvalue, maxvalue, mindif;
    int priority;
    TreapNode *left, *right;

    TreapNode(int value, int priority, TreapNode *left, TreapNode *right){
        this->value = value;
        this->priority = priority;
        this->left = left;
        this->right = right;
        this->minvalue = value;
        this->maxvalue = value;
        this->mindif = INT_MAX;
    }
};
TreapNode *NILL = new TreapNode(0, -1, nullptr, nullptr);
TreapNode *root = NILL;

bool find(TreapNode *&node, int value){
    if(node == NILL)
        return 0;
    if(value < node->value)
        return find(node->left, value);
    if(value > node->value)
        return find(node->right, value);
    return 1;
}

void rotateleft(TreapNode *&node){
    TreapNode *aux = node->left;
    node->left = aux->right;
    aux->right = node;
    node=aux;
}

void rotateright(TreapNode *&node){
    TreapNode *aux = node->right;
    node->right = aux->left;
    aux->left = node;
    node = aux;
}

void recheck(TreapNode *&node){
    if(node==NILL)
        return ;
    node->minvalue = node->maxvalue = node->value;
    node->mindif = valmax;
    if(node->left != NILL)
    {
        node->minvalue = min(node->minvalue, node->left->minvalue);
        node->maxvalue = max(node->maxvalue, node->left->maxvalue);
        node->mindif = min({node->mindif, node->left->mindif, node->value - node->left->maxvalue);
    }
    if(node->right != NILL)
    {
        node->minvalue = min(node->minvalue, node->right->minvalue);
        node->maxvalue = max(node->maxvalue, node->right->maxvalue);
        node->mindif = min(node->mindif, node->right->midif, node->right->minvalue - node->value);
    }
}

void balance(TreapNode *&node){
    if(node==NILL)
        return ;
    if(node->left->priority > node->priority)
        rotateleft(node);
    if(node->right->priority > node->priority)
        rotateright(node);
    recheck(node->left);
    recheck(node->right);
    recheck(node);
}

void insert(TreapNode *&node, int value){
    if(node == NILL)
    {
        node = new TreapNode(value, random_number(), NILL, NILL);
        return ;
    }
    if(value < node->value)
        insert(node->left, value);
    if(value > node->value)
        insert(node->right, value);
    balance(node);
}

void erase(TreapNode *&node, int value){
    if(node == NILL)
        return ;
    if(value < node->value)
        erase(node->left, value);
    if(value > node->value)
        erase(node->right, value);
    if(node->value == value)
    {
        if(node->left == NILL and node->right == NILL)
        {
            delete node;
            node = NILL;
            return;
        }
        if(node->left->priority > node->right->priority)
            rotateleft(node);
        else
            rotateright(node);
        erase(node,value);
    }
    balance(node);
}

int x, sz;
string a;

int main()
{
    srand(time(0));
    while(f>>a)
    {
        if(a=="I")
        {
            f>>x;
            if(find(root,x)==0)
                insert(root,x), sz++;
        }
        if(a=="S")
        {
            f>>x;
            if(find(root,x)==0)
                g<<-1<<'\n';
            else
                erase(root,x), sz--;
        }
        if(a=="C")
            f>>x, g<<find(root,x)<<'\n';
        if(a=="MAX")
        {
            if(sz<2)
                g<<-1<<'\n';
            else
                g<<root->maxvalue - root->minvalue<<'\n';
        }
        if(a=="MIN")
        {
            if(sz<2)
                g<<-1<<'\n';
            else
                g<<root->mindif<<'\n';
        }
    }
    return 0;
}