AVL

struct AVLNode{
	AVLNode *kid[2],*pa;
	int val,cnt;
	int flag;
	AVLNode():kid[0](NULL),kid[0](NULL),pa(NULL),flag(0){}
}*root,*nil;
void Rotate(AVLNode *node,int drct){
	AVLNode *t=node->kid[1-drct];
	node->kid[1-drct]->kid[drct]->pa=node;
	node->kid[1-drct]=node->kid[1-drct]->kid[drct];
	p->pa=node->pa;
	if(p->pa->kid[0]==node) p->pa->kid[0]=p;
	else p->pa->kid[1]=p;
	node->pa=p;
	p->kid[drct]=node;
}
void Insert(AVLNode *root,int val){
	if(root==NULL){
		root=new AVLNode();
		root->val=val;
		return;
	}
	AVLNode *p=root;
	while(val<p->val && p->lhd!=NULL) p=p->lhd; 
	while(val>p->val && p->rhd!=NULL) p=p->rhd;
	if(val<p->val){ p->lhd=new AVLNode(); p->lhd->val=val; }
	else if(val>p->val){ p->rhd=new AVLNode(); p->rhd->val=val; }
	else p->cnt++;
}
void Query(AVLNode *root,int val){
	AVLNode *p=root;
	while(p->val!=val){
		if(val<p->val){
			if(p->lhd==NULL) return false;
			p=p->lhd; continue;
		}
		if(val>p->val){
			if(p->rhd==NULL) return false;
			p=p->lhd; continue;
		}  
	}
	return true;
}
void Delete(AVLNode *root,int val){
	AVLNode *p=root;
	while(p->val!=val){
		if(val<p->val){
			if(p->lhd==NULL) return false;
			p=p->lhd; continue;
		}
		if(val>p->val){
			if(p->rhd==NULL) return false;
			p=p->lhd; continue;
		}  
	}
	// ..............	
}

 

////////////////
	int gradir=(p->pa->chi[0])==p?0:1;
    node->pa=p; p->chi[dir]=node;
    p->bf+=(dir==0)?-1:1;
    while(p->bf){
        p->pa->bf+=(gradir==0)?-1:1;
        if(p->pa->bf==-2 || p->pa->bf==2 ){
            int rodir=(p->pa->bf<0)?1:0;
            Rotate(p->pa->dir,rodir);
            p->chi[rodir]->bf+=(rodir==1)?1:-1;
            p->bf+=(rodir==1)?1:-1;
        }else{ p=p->pa; }
    }

 

// http://acm.nankai.edu.cn/p1248.html
#include<iostream>
#include<string.h>
#include<stdio.h>
using namespace std;
#define abs(x) (((x)<0)?(-x):(x))
int flag=0;
struct Int{
	int size,saf,lazy;
	Int():size{}
	bool operator <(const & a) const
	{ return saf<a.saf; }
	bool operator ==(const & a) const
	{ return saf==a.saf; }
};
struct AVLNode{
    AVLNode *chi[2],*pa;
    Int val;
    int bf,cnt;
}*nil=new AVLNode(),*root=nil;
inline void Nil(){ nil->chi[0]=nil->chi[1]=nil->pa=nil; nil->bf=nil->cnt=0;}
inline void CreatNode(AVLNode * &node,Int val,int cnt=1){
    if(node!=nil){ AVLNode *p=node; delete p; }
    node=new AVLNode(); node->val=val; node->cnt=cnt;
    node->pa=node->chi[0]=node->chi[1]=nil; node->bf=0;
}
inline void Connect(AVLNode *pa,AVLNode *node,int dir)
    { pa->chi[dir]=node; node->pa=pa; }
