#include <bits/stdc++.h>

using namespace std;

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

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

const int inf = 2e9;

struct treap
{
    int val, minval, maxval, mindiff;

    int priority;

    treap *left, *right;

    treap (int val, treap* left, treap* right)
    {
        this->val = val;
        this->minval = val;
        this->maxval = val;
        this->mindiff = inf;
        this->priority = randnum ();
        this->left = left;
        this->right = right;
    }
};

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

treap* root = nill;

void rotateLeft (treap*& node)
{
    treap* temp = node->left;
    node->left = temp->right;
    temp->right = node;
    node = temp;
}

void rotateRight (treap*& node)
{
    treap* temp = node->right;
    node->right = temp->left;
    temp->left = node;
    node = temp;
}

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

    node->minval = node->maxval = node->val;
    node->mindiff = inf;

    if (node->left != nill)
    {
        node->minval = node->left->minval;
        node->mindiff = min (node->mindiff, node->left->mindiff);
        node->mindiff = min (node->mindiff, node->val - node->left->maxval);
    }
    if (node->right != nill)
    {
        node->maxval = node->right->maxval;
        node->mindiff = min (node->mindiff, node->right->mindiff);
        node->mindiff = min (node->mindiff, node->right->minval - node->val);
    }
}

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

    if (node->priority < node->left->priority)
        rotateLeft (node);
    if (node->priority < node->right->priority)
        rotateRight (node);

    recheck (node->left);
    recheck (node->right);
    recheck (node);
}

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

    if (value <= node->val)
        insert (node->left, value);
    else
        insert (node->right, value);

    balance (node);
}

bool find (treap*& node, int value)
{
    if (node == nill)
        return false;
    if (node->val == value)
        return true;

    if (value < node->val)
        return find (node->left, value);

    return find (node->right, value);
}

void erase (treap*& node, int value)
{
    if (value < node->val)
        erase (node->left, value);
    else if (value > node->val)
        erase (node->right, value);
    else
    {
        if (node->left == nill && node->right == nill)
        {
            delete node;
            node = nill;
            return;
        }
        if (node->left->priority < node->right->priority)
            rotateRight (node);
        else
            rotateLeft (node);
        erase (node, value);
    }
    balance (node);
}


int main ()
{
    nill->priority = 0;

    string cer;

    while (fin >> cer)
    {
        if (cer == "I")
        {
            int x;
            fin >> x;
            if (!find (root, x))
                insert (root, x);
        }
        if (cer == "S")
        {
            int x;
            fin >> x;
            if (find (root, x))
                erase (root, x);
            else
                fout << -1 << '\n';
        }
        if (cer == "C")
        {
            int x;
            fin >> x;
            fout << find (root, x) << '\n';
        }
        if (cer == "MIN")
        {
            if (root->mindiff == inf)
                fout << -1 << '\n';
            else
                fout << root->mindiff << '\n';
        }
        if (cer == "MAX")
        {
            if (root->mindiff == inf)
                fout << -1 << '\n';
            else
                fout << root->maxval - root->minval << '\n';
        }
    }
    return 0;
}