#include <iostream>

#include <cstdio>

using namespace std;

const int N = 1e5 + ;

int top[N], fa[N], deep[N], size[N], son[N], tree[N], bef[N];

int head[N], W[N << ], F[N << ], Size[N << ];

int n, Ty, tim, now = ;

struct Node{int v, nxt;} G[N << ];

int Answer;

#define gc getchar()

inline int read() {

    int x = ; char c = gc;

    while(c < '' || c > '') c = gc;

    while(c >= '' && c <= '') x = x *  + c - '', c = gc;

    return x;

}

inline void Add(int u, int v) {G[now].v = v; G[now].nxt = head[u]; head[u] = now ++;}

void Dfs_1(int u, int dep, int f_) {

    deep[u] = dep; fa[u] = f_;

    size[u] = ;

    for(int i = head[u]; ~ i; i = G[i].nxt) {

        int v = G[i].v;

        if(v != f_) {

            Dfs_1(v, dep + , u);

            size[u] += size[v];

            if(size[v] > size[son[u]]) son[u] = v;

        }

    }

}

void Dfs_2(int u, int tp) {

    top[u] = tp;

    tree[u] = ++ tim;

    if(!son[u]) return ;

    Dfs_2(son[u], tp);

    for(int i = head[u]; ~ i; i = G[i].nxt) {

        int v = G[i].v;

        if(v != fa[u] && v != son[u]) Dfs_2(v, v);

    }

}

#define lson jd << 1

#define rson jd << 1 | 1

void Build_tree(int l, int r, int jd) {

    Size[jd] = r - l + ;

    if(l == r) {

        W[jd] = ;

        return ;

    }

    int mid = (l + r) >> ;

    Build_tree(l, mid, lson);

    Build_tree(mid + , r, rson);

    W[jd] = W[lson] + W[rson];

}

void Down(int jd) {

    int f = F[jd];

    W[lson] += Size[lson] * f; W[rson] += Size[rson] * f;

    F[lson] += f; F[rson] += f;

    F[jd] = ;

}

void Sec_G(int l, int r, int jd, int x, int y, int yj) {

    if(x <= l && r <= y) {W[jd] += (r - l + ) * yj; F[jd] += yj; return ;}

    if(F[jd]) Down(jd);

    int mid = (l + r) >> ;

    if(x <= mid) Sec_G(l, mid, lson, x, y, yj);

    if(y > mid)  Sec_G(mid + , r, rson, x, y, yj);

    W[jd] = W[lson] + W[rson];

}

inline void Sec_G_imp(int x, int y) {

    int tp1 = top[x], tp2 = top[y];

    while(tp1 != tp2) {

        if(deep[tp1] < deep[tp2]) swap(x, y), swap(tp1, tp2);

        Sec_G(, n, , tree[tp1], tree[x], -);

        x = fa[tp1];

        tp1 = top[x];

    }

    if(x == y) return ;

    if(deep[x] < deep[y]) swap(x, y);

    Sec_G(, n, , tree[y] + , tree[x], -);

}

void Sec_A(int l, int r, int jd, int x, int y) {

    if(x <= l && r <= y) {

        Answer += W[jd]; return ;

    }

    if(F[jd]) Down(jd);

    int mid = (l + r) >> ;

    if(x <= mid) Sec_A(l, mid, lson, x, y);

    if(y > mid)  Sec_A(mid + , r, rson, x, y);

}

inline int Sec_A_imp(int x) {

    int tp1 = top[x], ret = ;

    while(tp1 != ) {

        Answer = ;

        Sec_A(, n, , tree[tp1], tree[x]);

        ret += Answer;

        x = fa[tp1];

        tp1 = top[x];

    }

    if(x == ) return ret;

    Answer = ;

    Sec_A(, n, , tree[] + , tree[x]);

    ret += Answer;

    return ret;

}

int main() {

    n = read();

    for(int i = ; i <= n; i ++) head[i] = -;

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

        int u = read(), v = read();

        Add(u, v); Add(v, u);

    }

    Dfs_1(, , );

    Dfs_2(, );

    Build_tree(, n, );

    Ty = read();

    Ty = Ty + n - ;

    while(Ty --) {

        string opt;

        cin >> opt;

        if(opt[] == 'A') {

            int x = read(), y = read();

            Sec_G_imp(x, y);

        }

        else {

            int x = read();

            cout << Sec_A_imp(x) << "\n";

        }

    }

    return ;

}

/*

5

1 2

1 3

1 4

4 5

4

W 5

A 1 4

W 5

A 4 5

W 5

W 2

A 1 2

A 1 3

*/