#include<bits/stdc++.h>
#define rep(i,j,k) for(register int i(j);i!=(k+1);++i)
using namespace std;
const int N=2e5+79;
const int inf=0xfffffff;
inline void swap(int &a,int &b) {
	a==b? 1:a^=b^=a^=b;
}
inline int max(int &a,int &b){
	return a>b? a:b;
}
inline int min(int &a,int &b){
	return a<b? a:b;
}
namespace io {
	inline void read(int &x) {
		x=0;
		register char ch=getchar();
		int w=0;
		while(ch>'9'||ch<'0') {
			w|=ch=='-';
			ch=getchar();
		}
		while(ch>='0'&&ch<='9') {
			x=x*10+ch-48;
			ch=getchar();
		}
		w?x=~(x-1):x;
	}
	inline void out(int x) {
		if(x<0) x=-x,putchar('-');
		if(x==0) {
			putchar('0'),putchar('\n');
			return ;
		}
		if(x<10) {
			putchar(x+48);
			putchar('\n');
			return ;
		}
		char ch[50];
		int num(0);
		while(x) {
			ch[++num]=x%10+48;
			x/=10;
		}
		while(num) putchar(ch[num--]);
		putchar('\n');
	}
}
struct graph {
	int head[N<<1],next[N<<1],tot,ver[N<<1],edge[N<<1];
	inline void add(int a,int b,int c) {
		ver[++tot]=b;
		next[tot]=head[a];
		head[a]=tot;
		edge[tot]=c;
	}
} G;

int n,m;
int fa[N],dep[N],a[N],b[N],num;
int size[N],son[N],dfn[N],top[N];
inline void dfs1(int x,int fath) {
	dep[x]=dep[fath]+1;
	fa[x]=fath;
	size[x]=1;
	int maxson=-1;
	for(register int i(G.head[x]); i; i=G.next[i]) {
		int y(G.ver[i]);
		if(y==fath) continue;
		b[y]=G.edge[i];
		dfs1(y,x);
		size[x]+=size[y];
		if(size[y]>maxson) son[x]=y,maxson=size[y];
	}
}

inline void dfs2(int x,int topf) {
	dfn[x]=++num;
	a[num]=b[x];
	top[x]=topf;
	if(!son[x]) return;
	dfs2(son[x],topf);
	for(register int i(G.head[x]); i; i=G.next[i]) {
		int y(G.ver[i]);
		if(dfn[y]) continue;
		dfs2(y,y);
	}
}


