/*+Rainybunny+*/

#include <bits/stdc++.h>

#define rep(i, l, r) for (int i = l, rep##i = r; i <= rep##i; ++i)
#define per(i, r, l) for (int i = r, per##i = l; i >= per##i; --i)

typedef std::pair<int, int> PII;
#define fi first
#define se second

inline char fgc() {
    static char buf[1 << 17], *p = buf, *q = buf;
    return p == q && (q = buf + fread(p = buf, 1, 1 << 17, stdin), p == q)
    ? EOF : *p++;
}

template <typename Tp = int>
inline Tp rint() {
    Tp x = 0, s = fgc(), f = 1;
    for (; s < '0' || '9' < s; s = fgc()) f = s == '-' ? -f : f;
    for (; '0' <= s && s <= '9'; s = fgc()) x = x * 10 + (s ^ '0');
    return x * f;
}

template <typename Tp>
inline void wint(Tp x) {
    if (x < 0) putchar('-'), x = -x;
    if (9 < x) wint(x / 10);
    putchar(x % 10 ^ '0');
}

const int MAXN = 2e5;
int n, q, fa[MAXN + 5], rad[MAXN + 5], ans[MAXN + 5];
std::vector<int> adj[MAXN + 5];

namespace V {

int dep[MAXN + 5], rt[MAXN + 5], siz[MAXN + 5], son[MAXN + 5], top[MAXN + 5];
struct Query { int r, k, id; };
std::vector<Query> qry[MAXN + 5];

struct SegmentTree {
    static const int MAXND = 4e6; // !
    int node, ch[MAXND][2], siz[MAXND];

    inline void insert(int& u, const int l, const int r, const int x) {
        if (!u) u = ++node;
        ++siz[u];
        if (l == r) return ;
        int mid = l + r >> 1;
        if (x <= mid) insert(ch[u][0], l, mid, x);
        else insert(ch[u][1], mid + 1, r, x);
    }

    inline int merge(const int u, const int v) {
        if (!u || !v) return u | v;
        int w = ++node; siz[w] = siz[u] + siz[v];
        ch[w][0] = merge(ch[u][0], ch[v][0]);
        ch[w][1] = merge(ch[u][1], ch[v][1]);
        return w;
    }

    inline int query(const int u, const int l, const int r,
    const int ql, const int qr) const {
        if (!u) return 0;
        if (ql <= l && r <= qr) return siz[u];
        int mid = l + r >> 1, ret = 0;
        if (ql <= mid) ret += query(ch[u][0], l, mid, ql, qr);
        if (mid < qr) ret += query(ch[u][1], mid + 1, r, ql, qr);
        return ret;
    }
} sgt;

inline void init(const int u) {
    siz[u] = 1, dep[u] = dep[fa[u]] + 1;
    sgt.insert(rt[u], 1, n, dep[u]);
    for (int v: adj[u]) if (v != fa[u]) {
        fa[v] = u, init(v), siz[u] += siz[v];
        if (siz[v] > siz[son[u]]) son[u] = v;
        rt[u] = sgt.merge(rt[u], rt[v]);
    }
}

inline void reorder(const int u, const int tp) {
    top[u] = tp;
    if (son[u]) reorder(son[u], tp);
    for (int v: adj[u]) if (v != fa[u] && v != son[u]) reorder(v, v);
}

inline int lca(int u, int v) {
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]]) v = fa[top[v]];
        else u = fa[top[u]];
    }
    return dep[u] < dep[v] ? u : v;
}

inline void hang(int u, const int k, const int id) {
    int las = 0;
    while (u) {
        qry[u].push_back({ rad[id], k, id });
        if (son[u] && rad[id]) {
            ans[id] += k * sgt.query(rt[son[u]], 1, n,
            dep[son[u]], dep[son[u]] + rad[id] - 1);
        }
        if (las && rad[id]) {
            ans[id] -= k * sgt.query(rt[las], 1, n,
            dep[las], dep[las] + rad[id] - 1);
        }
        u = fa[las = top[u]];
    }
}

