#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<string>
#define line cout<<endl;
#define ran for(int i=1; i<=n; ++i)
#define ll long long
#define ull unsigned long long
#define dbg cout<<"ok"<<endl;
#define mod
#define N 200010
#define lson p<<1
#define rson p<<1|1

using namespace std;

string opt;
int n,m,cnt;
int fa[N],son[N],top[N],sz[N],d[N],dfn[N],b[N];
vector<int> g[N];
struct edge { int x,y,w; } e[N];
struct tree { int l,r,maxn,minn,sum,tag; } t[N*8];

void dfs1(int u,int f){
	fa[u] = f;
	sz[u] = 1;
	d[u] = d[f] + 1;
	for(int v:g[u])
	{
		if(v == f) continue;
		dfs1(v,u);
		sz[u] += sz[v];
		if(sz[v] > sz[son[u]])
			son[u] = v;
	}
}

void dfs2(int u,int f){
	top[u] = f;
	dfn[u] = ++cnt;
	if(son[u] == 0) return;
	dfs2(son[u],f);
	
	for(int v:g[u])
		if(v != fa[u] && v != son[u])
			dfs2(v,v);
}

inline void push_up(int p){
	t[p].maxn = max(t[lson].maxn, t[rson].maxn);
	t[p].minn = min(t[lson].minn, t[rson].minn);
	t[p].sum = t[lson].sum + t[rson].sum;
}

void build(int p,int l,int r){
	t[p].l = l; t[p].r = r; t[p].tag = 0;
	if(l == r) {
		t[p].maxn = t[p].minn = t[p].sum = b[l];
		return ;
	}
	int mid = (l+r) >> 1;
	build(lson,l,mid);
	build(rson,mid+1,r);
	push_up(p);
}

void push_down(int p){
	t[lson].maxn = -t[lson].maxn;
	t[lson].minn = -t[lson].minn;
	t[lson].sum = -t[lson].sum;
	t[lson].tag ^= 1;
	swap(t[lson].maxn, t[lson].minn);
	
	t[rson].maxn = -t[rson].maxn;
	t[rson].minn = -t[rson].minn;
	t[rson].sum = -t[rson].sum;
	t[rson].tag ^= 1;
	swap(t[rson].maxn, t[rson].minn);
	
	t[p].tag = 0;
}

void modify1(int p,int pos,int val){
	if(t[p].l == t[p].r){
		t[p].sum = t[p].maxn = t[p].minn = val;
		return ;
	}
	if(t[p].tag) push_down(p);
	int mid = (t[p].l + t[p].r) >> 1;
	if(pos <= mid) modify1(lson,pos,val);
	if(pos > mid) modify1(rson,pos,val);
	push_up(p);
}

void modify2(int p,int l,int r){
	if(l <= t[p].l && t[p].r <= r){
		t[p].tag ^= 1;
		t[p].maxn = -t[p].maxn;
		t[p].minn = -t[p].minn;
		t[p].sum = -t[p].sum;
		swap(t[p].maxn, t[p].minn);
		return ;
	}
	if(t[p].tag) push_down(p);
	int mid = (t[p].l + t[p].r) >> 1;
	if(l <= mid) modify2(lson,l,r);
	if(r > mid) modify2(rson,l,r);
	push_up(p);
}

int qsum(int p,int l,int r){
	if(l <= t[p].l && t[p].r <= r) return t[p].sum;
	if(t[p].tag) push_down(p);
	int mid = (t[p].l + t[p].r) >> 1, ans = 0;
	if(l <= mid) ans += qsum(lson,l,r);
	if(r > mid) ans += qsum(rson,l,r);
	push_up(p);
	return ans;
}

int qmax(int p,int l,int r){
	if(l <= t[p].l && t[p].r <= r) return t[p].maxn;
	if(t[p].tag) push_down(p);
	int mid = (t[p].l + t[p].r) >> 1, ans = -999999999;
	if(l <= mid) ans = max(qmax(lson,l,r), ans);
	if(r > mid) ans = max(qmax(rson,l,r), ans);
	push_up(p);
	return ans;
}

int qmin(int p,int l,int r){
	if(l <= t[p].l && t[p].l <= r) return t[p].minn;
	if(t[p].tag) push_down(p);
	int mid = (t[p].l + t[p].r) >> 1, ans = 999999999;
	if(l <= mid) ans = min(qmin(lson,l,r), ans);
	if(r > mid) ans = min(qmin(rson,l,r), ans);
	push_up(p);
	return ans;
}

void change(int u,int v){
	while(top[u] != top[v])
	{
		if(d[top[u]] < d[top[v]]) swap(u,v);
		modify2(1,dfn[top[u]],dfn[u]);
		u = fa[top[u]];
	}
	if(dfn[u] > dfn[v]) swap(u,v);
	if(u != v) modify2(1,dfn[u]+1,dfn[v]);
}

int ask(int u,int v,int type){
	int ans;
	if(type == 1) ans = 0; // sum
	if(type == 2) ans = -999999999; // max
	if(type == 3) ans = 999999999; // min
	
	while(top[u] != top[v])
	{
		if(d[top[u]] < d[top[v]]) swap(u,v);
		
		if(type == 1) ans += qsum(1,dfn[top[u]],dfn[u]);
		if(type == 2) ans = max(ans, qmax(1,dfn[top[u]],dfn[u]));
		if(type == 3) ans = min(ans, qmin(1,dfn[top[u]],dfn[u]));
		
		u = fa[top[u]];
	}
	
	if(dfn[u] > dfn[v]) swap(u,v);
	if(u != v)
	{
		if(type == 1) ans += qsum(1,dfn[u]+1,dfn[v]);
		if(type == 2) ans = max(ans, qmax(1,dfn[u]+1,dfn[v]));
		if(type == 3) ans = min(ans, qmin(1,dfn[u]+1,dfn[v]));
	}
	
	return ans;
}

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
	
	cin>>n;
	
	for(int i=1; i<n; ++i)
	{
		cin>>e[i].x>>e[i].y>>e[i].w;
		++e[i].x; ++e[i].y;
		g[e[i].x].push_back(e[i].y);
		g[e[i].y].push_back(e[i].x);
	}
	
	dfs1(1,0);
	dfs2(1,1);
	
	for(int i=1; i<n; ++i)
	{
		if(dfn[e[i].x] < dfn[e[i].y]) swap(e[i].x, e[i].y);
		b[dfn[e[i].x]] = e[i].w;
	}
	
	build(1,1,n); 
	 
	cin>>m;
	
	while(m--)
	{
		int x,y;
		opt = "";
		cin>>opt>>x>>y;
		if(opt == "C")
		{
			modify1(1,dfn[e[x].x],y);
		}
		else if(opt == "N")
		{
			++x; ++y;
			change(x,y);
		}
		else if(opt == "SUM")
		{
			++x; ++y; 
			cout<<ask(x,y,1)<<endl;
		}
		else if(opt == "MAX")
		{
			++x; ++y; 
			cout<<ask(x,y,2)<<endl;
		}
		else if(opt == "MIN")
		{
			++x; ++y;
			cout<<ask(x,y,3)<<endl;
		}
	}
	
    return 0;
}

RT，调了快一个下午了QAQ