#include <fstream>
#include <cstring>
#include <cstdlib>
#include <ctime>

#define INF 1000000005
#define MOD 300005

using namespace std;

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

char sir[10];
int nr;

struct TreapNode {
    TreapNode *left, *right;
    int mn , mx , key , priority , dmin;
};

TreapNode *newnode (int key , int pr) {
    TreapNode *temp = new TreapNode;

    temp -> mn = key;
    temp -> mx = key;
    temp -> dmin = INF;

    temp -> key = key;
    temp -> priority = pr;

    temp -> left = temp -> right = NULL;

    return temp;
}

void calc (TreapNode *node) {
    int dmin = INF;

    node -> mn = node -> mx = node -> key;
    node -> dmin = INF;

    if (node -> left != NULL) {
        node -> mn = min (node -> mn , node -> left -> mn);
        node -> mx = max (node -> mx , node -> left -> mx);

        dmin = min (dmin , node -> left -> dmin);
        dmin = min (dmin , node -> key - node -> left -> mx);
    }

    if (node -> right != NULL) {
        node -> mn = min (node -> mn , node -> right -> mn);
        node -> mx = max (node -> mx , node -> right -> mx);

        dmin = min (dmin , node -> right -> dmin);
        dmin = min (dmin , node -> right -> mn - node -> key);
    }

    node -> dmin = dmin;
}

TreapNode *rotate_right (TreapNode *y) {
    TreapNode *x = y -> left , *T2 = x -> right;

    x -> right = y;
    y -> left = T2;

    calc (y);
    calc (x);

    return x;
}

TreapNode *rotate_left (TreapNode *x) {
    TreapNode *y = x -> right , *T2 = y -> left;

    y -> left = x;
    x -> right = T2;

    calc (x);
    calc (y);

    return y;
}

TreapNode *search (TreapNode *node, int val) {
    if (node == NULL || node -> key == val) {
        return node;
    }

    if (node -> key > val) {
        return search (node -> left , val);
    }

    if (node -> key < val) {
        return search (node -> right , val);
    }
}

TreapNode *insert (TreapNode *node, int val) {
    if (node == NULL) {
        return newnode (val , rand () % MOD);
    }

    if (val < node -> key) {
        node -> left = insert (node -> left , val);

        if (node -> priority < node -> left -> priority) {
            node = rotate_right (node);
        }
    }

    if (val > node -> key) {
        node -> right = insert (node -> right , val);

        if (node -> priority < node -> right -> priority) {
            node = rotate_left (node);
        }
    }

    calc (node);
    return node;
}

TreapNode *dlt (TreapNode *node, int val) {
    if (node == NULL) {
        return node;
    }

    else if (val < node -> key) {
        node -> left = dlt (node -> left, val);
    }

    else if (val > node -> key) {
        node -> right = dlt (node -> right, val);
    }

    else if (node -> left == NULL && node -> right == NULL) {
        node = NULL;
    }

    else if (node -> left == NULL) {
        TreapNode *aux = node -> right;
        delete (node);
        node = aux;
    }

    else if (node -> right == NULL) {
        TreapNode *aux = node -> left;
        delete (node);
        node = aux;
    }

    else {
        if (node -> right -> priority > node -> left -> priority) {
            node = rotate_left (node);
            node -> left = dlt (node -> left , val);
        }

        else {
            node = rotate_right (node);
            node -> right = dlt (node -> right , val);
        }
    }

    if (node == NULL)
        return node;

    calc (node);
    return node;
}

int findmin (TreapNode *root) {
    if (root == NULL)
        return -1;

    return root -> mn;
}

int findmax (TreapNode *root) {
    if (root == NULL)
        return -1;

    return root -> mx;
}

int difmin (TreapNode *root) {
    if (root == NULL)
        return -1;

    if (root -> dmin == INF)
        return -1;

    return root -> dmin;
}

int main() {
    srand(time(NULL));

    TreapNode *root = NULL;

    while (f >> sir) {
        if (strcmp (sir , "I") == 0) {
            f >> nr;
            TreapNode *aux = search (root , nr);

            if (aux == NULL)
                root = insert (root, nr);
        }

        if (strcmp (sir , "S") == 0) {
            f >> nr;
            TreapNode *aux = search (root , nr);

            if (aux != NULL)
                root = dlt (root, nr);
            else
                g << -1 << '\n';
        }

        if (strcmp (sir , "C") == 0) {
            f >> nr;
            TreapNode *aux = search (root , nr);

            if (aux == NULL) {
                g << 0;
            }

            else {
                g << 1;
            }

            g << '\n';
        }

        if (strcmp (sir , "MAX") == 0) {
            int vmn = findmin (root);
            int vmx = findmax (root);

            if (vmn == vmx) {
                g << -1;
            }

            else {
                g << vmx - vmn;
            }

            g << '\n';
        }

        if (strcmp (sir , "MIN") == 0) {
            int aux = difmin (root);
            g << aux << '\n';
        }
    }
    return 0;
}