#include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
using namespace std;

using pii = pair<int, int>;
const int N = 200010, SZ = (1 << 18) + 5;
static char buf[SZ], *bgn = buf, *til = buf;
char getc() {
    if(bgn == til)  bgn = buf, til = buf + fread(buf, 1, SZ, stdin);
    return bgn == til ? EOF : *bgn++;
}
template<typename T>
void read(T &x) {
    char ch = getc();  T fh = 0;   x = 0;
    while(ch < '0' || ch > '9')    fh |= (ch == '-'), ch = getc();
    while(ch >= '0' && ch <= '9')   x = x * 10 + ch - '0', ch = getc();
    x = fh ? -x : x;
}
template<typename Type, typename... argc>
void read(Type &x, argc &...args)   {read(x), read(args...);}
template<typename T>
void print(T x) {
    if(x < 0)  putchar('-'), x = -x;
    if(x / 10)  print(x / 10);
    putchar(x % 10 + '0');
}
int n, q, u[N], v[N], d[N], fa[N], ans[N];
vector<int> edge[N];
struct clpf {
    vector<pii> ask[N]; // f
    int mson[N], top[N], dfn[N], cnt, dep[N], f[N];
    void dfs(int x) {
        for(int y : edge[x])    if(y != fa[x]) {
            dfs(y), dep[x] = max(dep[y] + 1, dep[x]);
            if(!mson[x] || dep[y] > dep[mson[x]])   mson[x] = y; 
        }
    }
    void dfs2(int x, int tp) {
        top[x] = tp, dfn[x] = ++cnt;
        if(mson[x]) dfs2(mson[x], tp);
        for(int y : edge[x])    if(y != fa[x] && y != mson[x])  dfs2(y, y);
    }
    void Dfs(int x) {
        if(mson[x]) Dfs(mson[x]), f[dfn[x]] = f[dfn[x] + 1] + 1;
        else    f[dfn[x]] = 1;
        for(int y : edge[x])    if(y != fa[x] && y != mson[x]) {
            Dfs(y), f[dfn[x]] += f[dfn[y]];
            for(int i = dep[y]; i >= 0; --i)    f[dfn[x] + i + 1] += f[dfn[y] + i];
        }
        // cerr << x << " : " << dfn[x] << " " << f[dfn[x]] << " " << mson[x] << "\n";
        for(auto [d, i] : ask[x]) {
            int tmp = f[dfn[x]] - (d + 1 <= dep[x] ? f[dfn[x] + d + 1] : 0);
            // cerr << "2 : " << x << " " << d << " " << tmp << " " << i << "\n";
            i > 0 ? ans[i] += tmp : ans[-i] -= tmp;
        }
    }
    void work() {
        dfs(1), dfs2(1, 1), Dfs(1);
        // for(int i = 1; i <= n; ++i) cerr << dep[i] << " ";
        // cerr << "\n";
    }
}tr2;  
struct dfz {
    vector<pii> ask[N]; // x's neighbours   
    int siz[N], vis[N], dep[N], root, tot, mn, mx, buc[N], nmx, tmp[N];
    void dfszx(int x, int fa) {
        siz[x] = 1;
        int res = 0;
        for(int y : edge[x])    if(y != fa && !vis[y])
            dfszx(y, x), siz[x] += siz[y], res = max(res, siz[y]);
        res = max(res, tot - siz[x]);
        if(res < mn)    mn = res, root = x;
    }
    void getroot(int x) {dfszx(x, 0), tot = siz[x], mn = N, dfszx(x, 0);}
    void add(int x, int fa, int op) {
        dep[x] = dep[fa] + 1, mx = max(mx, dep[x]), buc[dep[x]] += op;
        for(int y : edge[x])    if(y != fa && !vis[y])  add(y, x, op);
    }
    void dfs(int x, int fa, int op) {
        tmp[dep[x]] += op, nmx = max(nmx, dep[x]);
        for(int y : edge[x])    if(y != fa && !vis[y])  dfs(y, x, op);
    }
    void calc(int x, int fa) {
        for(auto [d, i] : ask[x]) {
            int ndep = d - (dep[x] - dep[root]), nw = ndep >= 0 ? buc[min(mx, dep[root] + ndep)] - tmp[min(nmx, dep[root] + ndep)] : 0;
            i > 0 ? ans[i] += nw : ans[-i] -= nw;
        }
        for(int y : edge[x])    if(y != fa && !vis[y])  calc(y, x);
    }
    void solve(int x) {
        vis[x] = 1, mx = 0, root = x, add(x, 0, 1);
        for(int i = dep[x] + 1; i <= mx; ++i)   buc[i] += buc[i - 1];
        for(auto [d, i] : ask[x])   i > 0 ? ans[i] += buc[min(mx, dep[x] + d)] : ans[-i] -= buc[min(mx, dep[x] + d)];
        for(int y : edge[x])    if(!vis[y]) {
            nmx = 0, dfs(y, x, 1);
            for(int i = dep[x] + 2; i <= nmx; ++i)  tmp[i] += tmp[i - 1];
            calc(y, x);
            for(int i = dep[x]; i <= nmx; ++i)  tmp[i] = 0;
        }
        for(int i = dep[x]; i <= mx; ++i)   buc[i] = 0;
        for(int y : edge[x])    if(!vis[y]) getroot(y), solve(root);
    }
    void work() {
        getroot(1), solve(root);
    }
}tr3;
struct zlpf {
    vector<pii> ask[N]; // g 1~x
    int siz[N], mson[N], top[N], dep[N], dfn[N], mxdfn[N], cnt, ord[N], buc[N];
    void dfs(int x, int fath) {
        siz[x] = 1, fa[x] = fath, dep[x] = dep[fath] + 1;
        for(int y : edge[x])
            if(y != fath) {
                dfs(y, x), siz[x] += siz[y];
                if(siz[y] > siz[mson[x]])   mson[x] = y;
            }
    }   
    void dfs2(int x, int tp) {
        top[x] = tp, dfn[x] = ++cnt, ord[cnt] = x;
        if(mson[x]) dfs2(mson[x], tp);
        for(int y : edge[x])    if(y != fa[x] && y != mson[x])  dfs2(y, y);
        mxdfn[x] = cnt;
    }
    int lca(int x, int y) {
        while(top[x] != top[y]) {
            if(dep[top[x]] < dep[top[y]])   swap(x, y);
            x = fa[top[x]];
        }
        return dfn[x] < dfn[y] ? x : y;
    }
    int jump(int x, int y) {
        int las = x;
        while(top[x] != top[y]) las = top[x], x = fa[top[x]];
        return x == y ? las : mson[y];
    }
    void work() {dfs(1, 0), dfs2(1, 1);}
    void solve(int x, int y, int id, int op = 1) {
        int las = 0;
        ask[x].pb({d[id], id}), ask[fa[y]].pb({d[id], -id});
        while(top[x] != top[y]) {
            tr2.ask[mson[x]].pb({d[id] - 1, id}), tr2.ask[las].pb({d[id] - 1, -id});
            las = top[x], x = fa[top[x]];
        }
        tr2.ask[mson[x]].pb({d[id] - 1, id}), tr2.ask[las].pb({d[id] - 1, -id});
        if(op)  tr3.ask[y].pb({d[id], id}), tr2.ask[y].pb({d[id], -id});
    }
    void dfs3(int x, int sum) {
        auto calc = [&](int op) -> void {
            buc[0] += op * siz[x], sum += op;
            for(int y : edge[x])    if(y != fa[x] && y != mson[x]) {
                for(int i = dfn[y]; i <= mxdfn[y]; ++i) buc[dep[ord[i]] - dep[x]] += siz[ord[i]] * op;
                sum += siz[y] * op;
            }
        };
        calc(1);
        for(auto [d, i] : ask[x]) {
            int tmp = sum - buc[d + 1];
            i > 0 ? ans[i] += tmp : ans[-i] -= tmp;
        }
        for(int y : edge[x])    if(y != fa[x])  dfs3(y, sum);
        calc(-1);
    }
}tr1;
int main() {
    #ifdef Kelly
        freopen("in.txt", "r", stdin);
        freopen("out.txt", "w", stdout);
        freopen("err.txt", "w", stderr);
    #endif
    read(n);
    for(int i = 1, u, v; i < n; ++i)  read(u, v), edge[u].pb(v), edge[v].pb(u);
    tr1.work();
    read(q);
    for(int i = 1; i <= q; ++i) {
        read(u[i], v[i], d[i]);
        if(tr1.dfn[u[i]] > tr1.dfn[v[i]])   swap(u[i], v[i]);
        int lca = tr1.lca(u[i], v[i]);
        if(d[i] == 0)   {ans[i] = tr1.dep[u[i]] + tr1.dep[v[i]] - tr1.dep[lca] * 2 + 1; continue;}
        if(lca == u[i]) tr1.solve(v[i], u[i], i);
        else {
            int x = tr1.jump(u[i], lca), y = tr1.jump(v[i], lca);
            tr1.solve(u[i], x, i, 0), tr1.solve(v[i], y, i, 0);
            tr3.ask[lca].pb({d[i], i}), tr2.ask[x].pb({d[i] - 1, -i}), tr2.ask[y].pb({d[i] - 1, -i});
        }
    }
    tr1.dfs3(1, 0), tr2.work(), tr3.work();
    for(int i = 1; i <= q; ++i) print(ans[i]), putchar('\n');
    return 0;
}