#include <bits/stdc++.h>

using namespace std;

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

const int inf = 1e9;

struct treap{
    int key, priority, minn, maxx, absminn;
    treap* left;
    treap* right;
    treap(int key, int priority, int minn, int maxx, int absminn, treap* left, treap* right){
        this->key = key;
        this->priority = priority;
        this->minn = minn;
        this->maxx = maxx;
        this->absminn = absminn;
        this->left = left;
        this->right = right;
    }
}*root, *nil;


bool Search(treap* nod, int key){
    if (nod == nil){
        return false;
    }
    if (nod->key == key){
        return true;
    }
    if (nod->key > key){
        return Search(nod->left, key);
    }
    return Search(nod->right, key);
}

void Refresh(treap* &nod){
    if (nod->left == nil && nod->right == nil){
        nod->absminn = inf;
        nod->maxx = nod->key;
        nod->minn = nod->key;
    }
    else if (nod->left == nil){
        nod->maxx = nod->right->maxx;
        nod->minn = nod->key;
        nod->absminn = min(nod->right->absminn, nod->right->minn - nod->key);
    }
    else if (nod->right == nil){
        nod->minn = nod->left->minn;
        nod->maxx = nod->key;
        nod->absminn = min(nod->left->absminn, nod->key - nod->left->maxx);
    }
    else{
        nod->maxx = nod->right->maxx;
        nod->minn = nod->left->minn;
        nod->absminn = min(nod->left->absminn, nod->right->absminn);
        nod->absminn = min(nod->absminn, nod->key - nod->left->maxx);
        nod->absminn = min(nod->absminn, nod->right->minn - nod->key);
    }
}


void rotateRight(treap* &nod){
    treap* t = nod->left;
    nod->left = t->right;
    t->right = nod;
    nod = t;
    Refresh(nod->right);
    Refresh(nod);
}

void rotateLeft(treap* &nod){
    treap* t = nod->right;
    nod->right = t->left;
    t->left = nod;
    nod = t;
    Refresh(nod->left);
    Refresh(nod);
}

void balance(treap* &nod){
    if (nod->left->priority > nod->priority){
        rotateRight(nod);
    }
    else if (nod->right->priority > nod->priority){
        rotateLeft(nod);
    }
}

void Insert(treap* &nod, int key, int priority){
    if (nod == nil){
        nod = new treap(key, priority, key, key, inf, nil, nil);
        return;
    }
    else if (nod->key > key){
        Insert(nod->left, key, priority);
    }
    else{
        Insert(nod->right, key, priority);
    }
    balance(nod);
}

void Erase(treap* &nod, int key){
    if (nod->key > key){
        Erase(nod->left, key);
    }
    else if (nod->key < key){
        Erase(nod->right, key);
    }
    else{
        if (nod->left == nil && nod->right == nil){
            delete nod;
            nod = nil;
        }
        else{
            if (nod->left->priority > nod->right->priority){
                rotateLeft(nod);
            }
            else{
                rotateRight(nod);
            }
            Erase(nod, key);
        }
    }
}

int main(){
    srand(time(0));
    nil = new treap(0, 0, 0, 0, 0, nullptr, nullptr);
    root = nil;
    string op;
    int nr, contor = 0;
    while (fin >> op){
        if (op[0] == 'I'){
            fin >> nr;
            ++contor;
            Insert(root, nr, rand() + 1);
        }
        else if (op[0] == 'S'){
            fin >> nr;
            if (Search(root, nr) == false){
                fout << -1 << "\n";
                continue;
            }
            Erase(root, nr);
            --contor;
        }
        else if (op[0] == 'C'){
            fin >> nr;
            fout << Search(root, nr) << "\n";
        }
        else if (op[1] == 'A'){
            if (contor > 1){
                fout << root->maxx - root->minn << "\n";
            }
            else{
                fout << -1 << "\n";
            }
        }
        else if (op[1] == 'I'){
            if (contor > 1){
                fout << root->absminn << "\n";
            }
            else{
                fout << -1 << "\n";
            }
        }
    }
    fin.close();
    fout.close();
    return 0;
}