AVLNode * Bound(AVLNode * root,Int val){
    AVLNode *p=root; if(root==nil) return nil;
    while(p!=nil && val!=p->val){
        int dir=(val<p->val);
        node=node->kid[drct];
    }
    return p;
}
AVLNode * Extrema(AVLNode * node,int dir){
    while(node->kid[dir]!=nil) node=node->chi[dir];
    return node;
}
BSTNode * Cessor(BSTNode * node,int dir){
    if(node->kid[dir]!=nil) return Extrema(node->chi[dir],1-dir);
    for(AVLnode * p=node->pa;p!=nil && p->chi[dir]==node;node=p,p=p->pa);
    return p;
}
void Rotate(AVLNode *node,int rodir){
    Nil(); AVLNode *pivot=node->chi[1-rodir];
    Connect(node,node->chi[1-rodir]->chi[rodir],1-rodir);
    Connect(node->pa,pivot,(node->pa->chi[0]==node)?0:1);
    Connect(pivot,node,rodir); Nil();
	node->bf+=(rodir)?2:-2; pivot->bf+=(rodir)?1:-1;
}
AVLNode * Bound(AVLNode * node,Int val){
    if(node==nil) return nil;
    for(;val!=node->val;node=node->chi[dir]){
        int dir=(val<node->val)?0:1
        if(node->chi[dir]==nil) return node;
    }
    return node;
}
AVLNode * Search(AVLNode *root,int val){
    AVLNode *p=Bound(root,val);
    if(p->val==val) return p; return nil;
}
void Balance(AVLNode node,int dbf,int aimbf){
    while(abs(node->bf+=dbf)!=aimbf){
        if(abs(node->bf)==2){ 
		int dir=(node->bf<0)?0:1;
		if((node->bf)*(node->chi[dir]->bf)<0)
			Rotate(node->chi[dir],dir)
		Rotate(node,1-dir); node->pa->bf-=dbf; 
	}
	if(node=node->pa==nil) return;
    }
}
void Insert(AVLNode *root,Int val){
    if(root==nil){ CreatNode(root,val); return; }
    Nil(); AVLNode *p=Bound(root,val);
    if(p->val==val){ p->cnt++; return; }
    int dir=(val<p->val)?0:1; AVLNode *node;
    CreatNode(node,val); Connect(p,node,dir);
    Balance(p,(!dir)?-1:1,0);
}
bool Delete(AVLNode *root,int val){
    if(root==nil) return false; 
    Nil(); AVLNode *p=Search(root,val);
    if(p==nil) return false;
    if(p->cnt>1){ (p->cnt)--; return true; }
    if(p->chi[0]!=nil || p->chi[1]!=nil){
        AVLNode *suc=Cessor(p,1);
        if(suc==nil) suc=Cessor(p,0);
        p->val=suc->val; p=suc;
    }
	int dir=p->pa->chi[0]==p?0:1;
    p->pa->chi[dir]=nil; 
    Balance(p->pa,(!dir)?1:-1,1); delete p;
}
void Depart(AVLNode *root,int min){
}
int main(){
	int n,m;
	scanf("%d%d",&n,&m);
	while(n--){
		char q; int a;
		scanf("%c%d",&q,&a);
		switch(c){
			case 'I': a-=flag; if(a>=m) Insert(root,a); break;
			case 'A': m+=a; flag+=a; break;
			case 'S': m-=a; flag-=a; Depart(root,m); break;
			case 'F': Query(root,a); break;
		}
	}
	return 0;
}

 

AVLNode * Bound(AVLNode * root,Int val){
    if(root==nil) return nil;
    AVLNode *p=root; 
    while(p!=nil && val!=p->val){
        int dir=(val<p->val);
        p=p->chi[dir];
    }
    return p;
}

// A.myc 
#include<iostream>  
#include<string.h>  
#include<stdio.h>  
#include<string>  
#include <stddef.h>  
#include<queue> 
#include<fstream>
using namespace std; 
int oo=0xffffffff; 
int cnt=0;  
#define abs(x) (((x)<0)?(-x):(x))  
typedef string Int;  
struct AVLNode{  
    AVLNode *chi[2],*pa;  
    Int val;  
    int bf,cnt;  
    int blank,len,hei; 
}*nil=new AVLNode(),*root=nil;  
inline void Nil(){ nil->chi[0]=nil->chi[1]=nil->pa=nil; nil->bf=nil->cnt=0; nil->blank=nil->len=nil->hei=0; }  
void OutNode(AVLNode * node,int cor){ 
    for(int i=cor;i<node->blank;i++) printf(" "); 
    cout<<node->val; 
} 
int CalCor(AVLNode * root,int lst){
	Nil(); root->blank=0;
	root->len=root->val.length(); int dis=0,dis2=0;;
	if(root->chi[0]!=nil){ root->chi[0]->hei=root->hei+1; dis=CalCor(root->chi[0],lst); }
	int halflen=(root->len)/2;  root->blank=lst+dis-halflen; if(root->blank<lst) root->blank=lst;
	if(root->chi[1]!=nil){ root->chi[1]->hei=root->hei+1; dis2=CalCor(root->chi[1],lst+dis+(dis?1:0)); }
	if(!dis2) root->blank-=(root->len+1)/2;  if(root->blank<lst) root->blank=lst;
	int ans=((dis+(dis?1:0)+dis2)>root->len)?dis+(dis?1:0)+dis2:root->len;
	if(dis2 && dis && (root->chi[1]->blank-root->chi[0]->blank)>root->len && (root->chi[0]->blank+root->chi[1]->blank)/2+root->len<=ans) 
		root->blank=(root->chi[0]->blank+root->chi[1]->blank)/2;
	return ans; Nil();
}

