#include <queue>

#include <vector>

#include <cstdio>

#include <cstring>

#include <iostream>

#include <algorithm>

using namespace std;

extern inline char gc() {

    static char RR[], *S = RR + , *T = RR + ;

    if(S == T) fread(RR, , , stdin), S = RR;

    return *S ++;

}

inline int read() {

    int p = , w = ; char c = gc();

    while(c > '' || c < '') { if(c == '-') w = -; c = gc(); }

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

    return p * w;

}

#define sid 100050

#define eid 200050

#define ri register int

const int inf = 1e9;

struct heap {

    priority_queue <int> f, g;

    inline void ins(int v) { if(v != -inf) f.push(v); }

    inline void era(int v) { if(v != -inf) g.push(v); }

    inline int top() {

        while() {

            if(f.empty()) return -inf;

            if(g.empty()) return f.top();

            if(f.top() == g.top()) f.pop(), g.pop();

            else return f.top();

        }

    }

} h[sid], ans;

int n, m, wn, cnp;

int cap[sid], nxt[eid], node[eid], fee[eid];

inline void addeg(int u, int v, int w) {

    nxt[++ cnp] = cap[u]; cap[u] = cnp; node[cnp] = v; fee[cnp] = w;

    nxt[++ cnp] = cap[v]; cap[v] = cnp; node[cnp] = u; fee[cnp] = w;

}

#define cur node[i]

int sz[sid], pre[sid], fa[sid], dep[sid];

inline void dfs(int o) {

    sz[o] = ;

    for(int i = cap[o]; i; i = nxt[i])

    if(cur != fa[o]) {

        fa[cur] = o; dep[cur] = dep[o] + fee[i]; dfs(cur);

        sz[o] += sz[cur]; if(sz[cur] > sz[pre[o]]) pre[o] = cur;

    }

}

int id, onp, col[sid];

int anc[sid], len[sid], dfn[sid], ord[sid];

inline void dfs(int o, int tp) {

    dfn[o] = ++ id; anc[o] = tp; ord[id] = o; len[tp] ++;

    if(!pre[o]) return; dfs(pre[o], tp);

    for(int i = cap[o]; i; i = nxt[i])

    if(cur != fa[o] && cur != pre[o]) dfs(cur, cur);

}

int tnp, rt[sid];

struct seg { int l, r, v, ls, rs; } t[sid * ];

#define dis(x) dep[ord[x]]

inline void upd(int o, int l, int r) {

    int ls = t[o].ls, rs = t[o].rs, mid = (l + r) >> ;

    t[o].l = max(t[ls].l, t[rs].l + dis(mid + ) - dis(l));

    t[o].r = max(t[rs].r, t[ls].r + dis(r) - dis(mid));

    t[o].v = max(max(t[ls].v, t[rs].v), t[ls].r + t[rs].l + dis(mid + ) - dis(mid));

}

inline void build(int &o, int l, int r) {

    if(!o) o = ++ onp;

    if(l == r) {

        int x = ord[l];

        for(ri i = cap[x]; i; i = nxt[i])

        if(cur != fa[x] && cur != pre[x]) h[x].ins(t[rt[cur]].l + dep[cur] - dep[x]);

        int d1 = h[x].top(); h[x].era(d1); int d2 = h[x].top(); h[x].ins(d1);

        t[o].l = t[o].r = max(d1, ); t[o].v = max(, max(d1, d1 + d2));

        return;

    }

    int mid = (l + r) >> ;

    build(t[o].ls, l, mid);

    build(t[o].rs, mid + , r);

    upd(o, l, r);

}

inline void mdf(int o, int l, int r, int v, int s) {

    if(l == r) {

        if(v == s) {

            int d1 = h[v].top(); h[v].era(d1); int d2 = h[v].top(); h[v].ins(d1);

            if(col[v]) t[o].l = t[o].r = d1, t[o].v = d1 + d2;

            else t[o].l = t[o].r = max(d1, ), t[o].v = max(, max(d1, d1 + d2));

        }

        else {

            h[v].ins(t[rt[s]].l + dep[s] - dep[v]);

            int d1 = h[v].top(); h[v].era(d1); int d2 = h[v].top(); h[v].ins(d1);

            if(col[v]) t[o].l = t[o].r = d1, t[o].v = d1 + d2;

            else t[o].l = t[o].r = max(d1, ), t[o].v = max(, max(d1, d1 + d2));

        }

        return;

    }

    int mid = (l + r) >> ;

    if(dfn[v] <= mid) mdf(t[o].ls, l, mid, v, s);

    else mdf(t[o].rs, mid + , r, v, s);

    upd(o, l, r);

}

int main() {

    wn = n = read();

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

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

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

    }

    dfs(); dfs(, ); ans.ins();

    for(ri i = n; i; i --) {

        int o = ord[i]; if(o != anc[o]) continue;

        build(rt[o], dfn[o], dfn[o] + len[o] - );

        ans.ins(t[rt[o]].v);

    }

    m = read(); char opt = ;

    for(ri i = ; i <= m; i ++) {

        opt = gc();

        while(opt != 'C' && opt != 'A') opt = gc();

        if(opt == 'C') {

            int x = read(); col[x] ^= ;

            if(col[x] == ) wn ++; else wn --;

            for(ri o = x, p = o; o; o = fa[o]) {

                int f = anc[o];

                int p1 = t[rt[f]].v, d1 = t[rt[f]].l;

                if(fa[f]) h[fa[f]].era(t[rt[f]].l + dep[f] - dep[fa[f]]);

                mdf(rt[f], dfn[f], dfn[f] + len[f] - , o, p);

                int p2 = t[rt[f]].v, d2 = t[rt[f]].l;

                if(p1 != p2) ans.era(p1), ans.ins(p2);

                p = o = f;

            }

        }

        else {

            if(wn == ) printf("They have disappeared.\n");

            else printf("%d\n", ans.top());

        }

    }

    return ;

}