#include <bits/stdc++.h>
#define INF 1000000001

using namespace std;

struct treap {

    int inf;
    int priority;
    int minim;
    int maxim;
    int difMin;

    treap * left, * right;

    treap () {}

    treap (int _inf, int _priority, int _minim, int _maxim, int _difMin, treap * _left, treap * _right) {
        inf = _inf;
        priority = _priority;
        minim = _minim;
        maxim = _maxim;
        difMin = _difMin;
        left = _left;
        right = _right;
    }

} * r, * nil;

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

char reader[20];

int numberNodes;

void update (treap * & r) {
    r->maxim = max (r->inf, max (r->right->maxim, r->left->maxim));
    r->minim = min (r->inf, min (r->right->minim, r->left->minim));
    r->difMin = min (r->inf - r->left->maxim, min (r->right->minim - r->inf, min (r->left->difMin, r->right->difMin)));
}

void rotateLeft (treap * & r) {
    treap * t = r->right;
    r->right = t->left;
    t->left = r;
    r = t;

    update (r->left);
    update (r);
}

void rotateRight (treap * & r) {
    treap * t = r->left;
    r->left = t->right;
    t->right = r;
    r = t;

    update (r->right);
    update (r);
}

void balance (treap * & r) {
   if (r->left != NULL and r->priority < r->left->priority) {
        rotateRight (r);
    }
    else if (r->right != NULL and r->priority < r->right->priority) {
        rotateLeft (r);
    }
}

void insertZeap (treap * & r, int inf, int priority) {
    if (r == nil) {
        r = new treap (inf, priority, inf, inf, INF, nil, nil);
        ++ numberNodes;
        return;
    }


    if (inf < r->inf) {
        insertZeap (r->left, inf, priority);
    }
    else if (inf > r->inf) {
        insertZeap (r->right, inf, priority);
    }

    balance (r);
    update (r);
}

void eraseZeap (treap * & r, int inf, bool & erased) {
    if (r == nil) {
        return;
    }

    if (r->inf > inf) {
        eraseZeap (r->left, inf, erased);
    }
    else if (r->inf < inf) {
        eraseZeap (r->right, inf, erased);
    }
    else {
        if (r->left == nil and r->right == nil) {
            delete r;
            -- numberNodes;
            r = nil;
            erased = true;
        }
        else {
            if (r->left->priority > r->right->priority) {
                rotateRight (r);
            }
            else {
                rotateLeft (r);
            }
            eraseZeap (r, inf, erased);
        }
    }

    if (r != nil) {
        update (r);
    }
}

int findZeap (treap * & r, int inf) {
    if (r == nil) {
        return 0;
    }

    if (r->inf == inf) {
        return 1;
    }

    if (r->inf < inf) {
        return findZeap (r->right, inf);
    }
    else {
        return findZeap (r->left, inf);
    }
}

int maxDifZeap (treap * & r) {
    if (numberNodes < 2) {
        return -1;
    }
    else {
        return r->maxim - r->minim;
    }
}

int minDifZeap (treap * & r) {
    if (numberNodes < 2) {
        return -1;
    }
    else {
        return r->difMin;
    }
}

int main () {

    srand (time (0));

    r = nil = new treap (0, 0, INF, - INF, INF, NULL, NULL);

    while (fin >> reader) {
        if (reader[0] == 'I') {
            int x;
            fin >> x;

            insertZeap (r, x, rand ());
            continue;
        }
        if (reader[0] == 'S') {
            int x;
            fin >> x;

            bool erased = false;
            eraseZeap (r, x, erased);
            if (erased == false) {
                fout << "-1\n";
            }
            continue;
        }
        if (reader[0] == 'C') {
            int x;
            fin >> x;

            fout << findZeap (r, x) << "\n";
            continue;
        }
        if (reader[1] == 'A') {
            fout << maxDifZeap (r) << "\n";
        }
        else {
            fout << minDifZeap (r) << "\n";
        }

    }


    return 0;
}