#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int MAXN = (int)2e5+5;

int n; vector<int> G[MAXN];

namespace LCA{
    const int stp = 17;
    int fa[MAXN][stp+1], dep[MAXN];

    void dfs_build(int x) {
        dep[x] ++;
        for (int i = 1; i <= stp; i++) {
            fa[x][i] = fa[fa[x][i-1]][i-1];
        }
        for (int to : G[x]) {
            if (to == fa[x][0]) continue;
            dep[to] = dep[x];
            fa[to][0] = x;
            dfs_build(to);
        }
    }

    int lca(int x, int y) {
        if (dep[x] < dep[y]) swap(x, y);
        for (int i = stp; i >= 0; i--) {
            if (dep[fa[x][i]] >= dep[y]) {
                x = fa[x][i];
            }
        }
        if (x == y) return x;
        for (int i = stp; i >= 0; i--) {
            if (fa[x][i] != fa[y][i]) {
                x = fa[x][i];
                y = fa[y][i];
            }
        }
        return fa[x][0];
    }

    int dist(int x, int y) {
        return dep[x]+dep[y]-2*dep[lca(x,y)];
    }
}

int m, ans[MAXN];
struct qr{ int d, k; int i;   }; 
vector<qr> qsf[MAXN], qf[MAXN], qg[MAXN];

namespace TSG{
    int fa[MAXN], hson[MAXN], dep[MAXN], siz[MAXN];
    void dfs1(int x) {
        dep[x] ++; siz[x] = 1;
        for (int to : G[x]) {
            if (to == fa[x]) continue;
            fa[to] = x; dep[to] = dep[x];
            dfs1(to);
            siz[x] += siz[to];
            if (siz[to] > siz[hson[x]]) {
                hson[x] = to;
            }
        }
    }

    int top[MAXN];
    void dfs2(int x, int tp) {
        top[x] = tp;
        for (int to : G[x]) {
            if (to == fa[x]) continue;
            dfs2(to, (to==hson[x]?tp:to));
        }
    }

    void addRF(int x, int d, int k, int i) {
        ans[i] += LCA::dep[x];
        qg[x].push_back({d, k, i});
        if (d == 0) return;

        if (hson[x] && d)
            qf[hson[x]].push_back({d-1, k, i});
        while (1) {
            x = top[x];
            if (x == 1) break;
            qf[x].push_back({d-1, -k, i});
            qf[hson[fa[x]]].push_back({d-1, k, i});
            x = fa[x];
        }
    }
}

