const int N=111111;

void upMin(i64 &x,i64 y) {if(x>y) x=y;}
void upMax(i64 &x,i64 y) {if(x<y) x=y;}

struct node
{
    i64 Max,Min,sum,val;
	int size;
	int isRev;
	i64 det;
    node *c[2],*p;

	void reverse()
	{
		swap(c[0],c[1]);
		isRev^=1;
	}

	void add(i64 x)
	{
		val+=x;
		det+=x;
		Max+=x;
		Min+=x;
		sum+=x*size;
	}

	void clear(node *nullNode)
	{
		Max=Min=sum=val=0;
		size=1;
		isRev=det=0;
		c[0]=c[1]=p=nullNode;
	}
};

node a[N],*nullNode;
node b[N],*pv[N];

int n,m,center;

void init()
{
	nullNode=new node();
	nullNode->size=0;
	nullNode->c[0]=nullNode->c[1]=nullNode->p=nullNode;

	int i;
	for(i=1;i<=n;i++)
	{
		a[i].clear(nullNode);
		b[i].clear(nullNode);
		pv[i]=b+i;
	}
}

void pushUp(node *p)
{
    if(p==nullNode) return;
	p->Min=p->Max=p->sum=p->val;
	p->size=1;
	if(p->c[0]!=nullNode)
	{
		upMin(p->Min,p->c[0]->Min);
		upMax(p->Max,p->c[0]->Max);
		p->sum+=p->c[0]->sum;
		p->size+=p->c[0]->size;
	}
	if(p->c[1]!=nullNode)
	{
		upMin(p->Min,p->c[1]->Min);
		upMax(p->Max,p->c[1]->Max);
		p->sum+=p->c[1]->sum;
		p->size+=p->c[1]->size;
	}
}

void pushDown(node *p)
{
    if(p==nullNode) return;
	if(p->isRev)
	{
		if(p->c[0]!=nullNode) p->c[0]->reverse();
		if(p->c[1]!=nullNode) p->c[1]->reverse();
		p->isRev=0;
	}

	if(p->det)
	{
		if(p->c[0]!=nullNode) p->c[0]->add(p->det);
		if(p->c[1]!=nullNode) p->c[1]->add(p->det);
		p->det=0;
	}
}

int isRoot(node *p)
{
    return p->p==nullNode||p->p->c[0]!=p&&p->p->c[1]!=p;
}

node *zig(node *x)
{
    node *p=x->p,*q=p->p;
    p->c[0]=x->c[1];
    if(x->c[1]!=nullNode) x->c[1]->p=p;
    x->c[1]=p;
    p->p=x;
    x->p=q;
    if(q!=nullNode)
    {
        if(q->c[0]==p) q->c[0]=x;
        if(q->c[1]==p) q->c[1]=x;
    }
    pushUp(p);
    pushUp(x);
}

node *zag(node *x)
{
    node *p=x->p,*q=p->p;
    p->c[1]=x->c[0];
    if(x->c[0]!=nullNode) x->c[0]->p=p;
    x->c[0]=p;
    p->p=x;
    x->p=q;
    if(q!=nullNode)
    {
        if(q->c[0]==p) q->c[0]=x;
        if(q->c[1]==p) q->c[1]=x;
    }
    pushUp(p);
    pushUp(x);
}

void splay(node *x)
{
    pushDown(x);
    while(!isRoot(x))
    {
        if(!isRoot(x->p))
        {
            pushDown(x->p->p);
            pushDown(x->p);
            pushDown(x);
            if(x->p->p->c[0]==x->p)
            {
                if(x->p->c[0]==x) zig(x->p),zig(x);
                else zag(x),zig(x);
            }
            else
            {
                if(x->p->c[1]==x) zag(x->p),zag(x);
                else zig(x),zag(x);
            }
        }
        else
        {
            pushDown(x->p);
            pushDown(x);
            if(x->p->c[0]==x) zig(x);
            else zag(x);
        }
    }
}

void mySplay(node *x)
{
	node *r=x;
	while(!isRoot(r)) r=r->p;
	node *tmp=pv[r-a];
	pv[r-a]=nullNode;
	splay(x);
	pv[x-a]=tmp;
}

void access(int u)
{
	node *p=a+u,*q=nullNode;
	while(p!=nullNode)
	{
		mySplay(p);

		node *tmp=pv[p-a];
		int K=p->c[0]==nullNode?0:p->c[0]->size;
		K++;
		pushDown(tmp);
		while(1)
		{
			int lnum=tmp->c[0]==nullNode?0:tmp->c[0]->size;
			if(lnum>=K) tmp=tmp->c[0];
			else if(lnum+1==K) break;
			else
			{
				K-=lnum+1;
				tmp=tmp->c[1];
			}
			pushDown(tmp);
		}
		splay(tmp);
		pv[p-a]=tmp;
		if(p->c[1]!=nullNode)
		{
			node *x=tmp->c[1];
			x->p=nullNode;
			tmp->c[1]=nullNode;
			pv[p->c[1]-a]=x;

			p->c[1]=nullNode;
		}
		if(q!=nullNode)
		{
			node *x=pv[q-a];
			pv[q-a]=nullNode;
			x->p=tmp;
			tmp->c[1]=x;
			p->c[1]=q;
		}
		pushUp(p);
		pushUp(tmp);

		q=p;
		p=p->p;
	}
}

void makeRoot(int u)
{
	access(u);
	mySplay(a+u);
	a[u].reverse();
	pv[u]->reverse();
}

void link(int u,int v)
{
	makeRoot(u);
	makeRoot(v);
	a[u].p=a+v;
}

int main()
{
	scanf("%d%d%d",&n,&m,&center);
	init();
	int i;
	for(i=1;i<n;i++)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		link(u,v);
	}

	while(m--)
	{
		char op[20];
		int u,v;
		i64 w;
		scanf("%s%d%d",op,&v,&u);

		makeRoot(v);
		access(u);
		mySplay(a+u);

		if(op[0]=='I'&&op[2]=='c')
		{
			w=getInt();
			pv[u]->add(w);
		}
		else if(op[0]=='I'&&op[2]=='v') pv[u]->reverse();
		else if(op[0]=='S') printf("%lld\n",pv[u]->sum);
		else if(op[0]=='M'&&op[1]=='a') printf("%lld\n",pv[u]->Max);
		else if(op[0]=='M'&&op[1]=='i') printf("%lld\n",pv[u]->Min);
	}
}