#include <bits/stdc++.h>

using namespace std;

ifstream fin("zeap.in");
ofstream fout("zeap.out");
struct Nod {
    int val, pri, fii;
    int ma, mi, midif;
    Nod *st, *dr;

    Nod(int val) {
        this->val = val;
        this->pri = rand() % 1000;

        this->st = this->dr = nullptr;

        this->mi = INT_MAX;
        this->ma = INT_MIN;
        this->midif = INT_MAX;
        this->fii = 1;
    }
};
char op;
Nod* rad;

static inline void CalcVal(Nod* nod) {
    nod->fii = nod->st->fii + nod->dr->fii + 1;
    nod->mi = nod->key;
    nod->ma = nod->key;
    if(nod->st != nullptr) nod->mi = nod->st->mi;
    if(nod->dr != nullptr) nod->ma = nod->dr->ma;

    nod->midif = min(nod->st->midif, nod->dr->mindif);
    if(nod->st != nullptr) nod->midif = min(nod->midif, nod->val - nod->st->ma);
    if(nod->dr != nullptr) nod->midif = min(nod->midif, nod->dr->mi - nod->val);
}

static inline Nod* Combina(Nod* a, Nod* b) {
    if(a == nullptr) return b;
    if(b == nullptr) return a;
    if(a->mi  > b->mi ) swap(a, b);
    if(a->pri > b->pri) {
        a->dr = Combina(a->dr, b);
        Recalc(a);
        return a;
    }
    else {
        b->st = Combina(a, b->st);
        CalcVal(b);
        return b;
    }
}

static inline pair<Nod*, Nod*> Imparte(Nod* nod, int val) {
    if(nod == nullptr) return {nullptr, nullptr};

    pair<Nod*, Nod*> ret;
    if(val == nod->val) {
        Nod* st1 = nod->st;
        nod->st = nullptr;
        CalcVal(nod);
        return {st1, nod};
    }
    else if(val < nod->val) {
        ret = Imparte(nod->st, val);
        nod->st = nullptr;

        CalcVal(nod);

        return {ret.first, Combina(ret.second, nod)};
    }
    else if(val > nod->val) {
        ret = Imparte(nod->dr, val);

        nod->dr = nullptr;

        CalcVal(nod);
        return {Combina(nod, ret.first), ret.second};
    }
}

static inline Nod* Add(Nod* nod, int val) {
    auto ret = Split(nod, val);
    return Combina(Combina(ret.first, new Treap(val)), ret.second);
}

static inline Nod* Del(Nod* nod, int val) {
    if(x == nullptr) return nullptr;
    auto pr  = Imparte(nod, val);
    auto doi = Imparte(pr.second, val + 1);
    return Combina(pr.first, doi.second);
}

static inline bool Cauta(Nod* nod, int val) {
    if(nod == nullptr)  return false;
    if(nod->val == val) return true;
    if(nod->val > val) return Cauta(nod->st, val);
    if(nod->val < val) return Cauta(nod->dr, val);
}

int main() {
    fin.tie(nullptr);
    fout.tie(nullptr);

    srand(time(0));

    rad = new Nod(0);
    while(fin >> op){
        if(op == "I") {
            int x;
            fin >> x;
            if(Cauta(rad, x) == 0) rad = Add(rad, x);
        }

    }

    return 0;
}