// An AC a day keeps the doctor away.
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#ifdef local
#define safe std::cerr<<__PRETTY_FUNCTION__<<" line "<<__LINE__<<" safe\n"
#define debug(args...) qqbx(#args, args)
#define orange(args...) danb(#args, args)
using std::cerr;
template <typename ...T> void qqbx(const char *s, T ...args) {
    int cnt = sizeof...(T);
    ((cerr << "\e[1;32m(" << s << ") = ("), ..., (cerr << args << (--cnt ? ", " : ")\e[0m\n")));
}
template <typename I> void danb(const char *s, I L, I R) {
    cerr << "\e[1;32m[ " << s << " ] = [ ";
    for (int f = 0; L != R; ++L) cerr << (f++ ? ", " : "") << *L;
    cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) ((void)0)
#define orange(...) ((void)0)
#endif // local
#define all(v) begin(v),end(v)

using namespace std;

using lld = int64_t;

struct Centroid {
    vector<vector<int>> &g;
    vector<vector<pair<int, lld&>>> qs;
    vector<int> vis, sz;
    vector<int> dis;
    Centroid(vector<vector<int>> &t_g) : g(t_g), qs(g.size()),
        vis(g.size()), sz(g.size()), dis(g.size()) {
    }
    void solve() {
        decomp(0, 0);
    }
    void add_query(int i, int d, lld &a) {
        qs[i].emplace_back(d, a);
    }

    void get_size(vector<int> &s, int i) {
        s.emplace_back(i);
        vis[i] = true;
        sz[i] = 1;
        for (int j: g[i]) if (!vis[j]) {
            get_size(s, j);
            sz[i] += sz[j];
        }
    }
    void dfs(vector<int> &s, int i) {
        s.emplace_back(i);
        vis[i] = true;
        for (int j: g[i]) if (!vis[j]) {
            dis[j] = dis[i] + 1;
            dfs(s, j);
        }
    }

    void gao(const vector<int> &vtx, int coef) {
        int mx = 0;
        for (int x: vtx) mx = max(mx, dis[x]);
        vector<int> pre(mx + 1);
        for (int x: vtx) {
            pre[dis[x]] += 1;
            mx = max(mx, dis[x]);
        }
        for (int i = 1; i <= mx; i++) pre[i] += pre[i - 1];
        for (int x: vtx) {
            for (auto &[d, p]: qs[x]) {
                // #{ y | dis[x] + dis[y] <= d }
                int cnt = d - dis[x] < 0 ? 0 : pre[min(mx, d - dis[x])];
                p += coef * cnt;
            }
        }
    }

    void decomp(int i, int d) {
        vector<int> s;
        get_size(s, i);
        int c = -1;
        for (int j: s) {
            if (sz[j] * 2 >= sz[i])
                c = j;
            vis[j] = false;
        }
        vis[c] = true;

        vector<int> total;
        vector<vector<int>> sub;
        for (int j: g[c]) {
            if (vis[j]) continue;
            dis[j] = 1;
            sub.emplace_back();
            dfs(sub.back(), j);
            for (int x: sub.back())
                total.emplace_back(x);
        }
        dis[c] = 0;
        total.emplace_back(c);

        gao(total, 1);
        for (const auto &t: sub) gao(t, -1);

        for (int j: s) vis[j] = false;
        vis[c] = true;
        for (int j: g[c]) {
            if (vis[j]) continue;
            decomp(j, d + 1);
        }
    }
};

struct HLD {
    vector<vector<int>> &g;
    vector<vector<tuple<int, int, lld&>>> g_qs;
    vector<vector<tuple<int, int, lld&>>> f_qs;

    vector<int> vis, sz, mxs, top, pa, dep;
    int dfc;
    vector<int> tin, tou, ord;
    int64_t totsum;
    vector<int64_t> sum;
    HLD(vector<vector<int>> &t_g) : g(t_g),
        g_qs(g.size()), f_qs(g.size()),
        vis(g.size()), sz(g.size()), mxs(g.size()), top(g.size()), pa(g.size()), dep(g.size()),
        dfc(0), tin(g.size()), tou(g.size()), ord(g.size()),
        totsum(0), sum(g.size() + 1) {
        get_size(0, -1);
        make_chain(0, -1, 0);
    }
    void get_size(int i, int f) {
        pa[i] = f;
        sz[i] = 1; mxs[i] = -1;
        for (int j: g[i]) {
            if (j == f) continue;
            dep[j] = dep[i] + 1;
            get_size(j, i);
            sz[i] += sz[j];
            if (mxs[i] == -1 || sz[mxs[i]] < sz[j])
                mxs[i] = j;
        }
    }
    void make_chain(int i, int f, int t) {
        ord[dfc] = i;
        tin[i] = dfc++;
        top[i] = t;
        if (mxs[i] != -1) make_chain(mxs[i], i, t);
        for (int j: g[i]) {
            if (j == f) continue;
            if (j == mxs[i]) continue;
            make_chain(j, i, j);
        }
        tou[i] = dfc;
    }

