//avl.cpp
//folosind treapuri:P
using namespace std;
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <algorithm>
#include <string>

struct nod { int v, max, min, mindif, h; nod *l, *r;};

typedef nod * tree;

tree R, nil;

inline void init()
{
	nil=new nod;
	nil->l=nil->r=0;
	nil->v=nil->max=-0x3f3f3f3f;
	nil->min=nil->mindif=0x3f3f3f3f;
	nil->h=0;
	R=nil;
}

inline void geth(tree &n)
{
	if(n == nil) return;
	n->h=max(n->l->h, n->r->h)+1;
}

inline void update(tree &n)
{
	//if(n == 0) return ;
	if(n == nil) return;
	n->mindif=0x3f3f3f3f;
	n->max=n->min=n->v;
	n->h=max(n->l->h, n->r->h)+1;
	
	n->min=min(n->min, n->l->min);
	n->max=max(n->max, n->l->max);
	n->mindif=min(n->mindif,n->v - n->l->max);
	n->mindif=min(n->mindif, n->l->mindif);

	n->min=min(n->min, n->r->min);
	n->max=max(n->max, n->r->max);
	n->mindif=min(n->mindif,n->r->min - n->v);
	n->mindif=min(n->mindif, n->r->mindif);
}

inline void rotleft(tree &n)
{
	tree t=n->l;
	n->l=t->r;
	t->r=n;
	update(n);update(t);
	n=t;
}

inline void rotright(tree &n)
{
	tree t=n->r;
	n->r=t->l;
	t->l=n;
	update(n);update(t);
	n=t;
}

inline void balance(tree &n)
{
	if(n == nil) return;
	update(n);
	if(n->l->h > n->r->h +1)
	{
		if(n->l->r->h > n->l->l->h) rotright(n->l);
		rotleft(n);
	}
	else
	if(n->r->h > n->l->h + 1)
	{
		if(n->r->l->h > n->r->r->h) rotleft(n->r);
		rotright(n);
	}
	update(n);
}

inline bool find(tree &n, int v)
{
	if(n == nil) return 0;
	if(v < n->v) return find(n->l,v);
	if(v > n->v) return find(n->r, v);
	if(v == n->v) return 1;
}

inline void insert(tree &n, int v)
{
	if(n == nil)
	{
		n=new nod;
		n->l=n->r=nil;
		n->v=v;
	//	n->p=rand();
		n->h=1;
		n->min=n->max=v;
		n->mindif=0x3f3f3f3f;
		return ;
	}
	
	if(v < n->v)
	{
		insert(n->l, v);
//		if(n->l->p > n->p) rotleft(n);
	}
	
	if(v > n->v)
	{
		insert(n->r, v);
		//if(n->r->p > n->p) rotright(n);
	}
	balance(n);
	update(n);
}

inline void strg(tree &n, int v)
{
	if(n == nil) return ;
	
	if(v < n->v) strg(n->l, v);
	if(v > n->v) strg(n->r, v);
	if(v == n->v)
	{
		if(n->l == nil && n->r == nil) 
		{
			delete n;
			n=nil;
			return;
		}
		
		if(n->l->h > n->r->h) rotleft(n);
		else rotright(n);
		
		strg(n,v);
	}
	balance(n);
}

inline void sterge(tree &n, int v)
{
	if(!find(n, v)) printf("-1\n");
	else strg(n, v);
}

inline int max_dif(tree n)
{
	if(n == nil) return -1;
	if(n->l == nil && n->r == nil) return -1;
	return n->max-n->min;
}

inline int min_dif(tree n)
{
	if(n == nil) return -1;
	if(n->l == nil && n->r == nil) return -1;
	return n->mindif;
}

int main()
{
	srand(time(0));
	init();
	
	freopen("zeap.in","r",stdin);
	freopen("zeap.out","w",stdout);
	
	while(!feof(stdin))
	{
		char ax[16];
		memset(ax, 0, sizeof(ax));
		gets(ax);
		if(ax[0] == 'M')
		{
			if(ax[1] == 'A') printf("%d\n", max_dif(R));
			else printf("%d\n", min_dif(R));
		}
		else 
		{
			int pz=1;
			while(ax[pz]<'0' || ax[pz]>'9') ++pz;
			int x=0;
			while(ax[pz]>='0' && ax[pz]<='9') x=x*10+ax[pz]-'0', ++pz;
			
			if(ax[0] == 'I') insert(R, x);
			if(ax[0] == 'S') sterge(R, x);
			if(ax[0] == 'C') printf("%d\n", find(R, x));
		}
	}
	return 0;
}