// 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;

struct Centroid {
    vector<vector<int>> &g;
    vector<vector<pair<int, int&>>> 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, int &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, int&>>> g_qs;
    vector<vector<tuple<int, int, int&>>> f_qs;

    vector<int> vis, sz, mxs, top, pa, dep;
    int dfc;
    vector<int> tin, tou, ord;
    int64_t totsum;
    vector<int> 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) {
        sz[i] = 1; mxs[i] = -1;
        for (int j: g[i]) {
            if (j == f) continue;
            pa[j] = i;
            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, int &ans) {
        return;
        if (d < 0) return;
        ans += coef * (sz[u] - 1);
        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);
        // for (int t = tin[u] + 1; t < tou[u]; t++) {
        //     int v = ord[t];
        //     // if (dep[v] - dep[u] <= d) {
        //     //     ans += coef;
        //     // }
        // }
    }

    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, int &ans) {
        g_qs[x].emplace_back(d, 1, ans);
        g_qs[y].emplace_back(d, 1, ans);
        if (mxs[x] != -1) add_f_query(mxs[x], d - 1, 1, ans);
        if (mxs[y] != -1) add_f_query(mxs[y], d - 1, 1, ans);
        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;
        g_qs[z].emplace_back(d, -2, ans);
        return z;
    }


    void dfs_g(int i, int f) {
        totsum += sz[i];
        for (int j: g[i]) {
            if (j == f || j == mxs[i]) continue;
            for (int t = tin[j]; t < tou[j]; t++) {
                int u = ord[t];
                sum[ dep[u] - dep[i] ] += sz[u];
            }
        }

        for (auto &[d, coef, ans]: g_qs[i]) {
            int64_t cur = totsum - dep[i] - sum[d + 1];
            debug(ans, coef, cur);
            ans += coef * cur;
        }

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

        totsum -= sz[i];
        for (int j: g[i]) {
            if (j == f || j == mxs[i]) continue;
            for (int t = tin[j]; t < tou[j]; 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<int> ans(q);
    Centroid cent(g);
    HLD hld(g);

    for (int i = 0; i < q; i++) {
        int x, y, d;
        cin >> x >> y >> d;
        --x, --y;
        int z = hld.add_query(x, y, d, ans[i]);
        cent.add_query(z, d, ans[i]);
        assert (x == y && y == z);
        debug(x+1, y+1, z+1);
        // hld.add_query(z, d, -2, ans[i]);
        // hld.add_query(x, d, 1, ans[i]);
        // hld.add_query(y, d, 1, ans[i]);
    }

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

    // hld.solve();

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

}