    void add_f_query(int u, int d, int coef, lld &ans) {
        debug("ADD_F_QUERY", u+1, d, coef);
        if (d < 0) return;
        ans += coef * sz[u];
        f_qs[tou[u]-1].emplace_back(dep[u] + d + 1, -coef, ans);
        f_qs[tin[u]].emplace_back(dep[u] + d + 1, coef, ans);
        // int cnt = 0;
        // for (int t = tin[u]; t < tou[u]; t++) {
        //     int v = ord[t];
        //     if (dep[v] - dep[u] <= d) ++cnt;
        // }
        // debug(u+1, d, coef, cnt);
        // ans += coef * cnt;
    }

    void do_f_query(int n) {
        vector<int64_t> cnt(n);
        for (int i = 0; i < n; i++) {
            cnt[ dep[ord[i]] ] += sz[ord[i]];
            for (auto &[d, coef, ans]: f_qs[i])
                ans += coef * (d >= 0 && d < n ? cnt[d] : 0);
        }
    }

    int add_query(int x, int y, int d, lld &ans) {
        g_qs[x].emplace_back(d, 1, ans);
        g_qs[y].emplace_back(d, 1, ans);
        for (int w: {x, y})
            if (mxs[w] != -1)
                add_f_query(mxs[w], d - 1, 1, ans);
        int org_x = x, org_y = y;
        while (top[x] != top[y]) {
            if (dep[top[x]] < dep[top[y]]) swap(x, y);
            int t = top[x];
            add_f_query(t, d - 1, -1, ans);
            add_f_query(mxs[pa[t]], d - 1, 1, ans);
            x = pa[t];
        }
        int z = dep[x] < dep[y] ? x : y;
        if (pa[z] != -1)
            g_qs[pa[z]].emplace_back(d, -2, ans);
        add_f_query(z, d, -2, ans);
        int onchain = dep[org_x] + dep[org_y] - dep[z] * 2 + 2;
        ans += onchain;
        debug(onchain);
        return z;
    }


    void dfs_g(int i, int f) {
        if (mxs[i] != -1) {
            totsum += sz[i] - 1 - sz[mxs[i]];
            for (int t = tou[mxs[i]]; t < tou[i]; t++) {
                int u = ord[t];
                sum[ dep[u] - dep[i] ] += sz[u];
            }
        }

        for (auto &[d, coef, ans]: g_qs[i]) {
            // for (int x = i; x != -1; x = pa[x]) {
            //     int m = 0;
            //     if (mxs[x] != -1)
            //         for (int t = tou[mxs[x]]; t < tou[x]; t++) {
            //             int u = ord[t];
            //             debug(u);
            //             if (dep[u] - dep[x] == d + 1)
            //                 m += sz[u];
            //         }
            //     debug(x+1, sz[x] - 1 - m, sz[x], m);
            // }
            debug(totsum, sum[d + 1]);
            int64_t cur = totsum - sum[d + 1];
            debug(coef, cur, d, i+1);
            ans += coef * cur;
        }

        for (int j: g[i]) {
            if (j == f) continue;
            dfs_g(j, i);
        }

        if (mxs[i] != -1) {
            totsum += sz[i] - 1 - sz[mxs[i]];
            for (int t = tou[mxs[i]]; t < tou[i]; t++) {
                int u = ord[t];
                sum[ dep[u] - dep[i] ] += sz[u];
            }
        }
    }

    void solve() {
        dfs_g(0, -1);
        do_f_query(g.size());
    }
};


signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;

    vector<vector<int>> g(n);
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        --u, --v;
        g[u].emplace_back(v);
        g[v].emplace_back(u);
    }


    int q;
    cin >> q;
    vector<lld> ans(q);
    Centroid cent(g);
    HLD hld(g);

    /* const auto brute = [&](int x, int y, int d) { */
    /*     const auto &p = hld.pa; */
    /*     const auto &dep = hld.dep; */
    /*     vector<int> dis(n, -1); */
    /*     queue<int> que; */
    /*     while (x != y) { */
    /*         if (dep[x] < dep[y]) swap(x, y); */
    /*         que.emplace(x); */
    /*         dis[x] = 0; */
    /*         x = p[x]; */
    /*     } */
    /*     que.emplace(x); */
    /*     dis[x] = 0; */
    /*     while (!que.empty()) { */
    /*         int i = que.front(); que.pop(); */
    /*         for (int j: g[i]) { */
    /*             if (dis[j] == -1) { */
    /*                 dis[j] = dis[i] + 1; */
    /*                 que.emplace(j); */
    /*             } */
    /*         } */
    /*     } */
    /*     int a = 0; */
    /*     for (int i = 0; i < n; i++) */
    /*         if (dis[i] <= d) */
    /*             ++a; */
    /*     return a; */
    /* }; */
    /* vector<lld> bans(q); */

    for (int i = 0; i < q; i++) {
        // int x = rand() % n;
        // int y = rand() % n;
        // int d = rand() % n;
        int x, y, d;
        cin >> x >> y >> d;
        --x, --y;

        // bans[i] = brute(x, y, d);
        int z = hld.add_query(x, y, d, ans[i]);
        cent.add_query(z, d, ans[i]);
        // hld.add_query(z, d, -2, ans[i]);
        // hld.add_query(x, d, 1, ans[i]);
        // hld.add_query(y, d, 1, ans[i]);
    }

    hld.solve();
    orange(all(ans));

    cent.solve();

    orange(all(ans));
    // orange(all(bans));
    // assert (ans == bans);

    for (int i = 0; i < q; i++)
        cout << ans[i] << '\n';

}