#include <bits/stdc++.h>
#define MAX 131072
#define MOD 1000000007

using namespace std;

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

int xVal, ans, N;
int valMax, valMinAbs, valMin;
char sTip[5];

struct Treap{
    int priority, val, absMin;
    int vMin, vMax;
    Treap *left, *right;
    Treap(int p, int x){
        left = right = NULL;
        priority = p;
        val = vMin = vMax = x;
        absMin = 2e9;
    }
};

Treap *root = NULL;
Treap *tForDelete;

inline int good_rand() {
    return (rand() << 14) | rand();
}

inline void tRefresh(Treap *node){
    if(node->right == NULL && node->left == NULL){
        node->vMax = node->val;
        node->vMin = node->val;
        node->absMin = 2e9;
        return;
    }
    if(node->right == NULL){
        node->vMax = node->val;
        node->vMin = node->left->vMin;
        node->absMin = min(node->left->absMin, node->val - node->left->vMax);
    } else if(node->left == NULL){
        node->vMax = node->right->vMax;
        node->vMin = node->val;
        node->absMin = min(node->right->absMin, node->right->vMin - node->val);
    } else {
        node->vMax = node->right->vMax;
        node->vMin = node->left->vMin;
        node->absMin = min(node->left->absMin, node->right->absMin);
        node->absMin = min(node->absMin, min(node->val - node->left->vMax, node->right->vMin - node->val));
    }
}

inline Treap *tRotLeft(Treap *node){
    Treap *aux = node->right;
    node->right = aux->left;
    aux->left = node;
    tRefresh(node);
    tRefresh(aux);
    return aux;
}

inline Treap *tRotRight(Treap *node){
    Treap *aux = node->left;
    node->left = aux->right;
    aux->right = node;
    tRefresh(node);
    tRefresh(aux);
    return aux;
}

inline Treap *tBalance(Treap *node){
    tRefresh(node);
    if(node->left != NULL && node->left->priority > node->priority)
        return tRotRight(node);
    if(node->right != NULL && node->right->priority > node->priority)
        return tRotLeft(node);
    return node;
}

Treap *tInsert(Treap *node){
    if(node == NULL){
        N++;
        node = new Treap(good_rand(), xVal);
        return node;
    } else if(node->val == xVal)
        return node;
    if(node->val >= xVal)
        node->left = tInsert(node->left);
    else node->right = tInsert(node->right);
    return tBalance(node);
}

inline bool tSearch(Treap *node){
    if(node == NULL)
        return false;
    else if(node->val == xVal){
        tForDelete = node;
        return true;
    }
    if(node->val > xVal)
        return tSearch(node->left);
    else return tSearch(node->right);
}

Treap *tDelete(Treap *node, bool flag){
    if(node == NULL)
        return node;
    if(node->val == xVal || flag){
        if(node->left == NULL && node->right == NULL){
            ans = 0;
            delete node;
            return NULL;
        }
        Treap *aux;
        if(node->left == NULL){
            aux = tRotLeft(node);
            aux->left = tDelete(aux->left, 1);
        } else if(node->right == NULL){
            aux = tRotRight(node);
            aux->right = tDelete(aux->right, 1);
        } else if(node->left->priority > node->right->priority){
            aux = tRotLeft(node);
            aux->left = tDelete(aux->left, 1);
        } else {
            aux = tRotRight(node);
            aux->right = tDelete(aux->right, 1);
        }
        return tBalance(aux);
    } else {
        if(node->val > xVal && node->left != NULL)
            node->left = tDelete(node->left, 0);
        else if(node->right != NULL)
            node->right = tDelete(node->right, 0);
        return tBalance(node);
    }
}

int main(){

    srand(time(NULL));
    while(true){
        fin >> sTip;
        if(fin.eof()) break;
        if(sTip[0] != 'M'){
            fin >> xVal;
            if(sTip[0] == 'I')
                root = tInsert(root);
            else if(sTip[0] == 'S'){
                ans = -1;
                root = tDelete(root, 0);
                if(ans == -1)
                    fout << ans << '\n';
            } else if(sTip[0] == 'C')
                fout << tSearch(root) << '\n';
        } else {
            if(N < 2){
                fout << -1 << '\n';
                continue;
            }
            if(sTip[1] == 'A')
                fout << root->vMax - root->vMin << '\n';
            else fout << root->absMin << '\n';
        }
    }

    return 0;
}