#include <iostream>
#include <fstream>
#include <cstring>
#include <sstream>
#include <queue>
using namespace std;
std::ofstream fout("zeap.out");

struct nod
{
    struct nod* dr, *st;
    int h, numar;
};

class ARBORE
{
private:
public:
    nod* rad;

    ARBORE() { this->rad = NULL; }

    int balance(nod* nod1)
    {
        if (!nod1)
            return 0;
        int stH = (nod1->st ? nod1->st->h : 0);
        int drH = (nod1->dr ? nod1->dr->h : 0);
        return stH - drH;
    }

    nod* ll(nod* nod1)
    {
        nod* a = nod1, *b;
        b = a->st;
        a->st = b->dr;
        b->dr = a;
        return b;
    }

    nod* rr(nod* nod1)
    {
        nod* a = nod1, *b;
        b = a->dr;
        a->dr = b->st;
        b->st = a;
        return b;
    }

    nod* lr(nod* nod1)
    {
        nod* a = nod1, *b, *c;

        b = a->st;
        c = a->st->dr;

        b->dr = c->st;
        a->st = c->dr;

        c->st = b;
        c->dr = a;

        return c;
    }

    nod* rl(nod* nod1)
    {
        nod* a = nod1, *b, *c;

        c = a->dr->st;
        b = a->dr;

        a->dr = c->st;
        b->st = c->dr;

        c->dr = b;
        c->st = a;

        return c;
    }

    nod* stang(nod* nod1)
    {
        while (nod1->st != NULL)
            nod1 = nod1->st;

        return nod1;
    }

    nod* drept(nod* nod1)
    {
        while (nod1->dr != NULL)
            nod1 = nod1->dr;
        return nod1;
    }

    nod* insert1(nod* radacina, int nr)
    {

        if (radacina == NULL)
        {
            struct nod* n = new struct nod;
            n->numar = nr;
            radacina = n;
            radacina->h = 1;
            radacina->st = radacina->dr = NULL;
            return radacina;
        }
        else
        {
            if (nr < radacina->numar)
                radacina->st = insert1(radacina->st, nr);
            else
                radacina->dr = insert1(radacina->dr, nr);
        }
        if (radacina->st && radacina->dr)
        {
            if (radacina->st->h < radacina->dr->h)
                radacina->h = radacina->dr->h + 1;
            else
                radacina->h = radacina->st->h + 1;
        }
        else if (radacina->st == NULL && radacina->dr)
        {
            radacina->h = radacina->dr->h + 1;
        }
        else if (radacina->st && radacina->dr == NULL)
        {
            radacina->h = radacina->st->h + 1;
        }
        else
            radacina->h = 0;
        if (balance(radacina) == 2 && balance(radacina->st) == 1)
        {
            radacina = ll(radacina);
        }
        else if (balance(radacina) == -2 && balance(radacina->dr) == -1)
        {
            radacina = rr(radacina);
        }
        else if (balance(radacina) == -2 && balance(radacina->dr) == 1)
        {
            radacina = rl(radacina);
        }
        else if (balance(radacina) == 2 && balance(radacina->st) == -1)
        {
            radacina = lr(radacina);
        }
        return radacina;
    }

    nod* del(nod* p, int nr)
    {
        nod* t, *q;

        if (p->st == NULL && p->dr == NULL)
        {
            if (p == this->rad)
                this->rad = NULL;
            delete p;
            return NULL;
        }

        if (p->numar < nr)
        {
            p->dr = del(p->dr, nr);
        }
        else if (p->numar > nr)
        {
            p->st = del(p->st, nr);
        }
        else
        {
            if (p->st != NULL)
            {
                q = drept(p->st);
                p->numar = q->numar;
                p->st = del(p->st, q->numar);
            }
            else
            {
                q = stang(p->dr);
                p->numar = q->numar;
                p->dr = del(p->dr, q->numar);
            }
        }
    }

    int cautare(int nr)
    {
        nod* nod1 = rad;
        while (nod1)
        {
            if (nod1->numar == nr)
                return 1;
            else if (nod1->numar < nr)
                nod1 = nod1->dr;
            else
                nod1 = nod1->st;
        }
        return 0;
    }




    int findMinDiff(nod* nod1, int diff)
{
    if (nod1 == NULL)
        return diff;
 if (nod1->dr)
    {
        diff = min(diff, stang(nod1->dr)->numar - nod1->numar);
        diff = findMinDiff(nod1->dr, diff);
    }
    if (nod1->st)
    {
        diff = min(diff, nod1->numar - drept(nod1->st)->numar);
        diff = findMinDiff(nod1->st, diff);
    }



    return diff;
}


    ~ARBORE() {}
};

ARBORE avl;
int n, i, nr, x, y;

int main()
{
    int maxDiff = -1, minDiff = 0, value, maxim = 0, minim = 1000000001;
    char op[3];

    ifstream file;
    file.open("zeap.in");
    string line;
    while (getline(file, line))
    {
        if (line[0] == 'C')
        {
            value = int(line[2]);
            fout << avl.cautare(value) << '\n';
        }
        else if (line[0] == 'I')
        {

            value = int(line[2]);
            avl.rad = avl.insert1(avl.rad, value);
            if (minim > value)
                minim = value;
            if (maxim < value)
                maxim = value;
        }
        else if (line[0] == 'S')
        {

            value = int(line[2]);
            if (avl.cautare(value) == 0)
                fout << -1 << endl;
            else
                avl.rad = avl.del(avl.rad, value);
        }
        else if (line[1] == 'I')
        {

            int minVal = avl.findMinDiff(avl.rad,100000001);
            if (minVal != 1000000001)
               fout<< minVal << endl;
               else fout<<-1<<endl;

        }
        else if (line[1] == 'A')
        {if(maxim==minim)
        fout<<-1;
        else
            fout << maxim - minim << endl;
        }
    }

    file.close();
    fout.close();
    return 0;
}