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

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;
	if(n->l != nil) 
	{
		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);
	}
	

	if(n->r != nil)
	{
		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)
{
	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);
	}
}

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

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

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);
	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 tree erase(tree &n,int v)
{
	if(n == nil) return n;
	
	//printf("%d %d__\n", n->v, v);
	if(v < n->v) n->l=erase(n->l, v);
	if(v > n->v) n->r=erase(n->r, v);
	if(v == n->v)
	{
		tree t;
		if(n->l == nil || n->r == nil)
		{
			if(n->l == nil) t=n->r;
			else t=n->l;
			delete n;
			return t;
		}
		
		for(t=n->r; t->l != nil; t=t->l);
		n->v=t->v;
		n->r=erase(n->r, t->v);
		balance(n);
		return n;
	}
	balance(n);
	update(n);
	return n;
}


inline void sterge(tree &n, int v)
{
	if(!find(n, v)) printf("-1\n");
	else erase(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;
}

void ino(tree n)
{
	if(n == nil) return ;
	ino(n->l);
//	printf("(v: %d min: %d max: %d mindif: %d p:(%d)) ", n->v, n->min, n->max, n->mindif,n->p);
	ino(n->r);
}

inline void afis(tree n)
{
	ino(n);
	printf("\n\n");
}

int main()
{
	srand(time(0));
	init();
	
	freopen("zeap.in","r",stdin);
	freopen("zeap.out","w",stdout);
	
	while(!feof(stdin))
	{
		char ax[64];
		gets(ax);
	//	printf("%s: ", 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));
		}
		//afis(R);
	}
	
	
	
	return 0;
}