#pragma GCC optimize (2)
#include <cstdio>
#include <algorithm>
#include <queue>
#define max(a,b) ((a) > (b) ? (a) : (b))
#define min(a,b) ((a) < (b) ? (a) : (b))
#define ls seg[p].lson
#define rs seg[p].rson
using namespace std;
const int N = 1e5;
const int C = 1e5;
 
const int BUFF_SIZE = 3 << 20;
char BUFF[BUFF_SIZE],*BB,*BE;
#define gc() (BB == BE ? (BE = (BB = BUFF) + fread(BUFF,1,BUFF_SIZE,stdin),BB == BE ? EOF : *BB++) : *BB++)
inline void read(int &x)
{
    char ch = 0;
    int w = 0;
    x = 0;
    while(ch < '0' || ch > '9')
        w |= ch == '-',ch = gc();
    while(ch >= '0' && ch <= '9')
        x = (x << 3) + (x << 1) + (ch ^ '0'),ch = gc();
    x = w ? -x : x;
}
 
struct segnode
{
    int sum,max;
    int lson,rson;
} seg[(N << 5) + 10];
int seg_tot;
int to[(N << 1) + 10],pre[(N << 1) + 10],first[N + 10],edge_tot;
inline void add(const int &u,const int &v)
{
    to[++edge_tot] = v;
    pre[edge_tot] = first[u];
    first[u] = edge_tot;
}
int f[N + 10],d[N + 10],siz[N + 10],son[N + 10],top[N + 10],rk[N + 10],id[N + 10],dfn_tot;
int a[N + 10],w[N + 10];
  
void dfs1(int p,int fa,int dep)
{
    f[p] = fa;
    d[p] = dep;
    siz[p] = 1;
    for(register int i = first[p];i;i = pre[i])
        if(to[i] ^ fa)
        {
            dfs1(to[i],p,dep + 1);
            siz[p] += siz[to[i]];
            if(!son[p] || siz[to[i]] > siz[son[p]])
                son[p] = to[i];
        }
}
  
void dfs2(int p,int t)
{
    top[p] = t;
    rk[++dfn_tot] = p;
    id[p] = dfn_tot;
    if(!son[p])
        return ;
    dfs2(son[p],t);
    for(register int i = first[p];i;i = pre[i])
        if(to[i] ^ f[p] && to[i] ^ son[p])
            dfs2(to[i],to[i]);
}
  
void insert(int x,int k,int &p,int tl,int tr)
{
    if(!p)
        p = ++seg_tot;
    if(tl == tr)
    {
        seg[p].sum = seg[p].max = k;
        return ;
    }
    int mid = tl + tr >> 1;
    if(x <= mid)
        insert(x,k,ls,tl,mid);
    else
        insert(x,k,rs,mid + 1,tr);
    seg[p].sum = seg[ls].sum + seg[rs].sum;
    seg[p].max = max(seg[ls].max,seg[rs].max);
    if(!seg[p].sum)
    	p = 0;
}

void remove(int x,int &p,int tl,int tr)
{
    if(tl == tr)
    {
        p = 0;
        return ;
    }
    int mid = tl + tr >> 1;
    if(x <= mid)
        remove(x,ls,tl,mid);
    else
        remove(x,rs,mid + 1,tr);
    seg[p].sum = seg[ls].sum + seg[rs].sum;
    seg[p].max = max(seg[ls].max,seg[rs].max);
    if(!seg[p].sum)
    	p = 0;
}
  
int getsum(int l,int r,int p,int tl,int tr)
{
    if(!seg[p].sum)
        return 0;
    if(l <= tl && tr <= r)
        return seg[p].sum;
    int ret = 0;
    int mid = tl + tr >> 1;
    if(l <= mid)
        ret += getsum(l,r,ls,tl,mid);
    if(r > mid)
        ret += getsum(l,r,rs,mid + 1,tr);
    return ret;
}
  
int getmax(int l,int r,int p,int tl,int tr)
{
    if(!seg[p].max)
        return 0;
    if(l <= tl && tr <= r)
        return seg[p].max;
    int ret = -0x3f3f3f3f;
    int mid = tl + tr >> 1;
    if(l <= mid)
        ret = max(ret,getmax(l,r,ls,tl,mid));
    if(r > mid)
        ret = max(ret,getmax(l,r,rs,mid + 1,tr));
    return ret;
}
  
int n,q;
int rt[C + 10];
int x,y;
char opt[5];
  
int main()
{
    read(n),read(q);
    for(register int i = 1;i <= n;++i)
        read(a[i]),read(w[i]);
    for(register int i = 1;i < n;++i)
        read(x),read(y),add(x,y),add(y,x);
    dfs1(1,0,1),dfs2(1,1);
    for(register int i = 1;i <= n;++i)
        insert(id[i],a[i],rt[w[i]],1,n);
    while(q--)
    {
        char ch = 0,*p = opt;
        while(ch < 'A' || ch > 'Z')
            ch = gc();
        while(ch >= 'A' && ch <= 'Z')
            *p++ = ch,ch = gc();
        read(x),read(y);
        if(opt[0] == 'C')
        {
            if(opt[1] == 'C')
            {
                remove(id[x],rt[w[x]],1,n);
                w[x] = y;
                insert(id[x],a[x],rt[w[x]],1,n);
            }
            else
            {
                a[x] = y;
                insert(id[x],a[x],rt[w[x]],1,n);
            }
        }
        else
        {
            if(opt[1] == 'S')
            {
                int root = rt[w[x]];
                int fx = top[x],fy = top[y];
                int ans = 0;
                while(fx ^ fy)
                {
                    if(d[fx] > d[fy])
                    {
                        ans += getsum(id[fx],id[x],root,1,n);
                        x = f[fx],fx = top[x];
                    }
                    else
                    {
                        ans += getsum(id[fy],id[y],root,1,n);
                        y = f[fy],fy = top[y];
                    }
                }
                if(d[x] > d[y])
                    swap(x,y);
                ans += getsum(id[x],id[y],root,1,n);
                printf("%d\n",ans);
            }
            else
            {
                int root = rt[w[x]];
                int fx = top[x],fy = top[y];
                int ans = -0x3f3f3f3f;
                while(fx ^ fy)
                {
                    if(d[fx] > d[fy])
                    {
                        ans = max(ans,getmax(id[fx],id[x],root,1,n));
                        x = f[fx],fx = top[x];
                    }
                    else
                    {
                        ans = max(ans,getmax(id[fy],id[y],root,1,n));
                        y = f[fy],fy = top[y];
                    }
                }
                if(d[x] > d[y])
                    swap(x,y);
                ans = max(ans,getmax(id[x],id[y],root,1,n));
                printf("%d\n",ans);
            }
        }
    }
}