#include <cstdio>

#include <algorithm>

#include <cstring>

#include <cstdlib>

 

using namespace std;

 

#define MAXN 30001

#define L(t) left[t]

#define R(t) right[t]

#define F(t) father[t]

#define G(t) father[father[t]]

#define IN(t) Information[t]

#define S(t)IN(t).Sum

#define M(t)IN(t).Max

#define V(t) Value[t]

#define P(t) path_parent[t]

#define Cl(t)(L(F(t))==t)

#define inf 0x7fffffff

#define Parent(v)P(splay_roof(v))

 

struct edge{

    edge *next;

    int t;

    edge (){

        next=NULL;

    }

}*head[MAXN];

int n,m,V=0,w[MAXN];

 

void Add(int s,int t){

    edge *p=new(edge);

    p->t=t,p->next=head[s];

    head[s]=p;

}

 

void AddEdge(int s,int t){

    Add(s,t),Add(t,s);

}

 

void Build_Tree(){

    memset(head,0,sizeof(head));

    scanf("%d",&n);

    for(int i=0;i++<n-1;){

        int s,t;scanf("%d%d",&s,&t);

        AddEdge(s,t);

    }

    for(int i=0;i++<n;)scanf("%d",&w[i]);

}

 

int left[MAXN],right[MAXN],father[MAXN],path_parent[MAXN],Value[MAXN];

bool f[MAXN];

struct type_inf {

    int Sum,Max;

    type_inf (){

        Sum=0;

        Max=-inf;

    }

} Information[MAXN];

 

void Dfs(int v){

    f[v]=false;

    for(edge *p=head[v];p;p=p->next){

        if(f[p->t])P(p->t)=v,Dfs(p->t);

    }

}

 

void Init_lct(){

    memset(f,true,sizeof(f));

    memset(father,0,sizeof(father));

    memset(left,0,sizeof(left));

    memset(right,0,sizeof(right));

    memset(path_parent,0,sizeof(path_parent));

    P(1)=0,Dfs(1);

    for(int i=0;i++<n;)S(i)=M(i)=V(i)=w[i];

}

 

type_inf Merge(type_inf x,type_inf y){

    type_inf u;

    u.Max=max(x.Max,y.Max),u.Sum=x.Sum+y.Sum;

    return u;

}

 

void update(int t){

    IN(t)=Merge(IN(L(t)),IN(R(t)));

    S(t)+=V(t),M(t)=max(M(t),V(t));

}

 

void zag(int t){

    int k=R(t),u=F(t),flag=Cl(t)?1:0;

    R(t)=L(k),F(L(k))=t;update(t);

    L(k)=t,F(t)=k;update(k);

    F(k)=u;

    if(flag)L(u)=k;else R(u)=k;

}

 

void zig(int t){

    int k=L(t),u=F(t),flag=Cl(t)?1:0;

    L(t)=R(k),F(R(k))=t;update(t);

    R(k)=t,F(t)=k;update(k);

    F(k)=u;

    if(flag)L(u)=k;else R(u)=k;

}

 

void splay(int t){

    while(F(t)){

        if(!G(t))if(Cl(t))zig(F(t));else zag(F(t));

        else{

            if(Cl(t)){

                if(Cl(F(t)))zig(G(t));

                zig(F(t));

            }else{

                if(!Cl(F(t)))zag(G(t));

                zag(F(t));

            }

        }

    }

}

 

int splay_roof(int v){

    splay(v);

    int t=v;

    while(L(t)) t=L(t);

    return t;

}

 

int Access(int v){

    int u=0;

    do{

        splay(v);

        if(R(v)){

            F(R(v))=0;

        }

        R(v)=u;F(u)=v;

        update(v);

        u=v;

        v=Parent(v);

    }while(v);

    return u;

}

 

void Solve(){

    scanf("%d",&m);

    while(m--){

        char s[10];

        scanf("%s",&s);

        if(s[0]=='C'){

            int x,y;

            scanf("%d%d",&x,&y);

            Access(x);

            splay(x);

            V(x)=y;

            update(x);

        }else{

            int u,v;

            scanf("%d%d",&u,&v);

            if(v==u){

                printf("%d\n",V(u));

                continue;

            }

            Access(u);

            int w=Access(v);

            type_inf ans;

            if(w!=u&&w!=v){

                splay(w),splay(u);

                ans=Merge(IN(R(w)),IN(u));

            }else if(w==v){

                splay(u);

                ans=IN(u);

            }else if(w==u){

                splay(u);

                ans=IN(R(u));

            }

            printf("%d\n",s[1]=='S'?ans.Sum+V(w):max(ans.Max,V(w)));

        }

    }

}

 

int main(){

    Build_Tree();

    Init_lct();

    Solve();

    return 0;

}