#include <iostream>
#include <cstring>

using namespace std;

const int N = 800010, M = N << 1;
const int INF = 1e9;

struct Segment_Tree_Node
{
    int l, r;
    int sum, min, max;
    int mul;
}tr[M << 2];

int n, m; char op[10];
int h[N], e[M], ne[M], idx;
int dfn[N], id[N], ts, w[M], nw[M];
int dep[N], fa[N], son[N], top[N], siz[N];

inline void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void dfs1(int u, int f, int d)
{
    dep[u] = d, fa[u] = f, siz[u] = 1;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j == f) continue;
        dfs1(j, u, d + 1);
        siz[u] += siz[j];
        if (siz[j] > siz[son[u]]) son[u] = j;
    }
}

void dfs2(int u, int t)
{
    dfn[u] = ++ ts, id[ts] = u, nw[ts] = w[u], top[u] = t;
    if (!son[u]) return;
    dfs2(son[u], t);
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j == fa[u] || j == son[u]) continue;
        dfs2(j, j);
    }
}

inline void pushup(int u)
{
    tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
    tr[u].max = max(tr[u << 1].max, tr[u << 1 | 1].max);
    tr[u].min = min(tr[u << 1].min, tr[u << 1 | 1].min);
}

inline void pushdown(int u)
{
	if (tr[u].mul == 1) return;
	if (u == 1)
	{
		tr[u << 1 | 1].sum *= tr[u].mul, tr[u << 1 | 1].mul *= tr[u].mul;
		tr[u << 1 | 1].max *= tr[u].mul, tr[u << 1 | 1].min *= tr[u].mul;
		swap(tr[u << 1 | 1].min, tr[u << 1 | 1].max);
		return;
	}
    tr[u << 1].sum *= tr[u].mul, tr[u << 1].mul *= tr[u].mul;
    tr[u << 1 | 1].sum *= tr[u].mul, tr[u << 1 | 1].mul *= tr[u].mul;
    tr[u << 1].max *= tr[u].mul, tr[u << 1 | 1].max *= tr[u].mul;
    tr[u << 1].min *= tr[u].mul, tr[u << 1 | 1].min *= tr[u].mul;
    tr[u].mul = 1, swap(tr[u << 1].min, tr[u << 1].max);
    swap(tr[u << 1 | 1].min, tr[u << 1 | 1].max);
}

void build(int u, int l, int r)
{
    if (l == r)
    {
    	if (id[l] <= n) tr[u] = {l, r, 0, INF, -INF, 1};
    	else tr[u] = {l, r, nw[l], nw[l], nw[l], 1};
    }
    else
    {
        tr[u] = {l, r, 0, 0, 0, 1};
        int mid = (l + r) >> 1;
        build(u << 1, l, mid);
        build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void modify_edge(int u, int x, int v)
{
    if (tr[u].l == tr[u].r)
    	tr[u].sum = tr[u].min = tr[u].max = v;
    else
    {
    	pushdown(u);
        int mid = (tr[u].l + tr[u].r) >> 1;
        if (x <= mid) modify_edge(u << 1, x, v);
        else modify_edge(u << 1 | 1, x, v);
        pushup(u);
    }
}

void modify(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r)
    {
    	tr[u].sum *= -1, tr[u].mul *= -1;
    	tr[u].min *= -1, tr[u].max *= -1;
    	swap(tr[u].min, tr[u].max);
    }
    else
    {
        pushdown(u);
        int mid = (tr[u].l + tr[u].r) >> 1;
        if (l <= mid) modify(u << 1, l, r);
        if (r > mid) modify(u << 1 | 1, l, r);
        pushup(u);
    }
}

void modify_path(int u, int v)
{
    while (top[u] != top[v])
    {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        modify(1, dfn[top[u]], dfn[u]);
        u = fa[top[u]];
    }
    if (dep[u] < dep[v]) swap(u, v);
    modify(1, dfn[v], dfn[u]);
}

int query_sum(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].sum;
    else
    {
        pushdown(u);
        int mid = (tr[u].l + tr[u].r) >> 1, res = 0;
        if (l <= mid) res += query_sum(u << 1, l, r);
        if (r > mid) res += query_sum(u << 1 | 1, l, r);
        return res;
    }
}

inline int query_path_sum(int u, int v)
{
    int res = 0;
    while (top[u] != top[v])
    {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        res += query_sum(1, dfn[top[u]], dfn[u]);
        u = fa[top[u]];
    }
    if (dep[u] < dep[v]) swap(u, v);
    res += query_sum(1, dfn[v], dfn[u]);
    return res;
}

int query_max(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].max;
    else
    {
        pushdown(u);
        int mid = (tr[u].l + tr[u].r) >> 1, res = -INF;
        if (l <= mid) res = max(res, query_max(u << 1, l, r));
        if (r > mid) res = max(res, query_max(u << 1 | 1, l, r));
        return res;
    }
}

inline int query_path_max(int u, int v)
{
    int res = -INF;
    while (top[u] != top[v])
    {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        res = max(res, query_max(1, dfn[top[u]], dfn[u]));
        u = fa[top[u]];
    }
    if (dep[u] < dep[v]) swap(u, v);
    res = max(res, query_max(1, dfn[v], dfn[u]));
    return res;
}

int query_min(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].min;
    else
    {
        pushdown(u);
        int mid = (tr[u].l + tr[u].r) >> 1, res = INF;
        if (l <= mid) res = min(res, query_min(u << 1, l, r));
        if (r > mid) res = min(res, query_min(u << 1 | 1, l, r));
        return res;
    }
}

inline int query_path_min(int u, int v)
{
    int res = INF;
    while (top[u] != top[v])
    {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        res = min(res, query_min(1, dfn[top[u]], dfn[u]));
        u = fa[top[u]];
    }
    if (dep[u] < dep[v]) swap(u, v);
    res = min(res, query_min(1, dfn[v], dfn[u]));
    return res;
}

int main()
{
    int a, b, c;
    memset(h, -1, sizeof h);

    scanf("%d", &n);
    for (int i = 1; i < n; i ++ )
    {
        int x = n + i;
        scanf("%d%d%d", &a, &b, &c);
        a ++ , b ++ , w[x] = c;
        add(a, x), add(x, b), add(b, x), add(x, a);
    }

    dfs1(1, 0, 1);
    dfs2(1, 1);
    build(1, 1, ts);

    scanf("%d", &m);
    while (m -- )
    {
        scanf("%s%d%d", op, &a, &b);
        if (*op != 'C') a ++ , b ++ ;
        if (*op == 'C') modify_edge(1, dfn[n + a], b);
        else if (*op == 'N') modify_path(a, b);
        else if (*op == 'S') printf("%d\n", query_path_sum(a, b));
        else if (op[1] == 'A') printf("%d\n", query_path_max(a, b));
        else if (op[1] == 'I') printf("%d\n", query_path_min(a, b));
    }

    return 0;
}