#include <bits/stdc++.h>
using namespace std;

// Overload << for vector
template <typename S>
ostream &operator<<(ostream &os, const vector<S> &vector)
{
    for (auto i : vector)
        os << i << " ";
    os << "\n";
    return os;
}

struct Op
{
    int type, x;
    Op(int type, int x) : type(type), x(x) {}
};

ostream &operator<<(ostream &os, const Op &op)
{
    os << "(" << op.type << ", " << op.x << ")";
    return os;
}

struct Nod
{
    int max = 0, min = INT_MAX, mindif = INT_MAX;
};

ostream &operator<<(ostream &os, const Nod &node)
{
    os << "(" << node.max << ", " << node.min << ", " << node.mindif << ")";
    return os;
}

vector<Nod> aint(1'000'000);
vector<int> nums;

void ins(int node, int st, int dr, int x)
{
    if (st == dr)
    {
        aint[node].max = nums[st];
        aint[node].min = nums[st];
        return;
    }
    int mid = (st + dr) / 2;
    if (nums[mid] < x)
        ins(node * 2 + 2, mid + 1, dr, x);
    else
        ins(node * 2 + 1, st, mid, x);
    aint[node].max = max(aint[node * 2 + 1].max, aint[node * 2 + 2].max);
    aint[node].min = min(aint[node * 2 + 1].min, aint[node * 2 + 2].min);
    aint[node].mindif = min(aint[node * 2 + 1].mindif, aint[node * 2 + 2].mindif);
    if (aint[node * 2 + 2].min != INT_MAX && aint[node * 2 + 1].max != 0)
        aint[node].mindif = min(aint[node].mindif, aint[node * 2 + 2].min - aint[node * 2 + 1].max);
}

void del(int node, int st, int dr, int x)
{
    if (st == dr)
    {
        aint[node].max = 0;
        aint[node].min = INT_MAX;
        return;
    }
    int mid = (st + dr) / 2;
    if (nums[mid] < x)
        del(node * 2 + 2, mid + 1, dr, x);
    else
        del(node * 2 + 1, st, mid, x);
    aint[node].max = max(aint[node * 2 + 1].max, aint[node * 2 + 2].max);
    aint[node].min = min(aint[node * 2 + 1].min, aint[node * 2 + 2].min);
    aint[node].mindif = min(aint[node * 2 + 1].mindif, aint[node * 2 + 2].mindif);
    if (aint[node * 2 + 2].min != INT_MAX && aint[node * 2 + 1].max != 0)
        aint[node].mindif = min(aint[node].mindif, aint[node * 2 + 2].min - aint[node * 2 + 1].max);
}

int main()
{
    ifstream f("zeap.in");
    ofstream g("zeap.out");
    // ios_base::sync_with_stdio(false);
    // f.tie(NULL);
    char t;
    int x;
    vector<Op> ops;
    unordered_set<int> nums_set;
    while (f >> t)
    {
        if (t == 'I')
        {
            f >> x;
            ops.push_back(Op(0, x));
            nums_set.insert(x);
        }
        else if (t == 'S')
        {
            f >> x;
            ops.push_back(Op(1, x));
        }
        else if (t == 'C')
        {
            f >> x;
            ops.push_back(Op(2, x));
        }
        else
        {
            f >> t >> t;
            if (t == 'X')
                ops.push_back(Op(3, 0));
            else
                ops.push_back(Op(4, 0));
        }
    }
    nums = vector<int>(nums_set.begin(), nums_set.end());
    int n = nums.size() - 1;
    sort(nums.begin(), nums.end());
    // aint = vector<Nod>(n * 2 + 10);
    nums_set.clear();
    for (auto &op : ops)
    {
        switch (op.type)
        {
        case 0:
        {
            // Insert
            if (nums_set.find(op.x) == nums_set.end())
            {
                ins(0, 0, n, op.x);
                nums_set.insert(op.x);
            }
            break;
        }
        case 1:
        {
            // Delete
            if (nums_set.find(op.x) == nums_set.end())
            {
                g << -1 << "\n";
            }
            else
            {
                del(0, 0, n, op.x);
                nums_set.erase(op.x);
            }
            break;
        }
        case 2:
        {
            // Search
            if (nums_set.find(op.x) == nums_set.end())
                g << 0 << "\n";
            else
                g << 1 << "\n";
            break;
        }
        case 3:
        {
            // Max-Dif
            if (nums.size() < 2)
                g << -1 << "\n";
            else
                g << aint[0].max - aint[0].min << "\n";
            break;
        }
        case 4:
        {
            // Min-Dif
            if (nums.size() < 2)
                g << -1 << "\n";
            else
                g << aint[0].mindif << "\n";
            break;
        }
        }
    }
    return 0;
}