#include<cstdio>

#include<algorithm>

using namespace std ; 

const int MAXN =  *  +  ;

const int MAX_SIZE =  *  +  ;

int N , Q ; 

int max_equal ( int & a , const int b ) { if ( a < b ) a = b ; return a ; }

namespace Seg {

int maxv [ MAX_SIZE *  ] ;

int sumv [ MAX_SIZE *  ] ;

int value [ MAXN ] ;

int l , r , v ; 

void maintain ( const int o ) {

    const register int o1 = o <<  , o2 = o <<  |  ;

    maxv [ o ] = max ( maxv [ o1 ] , maxv [ o2 ] ) ;

    sumv [ o ] = sumv [ o1 ] + sumv [ o2 ] ;

}

void __build ( const int o , const int L , const int R ) {

    if ( R - L ==  ) maxv [ o ] = sumv [ o ] = value [ L ] ;

    else {

        const int M = ( L + R ) /  ;

        __build ( o <<  , L , M ) ;

        __build ( o <<  |  , M , R ) ;

        maintain ( o ) ;

    }

}

void build () {

    __build (  ,  , N ) ;

}

void _modify ( const int o , const int L , const int R ) {

    if ( R - L ==  ) maxv [ o ] = sumv [ o ] = v ;

    else {

        const int M = ( L + R ) /  ;

        if ( l < M ) _modify ( o <<  , L , M ) ;

        else _modify ( o <<  |  , M , R ) ;

        maintain ( o ) ;

    }

}

void modify ( const int p , const int V ) {

    l = p ; v = V ; _modify (  ,  , N ) ;

}

void _Qmax ( const int o , const int L , const int R ) {

    if ( l <= L && R <= r ) max_equal ( v , maxv [ o ] ) ;

    else {

        const int M = ( L + R ) /  ;

        if ( l < M ) _Qmax ( o <<  , L , M ) ;

        if ( M < r ) _Qmax ( o <<  |  , M , R ) ;

    }

}

int Qmax ( int L , int R ) {

    if ( L > R ) swap ( L , R ) ;

    l = L ; r = R +  ; v = - (  <<  ) /* -INF */ ;

    _Qmax (  ,  , N ) ;

    return v ;

}

void _Qsum ( const int o , const int L , const int R ) {

    if ( l <= L && R <= r ) v += sumv [ o ] ;

    else {

        const int M = ( L + R ) /  ;

        if ( l < M ) _Qsum ( o <<  , L , M ) ;

        if ( M < r ) _Qsum ( o <<  |  , M , R ) ;

    }

}

int Qsum ( int L , int R ) {

    if ( L > R ) swap ( L , R ) ;

    l = L ; r = R +  ; v =  ;

    _Qsum (  ,  , N ) ;

    return v ;

}

}

struct edge {

    int p ;

    edge * nxt ;

} ;

edge * V [ MAXN ] ;

int value [ MAXN ] ;

edge E [ MAXN *  ] ; 

void ___add_edge ( const int a , const int b ) {

    static edge * t = E ;

    t -> p = b ; t -> nxt = V [ a ] ; V [ a ] = t ++ ;

}

void add_edge ( const int a , const int b ) {

    ___add_edge ( a , b ) ;

    ___add_edge ( b , a ) ;

}

namespace Link_cut {

    int top [ MAXN ] ;

    int num [ MAXN ] ;

    int size [ MAXN ] ;

    int height [ MAXN ] ;

    int father [ MAXN ] ;

    namespace GET_SIZE {

        int dfs ( const int o ) {

            size [ o ] =  ;

            for ( edge * i = V [ o ] ; i !=  ; i = i -> nxt )

            if ( i -> p != father [ o ] ) {

                father [ i -> p ] = o ;

                size [ o ] += dfs ( i -> p ) ;

            }

            return size [ o ] ;

        }

    }

    void Get_size () { father [  ] =  ; GET_SIZE :: dfs (  ) ; }  

    namespace LINK_CUT {

        void dfs ( const int o , const int t , const int h ) {

            if ( o <  ) return ;

            else {

                static int dfs_clock =  ;

                top [ o ] = t ;

                num [ o ] = dfs_clock ++ ;

                height [ o ] = h ;

                int max_size_value = - , max_size_node = - ;

                for ( edge * i = V [ o ] ; i !=  ; i = i -> nxt )

                if ( i -> p != father [ o ] && max_size_value < size [ i -> p ] ) {

                    max_size_value = size [ i -> p ] ;

                    max_size_node = i -> p ;

                }

                dfs ( max_size_node , t , h ) ;

                for ( edge * i = V [ o ] ; i !=  ; i = i -> nxt )

                if ( i -> p != father [ o ] && i -> p != max_size_node ) dfs ( i -> p , i -> p , h +  ) ;

            }

        }

    }

    void cut_link ( ) {

        LINK_CUT :: dfs (  ,  ,  ) ;

        for ( int i =  ; i < N ; ++ i ) Seg :: value [ num [ i ] ] = :: value [ i ] ;

        Seg :: build () ;

    }

    void modify ( const int p , const int v ) {

        Seg :: modify ( num [ p ] , v ) ;

    }

    int Qsum ( int a , int b ) {

        int v =  ;

        while ( top [ a ] != top [ b ] ) {

            if ( height [ a ] < height [ b ] ) swap ( a , b ) ;

            v += Seg :: Qsum ( num [ a ] , num [ top [ a ] ] ) ;

            a = father [ top [ a ] ] ;

        }

        v += Seg :: Qsum ( num [ a ] , num [ b ] ) ;

        return v ;

    }

    int Qmax ( int a , int b ) {

        int v = -(  <<  ) ;

        while ( top [ a ] != top [ b ] ) {

            if ( height [ a ] < height [ b ] ) swap ( a , b ) ;

            max_equal ( v , Seg :: Qmax ( num [ a ] , num [ top [ a ] ] ) ) ;

            a = father [ top [ a ] ] ;

        }

        max_equal ( v , Seg :: Qmax ( num [ a ] , num [ b ] ) ) ;

        return v ;

    }

}

char c [  ] ;

int main () {

    scanf ( "%d" , & N ) ;

    for ( int i =  ; i < N ; ++ i ) {

        int a , b ;

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

        add_edge ( a -  , b -  ) ;

    }

    for ( int i =  ; i < N ; ++ i ) scanf ( "%d" , & value [ i ] ) ;

    Link_cut :: Get_size () ;

    Link_cut :: cut_link () ;

    scanf ( "%d" , & Q ) ;

    for ( int i =  ; i < Q ; ++ i ) {

        int a , b ;

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

        switch ( c [  ] ) {

            case 'H' :

                Link_cut :: modify ( a -  , b ) ;

                break ;

            case 'M' :

                printf ( "%d\n" , Link_cut :: Qmax ( a -  , b -  ) ) ;

                break ;

            case 'S' :

                printf ( "%d\n" , Link_cut :: Qsum ( a -  , b -  ) ) ;

                break ;

        }

    }

    return  ;

}