#include<bits/stdc++.h>

using namespace std;

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

set<unsigned long long int> mySet;
set<long long int> differences;
map<long long int, int> differencesCounter;

long long int minDifference;

unsigned long long int GetNumberFromString(string task);

void InsertNumberInZeap(unsigned long long int number);
int DeleteNumberFromZeap(unsigned long long int number);
bool SearchNumberInZeap(unsigned long long int number);

long long int GetMaxDifferenceFromZeap();

int main()
{
    string task;
    unsigned long long int number = 0;
    int operationCode = 2;
    long long int maxDifference = -1;
    long long int minDifference = -1;
    bool isNumberInZeap = 0;

    while(getline(fin, task))
    {
        switch(task[0])
        {
            case 'I':
                number = GetNumberFromString(task);
                InsertNumberInZeap(number);
                break;

            case 'S':
                number = GetNumberFromString(task);
                operationCode = DeleteNumberFromZeap(number);

                if(operationCode == -1)
                {
                    fout << "-1" << '\n';
                }
                break;

            case 'C':
                number = GetNumberFromString(task);
                isNumberInZeap =  SearchNumberInZeap(number);

                fout << isNumberInZeap << '\n';
                break;

            case 'M':
                if(task == "MAX")
                {
                    maxDifference = GetMaxDifferenceFromZeap();

                    if(maxDifference == -1)
                    {
                        fout << "-1" << '\n';
                    }
                    else
                    {
                        fout << maxDifference << '\n';
                    }
                }
                else
                {
                    if(differences.size()==0)
                    {
                        minDifference = -1;
                    }
                    else
                    {
                        minDifference = *(differences.begin());
                    }

                    if(minDifference == -1)
                    {
                        fout << "-1" << '\n';
                    }
                    else
                    {
                        fout << minDifference << '\n';
                    }
                }
                break;

            default:
                fout << "Something went wrong with switcher" << '\n';
                break;
        }
    }
}

long long int GetMaxDifferenceFromZeap()
{
    int size = mySet.size();
    if(size<=1)
    {
        return -1;
    }

    auto first = mySet.begin();
    auto last = mySet.end();
    last--;

    long long int maxDifference = (*last)-(*first);
    return maxDifference;
}

bool SearchNumberInZeap(unsigned long long int number)
{
    auto it = mySet.find(number);

    if(it==mySet.end())
    {
        return 0;
    }
    else
    {
        return -1;
    }
}

int DeleteNumberFromZeap(unsigned long long int number)
{
    long long differenceWithRight = -1;
    auto it1 = mySet.find(number);
    auto it2 = it1;
    if(it1==mySet.end())
    {
        return -1;
    }
    else
    {
        if(it1==mySet.begin())
        {
            it1++;
            it2 = it1;
            it1--;

            differenceWithRight = (*it2)-(*it1);

            differencesCounter[differenceWithRight]--;

            if(differencesCounter[differenceWithRight]==0)
            {
                differences.erase(differenceWithRight);
            }
        }

        else
        {
            it1--;
            it2 = it1;
            it1++;

            long long int differenceWithLeft = (*it1)-(*it2);

            differencesCounter[differenceWithLeft]--;

            if(differencesCounter[differenceWithLeft]==0)
            {
                differences.erase(differenceWithLeft);
            }


            it1++;
            if(it1!=mySet.end())
            {
                it2=it1;
                it1--;

                differenceWithRight = (*it2)-(*it1);

                differencesCounter[differenceWithRight]--;

                if(differencesCounter[differenceWithRight]==0)
                {
                    differences.erase(differenceWithRight);
                }

                it1--;

                long long int differenceBetweenLeftAndRight = (*it2)-(*it1);

                if(differencesCounter.count(differenceBetweenLeftAndRight)==0)
                {
                    differencesCounter[differenceBetweenLeftAndRight] = 1;
                    differences.insert(differenceBetweenLeftAndRight);
                }
                else
                {
                    differencesCounter[differenceBetweenLeftAndRight]++;
                }

                it1++;

            }
            else
            {
                it1--;
            }
        }

        mySet.erase(it1);
        return 0;
    }
}

void InsertNumberInZeap(unsigned long long int number)
{
    long long int differenceWithRight = -1;

    mySet.insert(number);

    auto it1 = mySet.find(number);
    auto it2 = it1;

    if(mySet.size()>=2)
    {
        if(it1==mySet.begin())
        {
            it1++;
            it2 = it1;
            it1--;
            differenceWithRight = (*it2)-(*it1);

            if(differencesCounter.count(differenceWithRight)==0)
            {
                differencesCounter[differenceWithRight] = 1;
                differences.insert(differenceWithRight);
            }
            else
            {
                differencesCounter[differenceWithRight]++;
            }

        }

        else
        {
            it1--;
            it2 = it1;
            it1++;

            long long int differenceWithLeft = (*it1)-(*it2);

            if(differencesCounter.count(differenceWithLeft)==0)
            {
                differencesCounter[differenceWithLeft] = 1;
                differences.insert(differenceWithLeft);
            }
            else
            {
                differencesCounter[differenceWithLeft]++;
            }

            it1++;
            if(it1!=mySet.end())
            {
                it2 = it1;
                it1--;
                differenceWithRight = (*it2)-(*it1);

                if(differencesCounter.count(differenceWithRight)==0)
                {
                    differencesCounter[differenceWithRight] = 1;
                    differences.insert(differenceWithRight);
                }
                else
                {
                    differencesCounter[differenceWithRight]++;
                }
            }
        }
    }
}

unsigned long long int GetNumberFromString(string task)
{
    unsigned long long int answerNumber = 0;

    int stringLength = task.length();

    for(int i = 2; i<stringLength; i++)
    {
        answerNumber = answerNumber*10 + (task[i]-'0');
    }

    return answerNumber;
}