#include <bits/stdc++.h>

#define BufferSize 25

std::ifstream InFile("zeap.in");
std::ofstream OutFile("zeap.out");

std::set <int> ElementSet;
std::multiset <int> DiffSet;

std::set <int>::iterator SwapIt1, SwapIt2;

char Buffer[BufferSize];
int GetInt() {
    char *p = Buffer + 2;
    while(!isdigit(*p)) p++;

    int x = 0;
    while(p && isdigit(*p)) {
        x = x*10 + *p - '0';
        p++;
    }   return x;
}

void Insereaza(int Value) {
    if(ElementSet.size() == 0) {
        ElementSet.insert(Value);
        return;
    }
    if(ElementSet.count(Value) == 0) {
        if(Value > *ElementSet.rbegin()) {
            DiffSet.insert(Value - *ElementSet.rbegin());
            ElementSet.insert(Value);
            return;
        }
        if(Value < *ElementSet.begin()) {
            DiffSet.insert(-Value + *ElementSet.begin());
            ElementSet.insert(Value);
            return;
        }

        SwapIt1 = ElementSet.upper_bound(Value);
        SwapIt2-- = SwapIt1;
        DiffSet.erase(DiffSet.find(*SwapIt1 - *SwapIt2));
        DiffSet.insert(Value - *SwapIt2);
        DiffSet.insert(*SwapIt1 - Value);

        ElementSet.insert(Value);
    }
}
void Sterge(int Value) {

}

bool Cauta(int Value) {
    return (ElementSet.count(Value) > 0);
}
int MaxDif() {
    return (ElementSet.size() > 1 ? *ElementSet.rbegin() - *ElementSet.begin() : -1);
}
int MinDif() {
    return (ElementSet.size() > 0 ? *DiffSet.begin() : -1);
}

void Rezolvare() {
    while(InFile.getline(Buffer, BufferSize)) {
        if(strlen(Buffer) < 3) continue;

        if (Buffer[0] == 'I') {
            Insereaza(GetInt());
        } else
        if (Buffer[0] == 'S') {
            Sterge(GetInt());
        } else
        if (Buffer[0] == 'C') {
            OutFile << Cauta(GetInt()) << '\n';
        } else
        if (Buffer[1] == 'I') {
            OutFile << MinDif() << '\n';
        } else
        if (Buffer[1] == 'A') {
            OutFile << MaxDif() << '\n';
        }
    }
}

int main()
{
    Rezolvare();

    return 0;
}