/*int CalCor(AVLNode * root,int lst,int &padel,int dir){
	Nil(); root->blank=0;
	root->delta=0; root->len=root->val.length(); int dis=0,dis2=0;;
	if(root->chi[0]!=nil){ root->chi[0]->hei=root->hei+1; dis=CalCor(root->chi[0],lst,root->delta,0); }
	root->blank=dis+root->delta+lst;
	if(root->chi[1]!=nil){ root->chi[1]->hei=root->hei+1; dis2=CalCor(root->chi[1],root->blank+root->len,root->delta,1); }
	if(dis && dis2) root->delta/=2;  root->blank=dis+dis?(root->delta):0+lst;
	if(!dir){ padel+=dis2+(dis2)?(root->delta):0+root->chi[1]->len; return root->blank+root->len-lst; }
	else { padel+=root->blank-lst; return dis2+(dis2)?(root->delta):0+root->chi[1]->len; } Nil();
}*/


/*void CalCor(AVLNode *root,int cor,int lst,int &rst,int dir){ 
    root->len=root->val.length(); cor-=dir*root->len/2;  
    if(root->chi[0]!=nil){ CalCor(root->chi[0],cor,lst,root->blank,-1); root->chi[0]->hei=root->hei+1;} 
    if(lst<0){ cor-=lst; rst-=lst; root->blank-=lst; lst=0; } 
    cor+=root->len; if(cor>rst){ rst=cor; } 
    if(root->chi[1]!=nil){ CalCor(root->chi[1],cor,lst,root->blank,1); root->chi[1]->hei=root->hei+1; } 
} */
void OutTree(AVLNode * root){ 
    queue<AVLNode *> q; 
    q.push(root); int y=0,cor=0,cor2=0,cor3=0; string branch="",pro="";
    while(!q.empty()){ 
        AVLNode* t=q.front();  
        if(t->hei!=y) { cout<<endl<<pro<<endl<<branch; branch=""; pro=""; y=t->hei; printf("\n"); cor=0; cor2=0; cor3=0; } 
		OutNode(t,cor); cor=t->blank+t->len;
		for(int i=cor3;i<t->blank;i++) pro+=' '; cor3=t->blank;
		switch(t->bf){
			case -1: pro+="-1  "; cor3+=4; break;
			case -2: pro+="-2  "; cor3+=4; break;
			case 0:  pro+="0  "; cor3+=3; break;
			case 1:  pro+="1  "; cor3+=3; break;
			case 2:  pro+="2  "; cor3+=3; break;
		}
		if(t->chi[0]!=nil){ 
			q.push(t->chi[0]); 
			for(int i=cor2;i<(t->chi[0]->blank+t->blank)/2;i++) branch+=' '; 
			branch+='/'; cor2=(t->chi[0]->blank+t->blank)/2; 

		}
		if(t->chi[1]!=nil){ 
			q.push(t->chi[1]); 
			for(int i=cor2;i<(t->chi[1]->blank+t->blank)/2;i++) branch+=' '; 
			branch+='\\'; cor2=(t->chi[1]->blank+t->blank)/2; 
		}
        q.pop(); 
    } 
} 
void Doit(){ 
    root->hei=0; 
	CalCor(root,0);
    // CalCor(root,0,l,oo,-1); 
    OutTree(root); 
    printf("\n//////////////////////////////////\n"); 
} 
inline AVLNode * CreatNode(AVLNode * &node,Int val,int cnt=1){  
    if(node!=NULL && node!=nil){ AVLNode *p=node; delete p; }  
    node=new AVLNode(); node->val=val; node->cnt=cnt;  
    node->pa=node->chi[0]=node->chi[1]=nil; node->bf=0;  
    return node;  
}  
inline void Connect(AVLNode *pa,AVLNode *node,int dir)  
    { pa->chi[dir]=node; node->pa=pa; }  
