#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/detail/standard_policies.hpp>
using namespace __gnu_pbds;
using namespace std;
#define pb push_back
const int N = 100011;
int vst[N];
int tim = 0;
const int inf = 1e9 + 7;
struct E {
    int y, z, n;
} e[N * 2];
vector<int> vec[N];
int q[N][3];
int dep[N];
int blg[N], idx[N], son[N], siz[N], ans[N], x[N], y[N];
int l = 1;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
ordered_set mp, mps[N];

void get_size(int v, int fa = 0) {
    siz[v] = 1;
    son[v] = 0;
    int mx = -1;
    for(int p = idx[v]; p; p = e[p].n) {
        int y = e[p].y;
        if(y == fa) continue;
        get_size(y, v);
        siz[v] += siz[y];
        if(siz[y] > mx) {
            mx = siz[y];
            son[v] = y;
        }
    }
}
int get_root(int st) {
    get_size(st);
    int tot = siz[st];
    while(siz[son[st]] > tot / 2) {
        st = son[st];
    }
    return st;
}
void dfs(int v, int fa = 0) {
    for(int p = idx[v]; p; p = e[p].n) {
        int y = e[p].y;
        if(y == fa) continue;
        int z = e[p].z;
        dep[y] = min(inf, dep[v] + z);
        blg[y] = fa == 0 ? y : blg[v];
        dfs(y, v);
    }
}
void build(int x, int y, int z) {
    e[++l].y = y;
    e[l].z = z;
    e[l].n = idx[x];
    idx[x] = l;
}
void dvcq(int st, vector<int> qids) {
    int rt = get_root(st);
    //printf("st = %d, rt = %d, queries = %d, siz = %d\n", st, rt, qids.size(), siz[st]);
    dep[rt] = 0;
    dfs(rt);
    int cnt = 0;
    for(int id : qids) {
        if(q[id][0] == '+') {
            int v = q[id][1];
            int len = q[id][2];
            if(dep[v] <= len) {
                
                if(siz[st] == 2) {
                    cnt++;
                }else {
                    mp.insert(len - dep[v]);
                    if(v == rt) {

                    }else {
                        mps[blg[v]].insert(len - dep[v]);
                        vec[blg[v]].pb(id);
                    }
                }
            }else {
                if(siz[st] == 2) {
                    
                }else {
                    vec[blg[v]].pb(id);
                }
            }
        }else {
            if(siz[st] == 2) {
                ans[id] += cnt;
            }else {
                int eid = q[id][1];
                int x = ::x[eid];
                int y = ::y[eid];
                if(dep[x] < dep[y]) {
                    x = y;
                }
                ans[id] += mp.size() - mp.order_of_key(dep[x]);
                ans[id] -= mps[blg[x]].size() - mps[blg[x]].order_of_key(dep[x]);
                vec[blg[x]].pb(id);
            }
        }
    }
    if(siz[st] == 2) return;
    mp.clear();
    for(int p = idx[rt]; p; p = e[p].n) {
        int y = e[p].y;
        mps[y].clear();
    }
    for(int p = idx[rt]; p; p = e[p].n) {
        int y = e[p].y;
        int bak = idx[rt];
        int nxt = e[p].n;
        idx[rt] = p;
        e[p].n = 0;

        dvcq(y, move(vec[y]));
        idx[rt] = bak;
        e[p].n = nxt;
    }
}
int main() {
    int n, Q;
    scanf("%d", &n);
    for(int i = 0; i < n - 1; i++) {
        int x, y, z;
        scanf("%d%d%d", &x, &y, &z);
        build(x, y, z);
        build(y, x, z);
        ::x[i] = x;
        ::y[i] = y;
    }
    scanf("%d", &Q);
    vector<int> queries;
    for(int i = 0; i < Q; i++) {
        queries.pb(i);
        static char st[111];
        scanf("%s", st);
        q[i][0] = st[0];
        if(q[i][0] == '+') {
            scanf("%d%d", &q[i][1], &q[i][2]);
        }else {
            scanf("%d", &q[i][1]);
            q[i][1] -= 1;
        }
    }
    dvcq(1, queries);
    for(int i = 0; i < Q; i++) {
        if(q[i][0] == '?') {
            printf("%d\n", ans[i]);
        }
    }
}