#include <bits/stdc++.h>

using namespace std;

int randomNumber() {
    return abs((rand() << 15) + rand()) + 1; // rand() - returneaza doar 16 biti random
}

const int INF = 2e9;

struct TreapNode {
    int value, minValue, maxValue, minDiff; // pe subarbore / pe sub treap

    int priority;

    TreapNode *left, *right;

    TreapNode(int value, TreapNode *left, TreapNode *right) {
        this->value = value;
        this->minValue = value;
        this->maxValue = value;
        this->minDiff = INF;
        this->priority = randomNumber();
        this->left = left;
        this->right = right;
    }
};
TreapNode *NILL = new TreapNode(0, nullptr, nullptr);

TreapNode *root = NILL;

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

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

void recheck(TreapNode *& node) {
    if (node == NILL) return;

    node->minValue = node->maxValue = node->value;

    node->minDiff = INF;

    if (node->left != NILL) {
        node->minValue = node->left->minValue;
        node->minDiff = min(node->minDiff, node->left->minDiff);
        node->minDiff = min(node->minDiff, node->value - node->left->maxValue);
    }

    if (node->right != NILL) {
        node->maxValue = node->right->maxValue;
        node->minDiff = min(node->minDiff, node->right->minDiff);
        node->minDiff = min(node->minDiff, node->right->minValue - node->value);
    }
}

void balance(TreapNode *& 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(TreapNode *& node, int value) {
    if (node == NILL) {
        node = new TreapNode(value, NILL, NILL);
        return;
    }

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

    balance(node);
}

bool find(TreapNode *& node, int value) {
    if (node == NILL) {
        return false;
    }
    if (node->value == value) {
        return true;
    }

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

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

void erase(TreapNode *& node, int value) {
    if (node == NILL) {
        return;
    }

    if (value < node->value) {
        erase(node->left, value);
    } else if (value > node->value) {
        erase(node->right, value);
    } else {
        if (node->left == NILL && node->right == NILL) {
            delete node; // opusul lui new - sterge zona respectiva de memorie - OPTIONAL dar recomandat
            node = NILL;
        } else if (node->left->priority < node->right->priority) {
            rotateRight(node);
        } else {
            rotateLeft(node);
        }
        erase(node, value);
    }
    balance(node);
}


int main()
{
    freopen("zeap.in", "r", stdin);
    freopen("zeap.out", "w", stdout);
    NILL->priority = 0;

    string op;

    while (cin >> op) {
        if (op == "I") {
            int x;
            cin >> x;
            insert(root, x);
        }
        if (op == "S") {
            int x;
            cin >> x;
            if (find(root, x)) {
                erase(root, x);
            } else {
                cout << -1 << '\n';
            }
        }
        if (op == "C") {
            int x;
            cin >> x;

            cout << find(root, x) << '\n';
        }
        if (op == "MIN") {
            cout << (root->minDiff != INF ? root->minDiff : -1) << '\n';
        }
        if (op == "MAX") {
            cout << (root->minDiff != INF ? root->maxValue - root->minValue : -1) << '\n';
        }
    }
    return 0;
}