#include <cstdio>
#include <algorithm>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
constexpr int MAXN = 1e5 + 5;
constexpr ll MAXR = 1e9 + 5;

vector<pii> g[MAXN];

namespace lca
{
int timer = 0, tin[MAXN], tout[MAXN];
ll dist[MAXN];
constexpr int LOGMAXN = 18;
int up[MAXN][LOGMAXN];
void dfs(int n, int p)
{
	tin[n] = timer++;
	up[n][0] = p;
	for (int i = 1; i < LOGMAXN; i++)
		up[n][i] = up[up[n][i - 1]][i - 1];
	for (const auto &[a, w] : g[n])
		if (a != p)
		{
			dist[a] = dist[n] + w;
			dfs(a, n);
		}
	tout[n] = timer++;
}
void init()
{
	dist[1] = 0;
	dfs(1, 1);
}
bool is_ancestor(int u, int v)
{
	return tin[u] <= tin[v] && tout[u] >= tout[v];
}
int lca(int u, int v)
{
	if (is_ancestor(u, v))
		return u;
	if (is_ancestor(v, u))
		return v;
	for (int i = LOGMAXN - 1; i >= 0; i--)
		if (!is_ancestor(up[u][i], v))
			u = up[u][i];
	return up[u][0];
}
ll getdist(int u, int v)
{
	return dist[u] + dist[v] - 2 * dist[lca(u, v)];
}
}    // namespace lca

namespace centroid
{
int treesize[MAXN];
bool used[MAXN];
int up[MAXN];
short depth[MAXN];
void dfs(int n, int p)
{
	treesize[n] = 1;
	for (const auto &[a, _] : g[n])
		if (a != p && !used[a])
		{
			dfs(a, n);
			treesize[n] += treesize[a];
		}
}
int centroid(int n, int p, int sz)
{
	for (const auto &[a, _] : g[n])
		if (a != p && !used[a] && treesize[a] > sz / 2)
			return centroid(a, n, sz);
	return n;
}
void decomposition(int n, int p, int dep)
{
	dfs(n, n);
	int c = centroid(n, n, treesize[n]);
	up[c] = p;
	used[c] = true;
	depth[c] = dep;
	for (const auto &[a, _] : g[c])
		if (!used[a])
			decomposition(a, c, dep + 1);
}
void init()
{
	decomposition(1, -1, 0);
}
}    // namespace centroid

struct FenwickTree
{
	vector<int> tree;
	void init(int n)
	{
		tree.assign(n + 1, 0);
	}
	void update(int p, int a)
	{
		p++;
		while (p < tree.size())
		{
			tree[p] += a;
			p += p & (-p);
		}
	}
	int query(int p)
	{
		int s = 0;
		p++;
		while (p > 0)
		{
			s += tree[p];
			p -= p & (-p);
		}
		return s;
	}
};

#define allvec(v) v.data(), v.data() + v.size()
struct QueryStuff
{
	vector<int> rs[MAXN];
	FenwickTree ft[MAXN];
	void addquery(int cn, int radius)
	{
		rs[cn].push_back(radius);
	}
	void init(int N)
	{
		for (int i = 1; i <= N; i++)
			if (rs[i].size() != 0)
			{
				vector<int> &r = rs[i];
				sort(allvec(r));
				int nsz = unique(allvec(r)) - r.data();
				r.resize(nsz);
				ft[i].init(nsz);
			}
	}
	void update(int cn, int radius)
	{
		if (rs[cn].size() == 0)
			return;
		int l = 0, r = rs[cn].size();
		while (l + 1 != r)
		{
			int m = (l + r) / 2;
			if (rs[cn][m] <= radius)
				l = m;
			else
				r = m;
		}
		ft[cn].update(l, 1);
	}
	int query(int cn, int minrad)
	{
		if (rs[cn].size() == 0)
			return 0;
		const auto getlt = [this, cn](int val) -> int
		{
			if (rs[cn][0] >= val)
				return 0;
			int l = 0, r = rs[cn].size();
			while (l + 1 != r)
			{
				int m = (l + r) / 2;
				if (rs[cn][m] < val)
					l = m;
				else
					r = m;
			}
			return ft[cn].query(l);
		};
		return getlt(MAXR) - getlt(minrad);
	}
};

QueryStuff qs, qb;

int main()
{
	int N;
	scanf("%d", &N);
	vector<pii> edges(N);
	for (int i = 0, u, v, w; i < N - 1; i++)
	{
		scanf("%d %d %d", &u, &v, &w);
		g[u].push_back({v, w});
		g[v].push_back({u, w});
		edges[i] = {u, v};
	}

	lca::init();
	centroid::init();

	int Q;
	scanf("%d", &Q);
	vector<pii> queries(Q);
	for (int i = 0; i < Q; i++)
	{
		char t[2];
		int a, b = -1;
		scanf("%s %d", t, &a);
		if (t[0] == '+')
			scanf("%d", &b);
		queries[i] = {a, b};
		if (t[0] == '+')
		{
			int prev;
			const int start = a;
			for (int cn = start; cn != -1; cn = centroid::up[cn])
			{
				const ll radius = b - lca::getdist(start, cn);
				if (radius > 0)
				{
					qs.addquery(cn, radius);
					if (cn != start)
						qb.addquery(prev, radius);
				}
				prev = cn;
			}
		}
	}

	qs.init(N);
	qb.init(N);
	for (const auto &[a, b] : queries)
		if (b == -1)
		{
			int ans = 0;
			const auto [v0, v1] = edges[a - 1];
			const int start = centroid::depth[v0] > centroid::depth[v1] ? v0 : v1;
			int prev;
			for (int cn = start; cn != -1; cn = centroid::up[cn])
			{
				const ll dist = max(lca::getdist(v0, cn), lca::getdist(v1, cn));
				if (dist < MAXR)
				{
					ans += qs.query(cn, dist);
					if (cn != start)
						ans -= qb.query(prev, dist);
				}
				prev = cn;
			}
			printf("%d\n", ans);
		}
		else
		{
			const int start = a;
			int prev;
			for (int cn = start; cn != -1; cn = centroid::up[cn])
			{
				const ll radius = b - lca::getdist(start, cn);
				if (radius > 0)
				{
					qs.update(cn, radius);
					if (cn != start)
						qb.update(prev, radius);
				}
				prev = cn;
			}
		}

	return 0;
}