#include <fstream>

using namespace std;

const string txt = "zeap";
const int inf = 2e9;

ifstream f(txt + ".in");
ofstream g(txt + ".out");

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

struct treap {
    int val, prior, maxval, minval, diffmax, diffmin;

    treap* left; treap* right;

    treap(int x, treap* lf, treap* rt)
    {
        val = maxval = minval = x;
        prior = random_num();
        diffmax = 0; diffmin = inf;
        left = lf; right = rt;
    }
};

treap* nill = new treap(0, nullptr, nullptr);
treap* root = nill;


static void rotate_right(treap*& node)
{
    treap* x = node -> left;
    treap* y = x -> right;

    node -> left = y;
    x -> right = node;
    
    node = x;
}

static void rotate_left(treap*& node)
{
    treap* x = node -> right;
    treap* y = x -> left;
    
    node -> right = y;
    x -> left = node;
    
    node = x;
}

static void recheck(treap*& node)
{
    if (node == nill) return;

    node -> maxval = node -> minval = node -> val;
    node -> diffmin = inf;
    
    if (node -> left != nill)
    {
        treap* lf = node -> left;
        node -> minval = lf -> minval;
        node -> diffmax = max(node -> diffmax, node -> maxval - lf -> minval);
        node -> diffmin = min(node -> diffmin, min(lf -> diffmin, node -> val - lf -> maxval));
    }

    if (node -> right != nill)
    {
        treap* rt = node -> right;
        node -> maxval = rt -> maxval;
        node -> diffmax = max(node -> diffmax, rt -> maxval - node -> minval);
        node -> diffmin = min(node -> diffmin, min(rt -> diffmin, rt -> minval - node -> val));
    }
}

static void balance(treap*& node)
{
    if (node == nill) return;

    if (node -> prior < node -> left -> prior)
        rotate_right(node);

    if (node -> prior < node -> right -> prior)
        rotate_left(node);
    
    recheck(node -> left);
    recheck(node -> right);
    recheck(node);
}

static void insert(treap*& node, int x)
{
    if (node == nill) {
        node = new treap(x, nill, nill);
        return;
    }

    if (node -> val >= x)
        insert(node -> left, x);

    else insert(node -> right, x);
    
    balance(node);
}

static void deletee(treap*& node, int x)
{
    if (node == nill) 
        return;

    if (node -> val > x) deletee(node -> left, x);
    else if (node -> val < x) deletee(node -> right, x);
    else
    {
        if (node -> left == nill && node -> right == nill) {
            delete node; node = nill;
            return;
        }

        if (node -> left -> prior < node -> right -> prior)
            rotate_left(node);
        else
            rotate_right(node);

        deletee(node, x);
    }

    balance(node);
}

static bool searchh(treap*& node, int x)
{
    if (node == nill) return false;
    
    if (node -> val == x) return  true;
    if (node -> val > x)
        return searchh(node -> left, x);
    
    return searchh(node -> right, x);
}

int main()
{
    string c;
    while (f >> c)
    {
        if (c != "MAX" && c != "MIN")
        {
            int x; f >> x;
            if (c[0] == 'I') {
                if(!searchh(root, x))
                    insert(root, x);
            }
            
            else if (c[0] == 'S') {
                if (searchh(root, x))
                    deletee(root, x);
                else
                    g << -1 << '\n';
            }

            else 
                g << searchh(root, x) << '\n';
        }

        else if (c == "MAX")
            g << (root -> diffmin != inf ? root -> diffmax : -1) << '\n';
        else
            g << (root -> diffmin != inf ? root -> diffmin : -1) << '\n';
    }
    return 0;
}