（样例过了）

#include<bits/stdc++.h>
using namespace std;
#define reg register
extern "C" {
namespace io{
#define BUFS 100000
	static char in[BUFS], *p = in, *pp = in;
#define gc() (p == pp && (pp = (p = in) + fread(in, 1, BUFS, stdin), p == pp) ? EOF : *p++)
	inline char gtc() {while (isspace(*p)) ++p; return *p++;}
	inline int read() {
		reg int x = 0; reg char ch, f = 0;
		while (!isdigit(ch = gc())) f |= ch == '-';
		while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = gc();
		return f ? -x : x;
	}
}}
#define rd io :: read
const int N = 200001, inf = 0x3f3f3f3f;
int n, tot, head[N], ans = -inf;
struct Edge{int v, w, nxt;} eg[N << 1];
inline void addedge(int u, int v, int w) {
	eg[++tot] = Edge{v, w, head[u]}, head[u] = tot;
}
inline int fir(multiset<int>&s) {return s.size() ? *s.rbegin() : -inf;}
inline int sec(multiset<int>&s) {return s.size() > 1 ? *(++s.rbegin()) : -inf;}
multiset<int> chn[N], pth[N];
struct Node {
	int val, col, umx, dmx, dmt, sum, len;
	Node *fa, *ch[2];
	Node();
}spl[N], *null = spl;
Node :: Node() {fa = ch[0] = ch[1] = spl, umx = dmx = dmt = -inf;}
inline bool nroot(Node *x) {return x -> fa -> ch[0] == x || x -> fa -> ch[1] == x;}
inline void pushup(Node *x) {
	int vir = max(x -> val, fir(chn[x - spl])),
	L = max(vir, x -> ch[0] -> dmx + x -> len),
	R = max(vir, x -> ch[1] -> umx);
	x -> umx = max(x -> ch[0] -> umx, x -> ch[0] -> sum + x -> len + R),
	x -> dmx = max(x -> ch[1] -> dmx, x -> ch[1] ->sum + L),
	x -> dmt = max(x -> ch[0] -> dmx + x -> len + R, x -> ch[1] -> umx + L);
	x -> dmt = max(x -> dmt, max(x -> ch[0] -> dmt, x -> ch[1] -> dmt)),
	x -> dmt = max(x -> dmt, fir(pth[x - spl])),
	x -> dmt = max(x -> dmt, fir(chn[x - spl]) + sec(chn[x - spl])),
	x -> val || (x -> dmt = max(x -> dmt, max(fir(chn[x - spl]), 0)));
}
inline void rotate(Node *x) {
	reg Node *y = x -> fa, *z = y -> fa; reg int k = y -> ch[1] == x;
	nroot(y) && (z -> ch[z -> ch[1] == y] = x, 0), x -> fa =z;
	y -> ch[k] = x -> ch[k ^ 1], x -> ch[k ^ 1] -> fa = y;
	x -> ch[k ^ 1] = y, y -> fa = x;
	pushup(y), pushup(x);
}
inline void splay(Node *x) {
	for (reg Node *y, *z; nroot(x); rotate(x))
		y = x -> fa, z = y -> fa,
		nroot(y) && (rotate((z -> ch[0] == y) ^ (y -> ch[0] == x)? x : y), 0);
}
inline void access(Node *x) {
	for (reg Node *y = null; x != null; y = x, x = x -> fa)
		splay(x),
		x -> ch[1] != null && (pth[x - spl].insert(x -> ch[1] -> dmt), chn[x - spl].insert(x -> ch[1] -> umx), 0),
		y != null && (pth[x - spl].erase(pth[x - spl].find(y -> dmt)), chn[x - spl].erase(chn[x - spl].find(y -> umx)), 0),
		x -> ch[1] = y, pushup(x);
}
inline void modify(Node *x) {
	access(x), splay(x);
	x -> col ^= 1, x -> val = x -> col ? -inf : 0;
	pushup(x), ans = x -> dmt;
}
void dfs(int x, int Fa) {
	(spl + x) -> fa = spl + Fa;
	for (reg int i = head[x], v; i; i = eg[i].nxt)
		(v = eg[i].v) != Fa && (
			(spl + v) -> len = eg[i].w,
			dfs(v, x),
			chn[x].insert((spl + v) -> umx), pth[x].insert((spl + v) -> dmt), 0
		);
	pushup(spl + x);
}
int main() {
	n = rd();
	for (reg int i = 1, u, v, w; i < n; ++i)
		u = rd(), v = rd(), w = rd(),
		addedge(u, v, w), addedge(v, u, w);
	dfs(1, 0);
	ans = (spl + 1) -> dmt;
	for (reg int q = rd(); q; --q) {
		char op; int x;
		op = io :: gtc();
		op == 'A' ? ans < 0 ? puts("They have disappeared."), 0 : printf("%d\n", ans) : (x = rd(), modify(spl + x), 0);
	}
	return 0;
}