struct Segmentree {
	int lc[N<<1],rc[N<<1],cnt,root,sum[N<<1];
	int minn[N<<1],maxx[N<<1],lazy[N<<1];
	inline void spread(int p) {
		if(!lazy[p]) return;
		if(lc[p]) {
			sum[lc[p]]=-sum[lc[p]];
			lazy[lc[p]]^=1;
			int t=maxx[lc[p]];
			maxx[lc[p]]=-minn[lc[p]];
			minn[lc[p]]=-t;
		}
		if(rc[p]) {
			sum[rc[p]]=-sum[rc[p]];
			lazy[rc[p]]^=1;
			int t=maxx[rc[p]];
			maxx[rc[p]]=-minn[rc[p]];
			minn[rc[p]]=-t;
		}
		lazy[p]=0;
	}
	inline void build(int &p,int L,int R) {
		if(!p) p=++cnt;
		if(L==R) {
			minn[p]=maxx[p]=sum[p]=a[L];
			return;
		}
		int mid((L+R)>>1);
		build(lc[p],L,mid);
		build(rc[p],mid+1,R);
		minn[p]=min(minn[lc[p]],minn[rc[p]]);
		sum[p]=sum[lc[p]]+sum[rc[p]];
		maxx[p]=max(maxx[lc[p]],maxx[rc[p]]);
	}
	inline void cchange(int p,int L,int R,int x,int v) {
		if(!p) p=++cnt;
		if(L==R) {
			minn[p]=maxx[p]=sum[p]=v;
			return;
		}
		int mid((L+R)>>1);
		if(x<=mid)cchange(lc[p],L,mid,x,v);
		else cchange(rc[p],mid+1,R,x,v);
		minn[p]=min(minn[lc[p]],minn[rc[p]]);
		sum[p]=sum[lc[p]]+sum[rc[p]];
		maxx[p]=max(maxx[lc[p]],maxx[rc[p]]);
	}
	inline int qsum(int p,int L,int R,int ll,int rr) {
		if(!p) return 0;
		if(ll<=L&&rr>=R)return sum[p];
		spread(p);
		int mid((L+R)>>1);
		int val(0);
		if(ll<=mid) val+=qsum(lc[p],L,mid,ll,rr);
		if(rr>mid) val+=qsum(rc[p],mid+1,R,ll,rr);
		return val;
	}
	inline void change(int p,int L,int R,int ll,int rr) {
		if(!p) return;
		if(ll<=L&&rr>=R) {
			lazy[p]^=1;
			sum[p]=-sum[p];
			int t=maxx[p];
			maxx[p]=-minn[p];
			minn[p]=-t;
			return;
		}
		spread(p);
		int mid((L+R)>>1);
		if(ll<=mid) change(lc[p],L,mid,ll,rr);
		if(rr>mid)change(rc[p],mid+1,R,ll,rr);
	}
	inline int qmax(int p,int L,int R,int ll,int rr) {
		if(!p) return -21474;
		if(ll<=L&&rr>=R)return maxx[p];
		spread(p);
		int mid((L+R)>>1);
		int val(-2145);
		if(ll<=mid) val=max(val,qmax(lc[p],L,mid,ll,rr));
		if(rr>mid) val=max(val,qmax(rc[p],mid+1,R,ll,rr));
		return val;
	}
	inline int qmin(int p,int L,int R,int ll,int rr) {
		if(!p) return 214745;
		if(ll<=L&&rr>=R)return minn[p];
		spread(p);
		int mid((L+R)>>1);
		int val(21145);
		if(ll<=mid) val=min(val,qmin(lc[p],L,mid,ll,rr));
		if(rr>mid) val=min(val,qmin(rc[p],mid+1,R,ll,rr));
		return val;
	}
} S;

inline int qcsum(int x,int y) {
	int ans(0);
	while(top[x]!=top[y]) {
		if(dep[top[x]]<dep[top[y]]) swap(x,y);
		ans+=S.qsum(S.root,1,n,dfn[top[x]],dfn[x]);
		x=fa[top[x]];
	}
	if(dep[x]>dep[y]) swap(x,y);
	ans+=S.qsum(S.root,1,n,dfn[x]+1,dfn[y]);
	return ans;
}

inline int qcmax(int x,int y) {
	int ans(-2144544);
	while(top[x]!=top[y]) {
		if(dep[top[x]]<dep[top[y]]) swap(x,y);
		ans=max(ans,S.qmax(S.root,1,n,dfn[top[x]],dfn[x]));
		x=fa[top[x]];
	}
	if(dep[x]>dep[y]) swap(x,y);
	ans=max(ans,S.qmax(S.root,1,n,dfn[x]+1,dfn[y]));
	return ans;
}

inline int qcmin(int x,int y) {
	int ans(2144544);
	while(top[x]!=top[y]) {
		if(dep[top[x]]<dep[top[y]]) swap(x,y);
		ans=min(ans,S.qmin(S.root,1,n,dfn[top[x]],dfn[x]));
		x=fa[top[x]];
	}
	if(dep[x]>dep[y]) swap(x,y);
	ans=min(ans,S.qmin(S.root,1,n,dfn[x]+1,dfn[y]));
	return ans;
}


int main() {
	using namespace io;
	read(n);
	int u,v,w;
	rep(i,1,n-1) {
		
		read(u);
		read(v);
		u++;
		v++;
		read(w);
		G.add(u,v,w);
		G.add(v,u,w);
	}
	dfs1(1,0);
	dfs2(1,1);
	S.build(S.root,1,n);
	read(m);
	string op;
	int x,y;
	while(m--) {
		cin>>op>>x>>y;
		x++;
		y++;
		if(op=="SUM") {
			out(qcsum(x,y));
		} else if(op=="MAX") {
			out(qcmax(x,y));
		} else if(op=="MIN") {
			out(qcmin(x,y));
		} else if(op=="N") {
			S.change(S.root,1,n,dfn[x],dfn[y]);
		}
		if(op=="C") {
			y--;
			S.cchange(S.root,1,n,dfn[x],y);
		}
	}
}

zzzz 好长啊~~~...