// MagicDark
#include <bits/stdc++.h>
#define mid ((l + r) >> 1)
#define lc num << 1
#define rc lc | 1
#define li lc, l, mid
#define ri rc, mid + 1, r
#define debug cerr << "\33[33m[" << __LINE__ << "]\33[m "
#define all(x) x.begin(), x.end()
#define SZ(x) ((int) x.size() - 1)
#define ms(x, y) memset(x, y, sizeof x)
#define F(i, x, y) for (int i = (x); i <= (y); ++i)
#define DF(i, x, y) for (int i = (x); i >= (y); --i)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
template <typename T> T& chkmin(T& x, T y) {return x = min(x, y);}
template <typename T> T& chkmax(T& x, T y) {return x = max(x, y);}
template <typename T> T& read(T& x) {
    x = 0; int f = 1; char c = getchar();
    for (; !isdigit(c); c = getchar()) if (c == '-') f = - 1;
    for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
    return x *= f;
}
const int N = 5e5 + 10;
int n, q, dep[N], dfn[N], mn[21][N], dfscnt;
vector <int> v[N];
int qmin(int x, int y) {
    return dfn[x] < dfn[y] ? x : y;
}
void dfs(int x, int fa) {
    dep[x] = dep[fa] + 1;
    // ::fa[x] = fa;
    mn[0][dfn[x] = ++dfscnt] = fa;
    for (int i: v[x])
        if (i != fa) {
            dfs(i, x);
        }
}
struct DS {
    int info[N << 2];
    void pushup(int num) {
        info[num] = max(info[lc], info[rc]);
    }
    void modify(int num, int l, int r, int x, int y) {
        if (l == r) {
            // assert(y >= info[num]);
            info[num] = y;
            return;
        }
        if (mid >= x) modify(li, x, y);
        else modify(ri, x, y);
        pushup(num);
    }
    int query(int num, int l, int r, int L, int R) {
        if (L <= l && r <= R) return info[num];
        if (mid >= R) return query(li, L, R);
        if (mid < L) return query(ri, L, R);
        return max(query(li, L, R), query(ri, L, R));
    }
} ds1, ds2;
int ans[N], ff[21][N];
int lca(int x, int y) {
    if (x == y) return x;
    x = dfn[x], y = dfn[y];
    if (x > y) swap(x, y);
    int k = __lg(y - x++);
    return qmin(mn[k][x], mn[k][y - (1 << k) + 1]);
}
int qq(int l, int r) {
    int k = __lg(r - l + 1);
    return min(ff[k][l], ff[k][r - (1 << k) + 1]);
}
vector <int> g[N];
int fa[N], tr[N];
int find(int x) {
    return fa[x] == x ? x : fa[x] = find(fa[x]);
}
vector <tuple <int, int, int>> vq[N];
vector <tuple <int, int, int>> va[N];
signed main() {
    freopen("query.in", "r", stdin);
    freopen("query.out", "w", stdout);
    read(n);
    F(i, 1, n - 1) {
        int x, y; read(x), read(y);
        v[x].push_back(y);
        v[y].push_back(x);
    }
    dfs(1, 0);
    F(i, 1, __lg(n))
        F(j, 1, n - (1 << i) + 1)
            mn[i][j] = qmin(mn[i - 1][j], mn[i - 1][j + (1 << (i - 1))]);
    F(i, 1, n - 1) {
        int w = lca(i, i + 1);
        ff[0][i] = dep[w];
        // debug << i << " " << dep[w] << endl;
        g[dep[w]].push_back(i);
    }
    // F(i, 1, n) ff[0][i] = i;
    F(i, 1, __lg(n - 1))
        F(j, 1, n - 1 - (1 << i) + 1)
            ff[i][j] = min(ff[i - 1][j], ff[i - 1][j + (1 << (i - 1))]);
    F(i, 1, n) {
        fa[i] = i;
        tr[i] = i;
        va[1].emplace_back(i, i, dep[i]);
    }
    // debug << n << endl;
    DF(i, n, 1) {
        // debug << g[i].size() << endl;
        for (int j: g[i]) {
            int a = find(j), b = j + 1;
            fa[b] = a;
            tr[a] = tr[b];
            // debug << a << ' ' << tr[a] << " " << i << endl;
            va[tr[a] - a + 1].emplace_back(a, tr[a], i);
        }
    }
    read(q);
    F(i, 1, q) {
        int l, r, k; read(l), read(r), read(k);
        if (l == r) ans[i] = dep[l];
        else ans[i] = qq(l, r - 1);
        if (k != r - l + 1) vq[k].emplace_back(l, r, i);
    }
    // F(i, 1, q) {
    //     F(j, )
    //     for (auto [a, b, c]: )
    // }
    // debug << ans[3] << endl;
    DF(i, n, 1) {
        for (auto [l, r, val]: va[i]) {
            // debug << l << " " << r << " " << val << endl;
            ds1.modify(1, 1, n, l, val);
            ds2.modify(1, 1, n, r, val);
        }
        for (auto [l, r, id]: vq[i]) {
            // F(j, i, n)
            //     for (auto [tl, tr, val]: va[j])
            //         if ((l + i - 1 <= tr && tr <= r) || (l <= tl && tl <= r - i + 1)) chkmax(ans[id], val);
            chkmax(ans[id], max(ds2.query(1, 1, n, l + i - 1, r), ds1.query(1, 1, n, l, r - i + 1)));
        }
    }
    F(i, 1, q) cout << ans[i] << '\n';
    return 0;
}
/*
why
*/