AVLNode * Bound(AVLNode * node,Int val){  
    if(node==nil) return nil;  
    for(int dir;val!=node->val;node=node->chi[dir]){  
        dir=(val<node->val)?0:1;  
        if(node->chi[dir]==nil) return node;  
    }  
    return node;  
}  
AVLNode * Extrema(AVLNode * node,int dir){  
    while(node->chi[dir]!=nil) node=node->chi[dir];  
    return node;  
}  
AVLNode * Cessor(AVLNode * node,int dir){  
    if(node->chi[dir]!=nil) return Extrema(node->chi[dir],1-dir);  
    for(AVLNode * p=node->pa;p!=nil && p->chi[dir]==node;node=p,p=p->pa);  
    return node->pa;  
}  
void Rotate(AVLNode *node,int rodir){  
    Nil(); AVLNode *pivot=node->chi[1-rodir];  
    Connect(node,node->chi[1-rodir]->chi[rodir],1-rodir);  
    Connect(node->pa,pivot,(node->pa->chi[0]==node)?0:1);  
    Connect(pivot,node,rodir); Nil();  
	if(root==node) root=pivot;  // !!!!!!
    node->bf+=(rodir)?2:-2; pivot->bf+=(rodir)?1:-1;  
    Doit(); 
}  
    
AVLNode * Search(AVLNode *root,Int val){  
    AVLNode *p=Bound(root,val);  
    if(p->val==val) return p; return nil;  
}  
void Balance(AVLNode * node,int dbf,int aimbf){  
    for((node->bf)+=dbf;aimbf!=abs(node->bf);(node->bf)+=dbf){  
		dbf=(node->pa->chi[0]==node)?-1:1;
        if(abs(node->bf)==2){  
			int dir=(node->bf<0)?0:1;  
			if((node->bf)*(node->chi[dir]->bf)<0) Rotate(node->chi[dir],dir);  
			Rotate(node,1-dir);
			node->pa->bf-=dbf;  
		}  
		if((node=node->pa)==nil) { Nil(); return;}  
	}  Nil();
}  
void Insert(AVLNode * &root,Int val){  
    if(root==nil){ root=CreatNode(root,val); return; }  
    Nil(); AVLNode *p=Bound(root,val);  
    if(p->val==val){ p->cnt++; return; }  
    int dir=(val<p->val)?0:1; AVLNode *node=nil;  
    CreatNode(node,val); Connect(p,node,dir);  
    Balance(p,(!dir)?-1:1,0);  
    Doit(); 
}  
bool Delete(AVLNode *root,Int val){  
    if(root==nil) return false;  
    Nil(); AVLNode *p=Search(root,val);  
    if(p==nil) return false;  
    if(p->cnt>1){ (p->cnt)--; return true; }  
    if(p->chi[0]!=nil || p->chi[1]!=nil){  
        AVLNode *suc=Cessor(p,1);  
        if(suc==nil) suc=Cessor(p,0);  
        p->val=suc->val; p=suc;  
    }  
    int dir=p->pa->chi[0]==p?0:1;  
    p->pa->chi[dir]=nil;  
    Balance(p->pa,(!dir)?1:-1,1); delete p;  
    Doit(); 
    return true;  
}  
void Traversal(AVLNode * root){  
    if(root->chi[0]!=nil) Traversal(root->chi[0]);  
    cout<<root->val;  
    printf(" %.4lf\n",(double)root->cnt/(double)cnt*100.0); // double  
    if(root->chi[1]!=nil) Traversal(root->chi[1]);  
}  
int main(){  
	freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout); 
    string s; 
    while (getline(cin,s)) // ## 
        if(s!="" && ++cnt) Insert(root,s); // ## 
    Traversal(root);  
    return 0;  
}