#include<iostream>

 #include<stdio.h>

 #include<string.h>

 #include <string>

 #include <cmath>

 #include <algorithm>

 #include <map>

 #include <set>

 #include <queue>

 #include <stack>

 #include<stdlib.h>

 #include <vector>

 using namespace std;

 #pragma comment(linker, "/STACK:1024000000,1024000000")

 #define ll __int64

 #define CL(a,b) memset(a,b,sizeof(a))

 #define MAXNODE 100010

 int n,q;

 typedef struct myedge

 {

     int v,next,p;

 }E;

 E edge[MAXNODE*];

 int head[MAXNODE],ce;

 void inithead()

 {

     CL(head,-);

     ce=;

 }

 void addedge(int s,int e,int p)

 {

     edge[ce].p=p;edge[ce].v=e;edge[ce].next=head[s];head[s]=ce++;

     edge[ce].p=p;edge[ce].v=s;edge[ce].next=head[e];head[e]=ce++;

 }

 typedef struct opedge

 {

     int v,t,k,p,next;

 }O;

 O op[MAXNODE*];

 int heado[MAXNODE],co;

 int etn[MAXNODE];

 void initheado()

 {

     CL(heado,-);

     CL(etn,);

     co=;

 }

 void addo(int s,int e,int t,int k,int p)

 {

     op[co].t=t;op[co].v=e;op[co].next=heado[s];op[co].p=p;op[co].k=k;heado[s]=co++;

     op[co].t=t;op[co].v=s;op[co].next=heado[e];op[co].p=p;op[co].k=k;heado[e]=co++;

 }

 int fa[MAXNODE];

 int fifa(int i)

 {

     if(fa[i]==i)return i;

     fa[i]=fifa(fa[i]);

     return fa[i];

 }

 int pre[MAXNODE];

 int tagp[MAXNODE];

 ll  re[MAXNODE][];

 int tag[MAXNODE];

 void initdfs()

 {

     CL(pre,-);

     CL(tagp,);

     CL(tag,);

     CL(re,);

     for(int i=;i<MAXNODE;i++)fa[i]=i;

 }

 void dfsad(int i,int pr)

 {

     pre[i]=pr;

     int p=head[i],v,t,k,pos,rt;

     while(p!=-)

     {

         v=edge[p].v;

         if(pre[v]==-)

         {

             etn[edge[p].p]=v;

             dfsad(v,i);

         }

         p=edge[p].next;

     }

     tag[i]=;

     p=heado[i];

     while(p!=-)

     {

         v=op[p].v;

         t=op[p].t;

         k=op[p].k;

         rt=fifa(v);

         if(tag[v]==&&tagp[op[p].p]==)

         {

             re[i][t]+=k;re[v][t]+=k;

             re[rt][t]-=k;

             if(t==)

             {

                 re[pre[rt]][t]-=k;

             }

             else re[rt][t]-=k;

             tagp[op[p].p]=;

         }

         p=op[p].next;

     }

     fa[i]=pr;

 }

 void dfs(int i,int pr)

 {

     tag[i]=;

     int p=head[i],v;

     while(p!=-)

     {

         v=edge[p].v;

         if(tag[v]==)dfs(v,i);

         p=edge[p].next;

     }

     re[pr][]+=re[i][];

     re[pr][]+=re[i][];

 }

 char opt[];

 int main()

 {

     int tt,ii;

     cin>>tt;

     for(ii=;ii<=tt;ii++)

     {

         scanf("%d %d",&n,&q);

         int i,j,a,b,k;

         inithead();

         initheado();

         initdfs();

         for(i=;i<n;i++)

         {

             scanf("%d %d",&a,&b);

             addedge(a,b,i);

         }

         for(i=;i<=q;i++)

         {

             scanf("%s %d %d %d",opt,&a,&b,&k);

             {

                 if(opt[]=='')

                 {

                     addo(a,b,,k,i);

                 }

                 else

                 {

                     addo(a,b,,k,i);

                 }

             }

         }

         dfsad(,);

         CL(tag,);

         dfs(,);

         printf("Case #%d:\n",ii);

         for(i=;i<=n;i++)

         {

             if(i!=)printf(" ");

             printf("%I64d",re[i][]);

         }cout<<endl;

         for(i=;i<n;i++)

         {

             if(i!=)printf(" ");

             printf("%I64d",re[etn[i]][]);

         }cout<<endl;

     }

     return ;

 }