#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <set>
using namespace std;

using i64 = long long;
using u32 = unsigned int;
using u64 = unsigned long long;

template<typename T> using vec = vector<T>;

struct Point
{
    int a, b, c, v;
    Point() { }
    Point(int _a, int _b, int _c, int _v)
        : a(_a), b(_b), c(_c), v(_v) { }
};

struct BIT
{
    int n;
    vec<int> t;
    vec<int> mem, ps;
    
    BIT(int _n): n(_n), t(n + 1), mem(n + 1, -1) { }
    void add(int x, int d) 
    {
        for (++x; x <= n; x += x & -x) {
            if (mem[x] == -1) mem[x] = t[x], ps.emplace_back(x);
            t[x] = max(t[x], d);
        }
    }
    int ask(int x)
    {
        if (x <= 0) return 0;
        if (x >= n) x = n;
        int res = 0;
        for (; x; x -= x & -x) res = max(res, t[x]);
        return res;
    }
    
    void clear()
    {
        for (auto i: ps) {
            t[i] = mem[i];
            mem[i] = -1;
        }
        ps.clear();
    }
};

signed main()
{
    freopen("query.in", "r", stdin);
    freopen("query.out", "w", stdout);
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    vec<vec<int>> g(n);
    for (int i = 1, u, v; i < n; i++) {
        cin >> u >> v;
        --u, --v;
        g[u].emplace_back(v);
        g[v].emplace_back(u);
    }
    
    vec<set<pair<int, int>>> seg(n);
    vec<Point> pt;
    pt.reserve(n * 2);
    vec<int> pss;
    vec<int> mr(n, -1);
    
    auto dfs = [&](auto &&f, int x, int fa, int dep) -> void
    {
        for (auto it = g[x].begin(); it != g[x].end(); it++) {
            if (*it == fa) {
                g[x].erase(it);
                break;
            }
        }
        if (g[x].empty()) {
            pt.emplace_back(x + 1, x + 1, 1, dep);
            seg[x].emplace(x, x + 1);
            return ;
        }
        int mxs = 0, mxv = 0;
        for (int v: g[x]) {
            f(f, v, x, dep + 1);
            if (mxs < int(seg[v].size())) {
                mxs = seg[v].size();
                mxv = v;
            }
        }
        seg[x].swap(seg[mxv]);
        auto &nw = seg[x];
        // ÐèÒª¸Ä½ø£¡ 
        for (int v: g[x]) if (v != mxv) {
            for (auto p: seg[v]) {
                auto it = nw.lower_bound(p);
                int nl = p.first, nr = p.second, fg = false;
                if (it != nw.begin()) {
                    auto jt = prev(it);
                    if (jt->second == nl) {
                        nl = jt->first;
                        nw.erase(jt);
                        fg = true;
                    }
                }
                if (it != nw.end()) {
                    if (it->first == nr) {
                        nr = it->second;
                        nw.erase(it);
                        fg = true;
                    }
                }
                nw.emplace(nl, nr);
                if (fg) {
                    if (mr[nl] == -1) pss.emplace_back(nl);
                    mr[nl] = max(mr[nl], nr);
//                    pt.emplace_back(nl, nr, nr - nl, dep);
                }
            }
            seg[v].clear();
        }
        pair<int, int> p(x, x + 1);
        auto it = nw.lower_bound(p);
        int nl = p.first, nr = p.second, fg = false;
        if (it != nw.begin()) {
            auto jt = prev(it);
            if (jt->second == nl) {
                nl = jt->first;
                nw.erase(jt);
                fg = true;
            }
        }
        if (it != nw.end()) {
            if (it->first == nr) {
                nr = it->second;
                nw.erase(it);
                fg = true;
            }
        }
        nw.emplace(nl, nr);
//        cout << x << endl;
//        for (auto i: nw) cout << i.first << ' ' << i.second << endl;
        
        if (fg) {
            if (mr[nl] == -1) pss.emplace_back(nl);
            mr[nl] = max(mr[nl], nr);
        }
        int mxr = -1;
        pt.emplace_back(x + 1, x + 1, 1, dep);
        sort(pss.begin(), pss.end());
        for (auto i: pss) {
            if (i < mxr) {
                mr[i] = -1;
                continue;
            }
            mxr = max(mxr, mr[i]);
            pt.emplace_back(i + 1, mr[i], mr[i] - i, dep);
            mr[i] = -1;
        }
        pss.clear();
    };
    
    dfs(dfs, 0, -1, 1);
    
    int q;
    cin >> q;
    vec<Point> qr(q);
    vec<int> ans(q);
    
    for (int i = 0, l, r, k; i < q; i++) {
        cin >> l >> r >> k;
        qr[i] = {l - 1, r, k, i};
    }
    
//    for (auto i: pt) cout << i.a << ' ' << i.b << ' ' << i.c << ' ' << i.v << endl;
//    cout << endl;
//    for (auto i: qr) cout << i.a << ' ' << i.b << ' ' << i.c << ' ' << i.v << endl;
//    cout << endl;

    BIT bt(n + 2);

    sort(qr.begin(), qr.end(), [](const auto &x, const auto &y)
    {
        return x.b - x.c <= y.b - y.c;
    });
    
    sort(pt.begin(), pt.end(), [](const auto &x, const auto &y)
    {
        return x.a < y.a;
    });
    
    {
        int ps = pt.size(), qs = qr.size(), pp = 0;
        for (int i = 0; i < qs; i++) {
            int lim = qr[i].b - qr[i].c + 1;
            while (pp < ps && pt[pp].a <= lim) {
                bt.add(n - pt[pp].b, pt[pp].v);
                pp++;
            }
            ans[qr[i].v] = max(ans[qr[i].v], bt.ask(n - (qr[i].b) + 1));
        }
        bt.clear();
    }
    sort(qr.begin(), qr.end(), [](const auto &x, const auto &y)
    {
        return x.a < y.a;
    });
    {
        int ps = pt.size(), qs = qr.size(), pp = 0;
        for (int i = 0; i < qs; i++) {
            while (pp < ps && pt[pp].a <= qr[i].a) {
                bt.add(n - pt[pp].b, pt[pp].v);
                pp++;
            }
            ans[qr[i].v] = max(ans[qr[i].v], bt.ask(n - (qr[i].a + qr[i].c) + 1));
        }
        bt.clear();
    }
    
    auto solve = [&](auto &&f, int ll, int lr, vec<Point> &pts, vec<Point> &qrs)
    {
        if (qrs.empty() || ll + 1 == lr) return ;
        int mid = (ll + lr) >> 1;
        vec<Point> lp, rp, lq, rq;
        lp.reserve(pts.size());
        rp.reserve(pts.size());
        lq.reserve(qrs.size());
        rq.reserve(qrs.size());
        for (auto &i: pts) {
            if (i.a < mid) lp.emplace_back(i);
            else rp.emplace_back(i);
        }
        for (auto &i: qrs) {
            if (i.a < mid) lq.emplace_back(i);
            else rq.emplace_back(i);
        }
        sort(lq.begin(), lq.end(), [](const auto &x, const auto &y)
        {
            return x.c > y.c;
        });
        sort(rp.begin(), rp.end(), [](const auto &x, const auto &y)
        {
            return x.c > y.c;
        });
        int pp = 0, ps = rp.size();
        for (int i = 0, qq = lq.size(); i < qq; i++) {
            int cc = lq[i].c, vv = lq[i].v;
            while (pp < ps && rp[pp].c >= cc) {
                bt.add(rp[pp].b, rp[pp].v);
                pp++;
            }
            ans[vv] = max(ans[vv], bt.ask(lq[i].b + 1));
        }
        bt.clear();
        vec<Point>().swap(pts);
        vec<Point>().swap(qrs);
        f(f, ll, mid, lp, lq);
        f(f, mid, lr, rp, rq);
    };
    
    solve(solve, 0, n + 1, pt, qr);
    
    for (auto i: ans) cout << i << '\n';
    return 0;
}