struct BIT {
    int val[MAXN + 5];
    inline void add(int x, const int k) {
        for (; x <= n; x += x & -x) val[x] += k;
    }
    inline int sum(int x) {
        int ret = 0;
        for (; x; x ^= x & -x) ret += val[x];
        return ret;
    }
} bit;

inline void collect(const int u, const int d, const int k) {
    bit.add(d, k);
    for (int v: adj[u]) if (v != fa[u]) collect(v, d + 1, k);
}

inline void solve(const int u) {
    bit.add(1, 1);
    for (int v: adj[u]) if (v != fa[u] && v != son[u]) collect(v, 2, 1);

    for (auto [r, k, id]: qry[u]) ans[id] += k * bit.sum(r);
    if (son[u]) solve(son[u]);

    bit.add(1, -1);
    for (int v: adj[u]) if (v != fa[u] && v != son[u]) collect(v, 2, -1);
}

} // namespace V

namespace R {

int siz[MAXN + 5], wgt[MAXN + 5], mxh, suh, sum[MAXN + 5], sub[MAXN + 5];
bool vis[MAXN + 5];
std::vector<int> qry[MAXN + 5];

inline void findG(const int u, const int fa, const int all, int& rt) {
    siz[u] = 1, wgt[u] = 0;
    for (int v: adj[u]) if (v != fa && !vis[v]) {
        findG(v, u, all, rt), siz[u] += siz[v];
        wgt[u] = std::max(wgt[u], siz[v]);
    }
    wgt[u] = std::max(wgt[u], all - siz[u]);
    if (!rt || wgt[rt] > wgt[u]) rt = u;
}

inline void collect(const int u, const int fa, int* buc, int& h, const int d) {
    ++buc[d], h = std::max(h, d);
    for (int v: adj[u]) if (v != fa && !vis[v]) collect(v, u, buc, h, d + 1);
}

inline void contri(const int u, const int fa, const int d) {
    for (int id: qry[u]) if (rad[id] >= d) {
        ans[id] += sum[std::min(rad[id] - d, mxh)];
        ans[id] -= sub[std::min(rad[id] - d, suh)];
    }
    for (int v: adj[u]) if (v != fa && !vis[v]) contri(v, u, d + 1);
}

inline void solve(const int u) {
    vis[u] = true;

    collect(u, 0, sum, mxh = 0, 0);
    rep (i, 1, mxh) sum[i] += sum[i - 1];
    for (int id: qry[u]) ans[id] += sum[std::min(rad[id], mxh)];
    for (int v: adj[u]) if (!vis[v]) {
        collect(v, 0, sub, suh = 0, 1);
        rep (i, 1, suh) sub[i] += sub[i - 1];
        contri(v, 0, 1), memset(sub, 0, suh + 1 << 2);
    }
    memset(sum, 0, mxh + 1 << 2);

    for (int v: adj[u]) if (!vis[v]) {
        int rt = 0;
        findG(v, 0, siz[v], rt), solve(rt);
    }
}

} // namespace R

int main() {
    n = rint();
    rep (i, 2, n) {
        int u = rint(), v = rint();
        adj[u].push_back(v), adj[v].push_back(u);
    }

    V::init(1), V::reorder(1, 1);

    q = rint();
    rep (i, 1, q) {
        int u = rint(), v = rint(), w = V::lca(u, v); rad[i] = rint();
        V::hang(u, 1, i), V::hang(v, 1, i), V::hang(w, -2, i);
        R::qry[w].push_back(i);
    }

    int rt = 0; R::findG(1, 0, n, rt), R::solve(rt);
    // rep (i, 1, q) wint(ans[i]), putchar("\n "[i < q]);
    rep (u, 1, n) if (u == V::top[u]) V::solve(u);
    rep (i, 1, q) wint(ans[i]), putchar('\n');
    return 0;
}