void init() {
    cin >> n;
    for (int i = 1, u, v; i < n; i++) {
        cin >> u >> v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
}

void addSF(int x, int d, int k, int i) {
    qsf[x].push_back({d, k, i});
}

void dealqry() {
    cin >> m;
    for (int i = 1, u, v, d, t; i <= m; i++) {
        cin >> u >> v >> d;
        t = LCA::lca(u, v);
        TSG::addRF(u, d, 1, i);
        TSG::addRF(v, d, 1, i);
        TSG::addRF(t, d, -2, i);
        addSF(t, d, 1, i);
    }
}

namespace getf{
    const int MAXL = MAXN*20*2;
    int rt[MAXN];
    int sum[MAXL], lc[MAXL], rc[MAXL], pt;

    void modify(int p, int l, int r, int x, int v) {
        sum[p] += v;
        if (l == r) return;
        int mid = l + r >> 1;
        if (x <= mid) {
            if (!lc[p]) lc[p] = ++pt;
            modify(lc[p], l, mid, x, v);
        } else {
            if (!rc[p]) rc[p] = ++pt;
            modify(rc[p], mid+1, r, x, v);
        }
    }
    int merge(int p, int q, int l, int r) {
        if (!p || !q) return p | q;
        int mid = l + r >> 1;
        sum[p] += sum[q];
        lc[p] = merge(lc[p], lc[q], l, mid);
        rc[p] = merge(rc[p], rc[q], mid+1, r);
        return p;
    }
    int query(int p, int l, int r, int ql, int qr) {
        if (ql <= l && r <= qr) return sum[p];
        int mid = l + r >> 1, res = 0;
        if (ql <= mid) res += query(lc[p], l, mid, ql, qr);
        if (mid < qr) res += query(rc[p], mid+1, r, ql, qr);
        return res;
    }

    void calc(int x, int fa, int dep) {
        rt[x] = ++pt;
        modify(rt[x], 1, n, dep, 1);
        for (int to : G[x]) {
            if (to == fa) continue;
            calc(to, x, dep+1);
            rt[x] = merge(rt[x], rt[to], 1, n);
        }

        for (qr _ : qf[x]) {
            ans[_.i] += query(rt[x], 1, n, dep, dep+_.d) * _.k;
        }
    }
}
namespace getg{
    #define lowbit(x) ((x)&-(x))
    struct arr{
        int t[MAXN], d[MAXN], ti;
        int& operator [] (int x) {
            if (t[x] != ti) {
                t[x] = ti;
                d[x] = 0;
            }
            return d[x];
        }
    }bit;

    void mdf(int x, int v) {
        for (; x <= n; x+=lowbit(x)) {
            bit[x] += v;
        }
    }
    int qry(int x) {
        int sum = 0;
        for (; x; x-=lowbit(x))
            sum += bit[x];
        return sum;
    }

    void insert(int x, int fa, int dep) {
        mdf(dep, 1);
        for (int to : G[x]) {
            if (to == fa) continue;
            insert(to, x, dep+1);
        }
    }

    void calc(int x, int fa, int dep) {
        bit.ti++;
        for (int to : G[x]) {
            if (to == fa || to == TSG::hson[x]) continue;
            insert(to, x, 1);
        }
        for (qr _ : qf[x]) {
            ans[_.i] += qry(_.d)*_.k;
        }

        for (int to : G[x]) {
            if (to == fa) continue;
            calc(to, x, dep+1);
        }
    }
}
namespace getsf{
    #define vi vector<int>
    bool vis[MAXN];
    int siz[MAXN], all;

    void dfssiz(int x, int fa) {
        siz[x] = 1;
        for (int to : G[x]) {
            if (to == fa || vis[to]) continue;
            dfssiz(to, x);
            siz[x] += siz[to];
        }
    }
    int dfsmid(int x, int fa) {
        int mx = all - siz[x];
        for (int to : G[x]) {
            if (to == fa || vis[to]) continue;
            int tmp = dfsmid(to, x);
            if (tmp) return tmp;
            mx = max(mx, siz[to]);
        }
        return x*(mx*2<=all);
    }

    int Tfa[MAXN];
    int findmid(int x) {
        dfssiz(x, 0);
        all = siz[x];
        return dfsmid(x, 0);
    }

    vi b[MAXN], fb[MAXN];
    void mdf(vi& bit, int x, int v) {
        for (; x < bit.size(); x+=lowbit(x)) {
            bit[x] += v;
        }
    }
    int qry(vi& bit, int x) {
        int res = 0;
        for (; x; x-=lowbit(x)) {
            res += bit[x];
        }
        return res;
    }

    int dfs_mxdep(int x, int fa) {
        int res = 0;
        for (int to : G[x]) {
            if (to == fa || vis[to]) continue;
            res = max(res, dfs_mxdep(to, x));
        }
        return res+1;
    }
    void insert(vi v, int x, int fa, int dep) {
        mdf(v, dep, 1);
        for (int to : G[x]) {
            if (to == fa || vis[to]) continue;
            insert(v, to, x, dep+1);
        }
    }
    void build(int x) {
        vis[x] = 1;

        b[x].resize(dfs_mxdep(x, 0)+1);
        insert(b[x], x, 0, 1);

        for (int to : G[x]) {
            if (vis[to]) continue;
            int tr = findmid(to);
            Tfa[tr] = x;
            fb[tr].resize(dfs_mxdep(to, 0)+1);
            insert(fb[tr], to, 0, 2);
            build(tr);
        }
    }

    void calc() {
        build(findmid(1));
        for (int i = 1; i <= n; i++) {
            if (qsf[i].empty()) continue;
            int now = i, pre = 0;
            while (now) {
                for (qr _ : qsf[i]) {
                    int nd = _.d - LCA::dist(now, i);
                    if (nd < 0) continue;
                    ans[_.i] += qry(b[now], nd+1)*_.k;
                    if (pre) ans[_.i] -= qry(fb[pre], nd+1);
                }
                pre = now; now = Tfa[now];
            }
        }
    }
}

void print() {
    for (int i = 1; i <= m; i++) {
        cout << ans[i] << '\n';
    }
}

int main() {
    // g++ code.cpp -o code.exe -std=c++14 -O2 -fno-ms-extensions "-Wl,--stack=1000000000" -DLOCAL; ./code
    time_t stm = clock();

    #ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("ans.out", "w", stdout);
    #else
    // freopen("tii.in", "r", stdin);
    // freopen("tii.out", "w", stdout);
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    #endif

    init();
    LCA::dfs_build(1);
    TSG::dfs1(1);
    TSG::dfs2(1, 1);
    dealqry();
    getf::calc(1, 1, 1);
    getg::calc(1, 1, 1);
    getsf::calc();
    print();

    cerr << "Exec Time: " << (double)(clock()-stm)/CLOCKS_PER_SEC << "s" << endl;
    return 0;
}