#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")

#include <bits/stdc++.h>
using namespace std;

const int maxn = 100010, maxlg = 20;
struct edge {
    int to;
    long long val;
};
vector<edge> G[maxn];
vector<int> vec[maxn];
bool vis[maxn];
int build(int, int);
inline void insert(int, int);
inline int query(int);
void init(int);
int dep1[maxn];

int main() {
    int n;
    // n = 100000;
    scanf("%d", &n);
    static int U[maxn], V[maxn];
    for (int i = 1; i < n; i++) {
        int u, v;
        long long w;
        // u = i, v = i + 1, w = 1;
        scanf("%d %d %lld", &u, &v, &w);
        G[u].push_back({ v, w });
        G[v].push_back({ u, w });
        U[i] = u, V[i] = v;
    }
    build(1, 0);
    init(n);
    int q;
    // q = 100000;
    scanf("%d", &q);
    while (q--) {
        char ch = getchar();
        // ch = q & 1 ? '+' : '?';
        while (ch != '+' && ch != '?') ch = getchar();
        if (ch == '+') {
            int x, r;
            // x = 10, r = 9;
            scanf("%d %d", &x, &r);
            insert(x, r);
        } else {
            int y;
            // y = 1;
            scanf("%d", &y);
            printf("%d\n", query(dep1[U[y]] > dep1[V[y]] ? U[y] : V[y]));
        }
    }
    return 0;
}

int fa[maxn], dep[maxn];
long long dis[maxlg][maxn];

int build(const int u, const int d) {
    static int siz[maxn];
    function<void(int, int)> dfs = [&dfs, r = u](const int u, const int fa) {
        siz[u] = 1, vec[r].push_back(u);
        for (auto e : G[u])
            if (e.to != fa && !vis[e.to])
                dfs(e.to, u), siz[u] += siz[e.to];
        return;
    };
    dfs(u, 0);
    int r, val = vec[u].size();
    for (int i : vec[u]) {
        int cur = vec[u].size() - siz[i];
        for (auto e : G[i])
            if (siz[e.to] < siz[i])
                cur = max(cur, siz[e.to]);
        if (val > cur)
            r = i, val = cur;
    }
    if (r != u)
        vec[r] = vec[u], vec[u].clear();
    function<void(int, int)> dfs2 = [&dfs2, d](const int u, const int fa) {
        for (auto e : G[u])
            if (e.to != fa && !vis[e.to])
                dis[d][e.to] = dis[d][u] + e.val, dfs2(e.to, u);
        return;
    };
    vis[r] = true, dep[r] = d, dis[d][r] = 0, dfs2(r, 0);
    for (auto e : G[r])
        if (!vis[e.to])
            fa[build(e.to, d + 1)] = r;
    return r;
}

struct node {
    int ls, rs;
    int val;
};
node t[maxn << 9];
int r1[maxn], r2[maxn], Cnt;

void modify(int& u, const int l, const int r, const int p, const int val) {
    if (!u)
        u = ++Cnt;
    t[u].val += val;
    if (l == r)
        return;
    int mid = (l + r) >> 1;
    if (p <= mid)
        modify(t[u].ls, l, mid, p, val);
    else
        modify(t[u].rs, mid + 1, r, p, val);
    return;
}

int query(const int u, const int l, const int r, const int p) {
    if (!u || r < p)
        return 0;
    if (p <= l)
        return t[u].val;
    int mid = (l + r) >> 1;
    return query(t[u].ls, l, mid, p) + query(t[u].rs, mid + 1, r, p);
}

int fa1[maxn];
int lg[maxn], anc[maxlg][maxn];
long long dis1[maxn];

void dfs1(const int u) {
    anc[0][u] = fa1[u];
    for (int l = 1; l <= lg[dep1[u]]; l++) anc[l][u] = anc[l - 1][anc[l - 1][u]];
    for (auto e : G[u])
        if (e.to != fa1[u]) {
            fa1[e.to] = u, dep1[e.to] = dep1[u] + 1;
            dis1[e.to] = dis1[u] + e.val;
            dfs1(e.to);
        }
    return;
}

void init(const int n) {
    for (int i = 2; i <= n; i++) lg[i] = lg[i >> 1] + 1;
    dfs1(1);
    return;
}

const int lim = 1000000000;

int del[maxn];

inline void insert(int u, int x) {
    int v = u;
    for (int l = lg[dep1[u]]; l >= 0; l--)
        if (dis1[u] - dis1[anc[l][v]] <= x)
            v = anc[l][v];
    del[v]++;
    for (int d = dep[u], f = u, last = 0; d >= 0; d--, last = f, f = fa[f])
        if (dis[d][u] <= x) {
            modify(r1[f], 0, lim, x - dis[d][u], 1);
            if (last != 0)
                modify(r2[last], 0, lim, x - dis[d][u], 1);
        }
    return;
}

inline int query(int u) {
    int ret = 0;
    for (int d = dep[u], f = u, last = 0; d >= 0; d--, last = f, f = fa[f]) {
        if (dis[d][u] > lim)
            break;
        ret += query(r1[f], 0, lim, dis[d][u]);
        if (last != 0)
            ret -= query(r2[last], 0, lim, dis[d][u]);
    }
    return ret - del[u];
}