#include <bits/stdc++.h>
using namespace std;
const int _ = 5e5 + 10;
const int __ = 1e6 + 10;
const int ___ = 2e6 + 10;
int n, e, hd[_], nx[__], to[__];
inline void add(int u, int v) {
    e++;
    nx[e] = hd[u];
    to[e] = v;
    hd[u] = e;
}
int fa[_][20], dep[_];
void dfs(int x) {
    for (int i = hd[x]; i; i = nx[i]) {
        int y = to[i];
        if (y != fa[x][0]) {
            fa[y][0] = x;
            dep[y] = dep[x] + 1;
            dfs(y);
        }
    }
}
inline int lca(int x, int y) {
    if (dep[x] < dep[y]) swap(x, y);
    int D = dep[x] - dep[y];
    for (int i = 19; i >= 0; i--) {
        if (D & (1 << i)) x = fa[x][i];
    }
    if (x == y) return x;
    for (int i = 19; i >= 0; i--) {
        if (fa[x][i] != fa[y][i]) {
            x = fa[x][i];
            y = fa[y][i];
        }
    }
    return fa[x][0];
}
int mid[_];
struct node {
    int dep;
    int pos;
    bool tp;
} arr[__];
inline bool cmpn(const node& lhs, const node& rhs) {
    return lhs.dep > rhs.dep;
}
int lef[_], rig[_];
int Lef(int x) {
    if (x == lef[x]) return x;
    return lef[x] = Lef(lef[x]);
}
int Rig(int x) {
    if (x == rig[x]) return x;
    return rig[x] = Rig(rig[x]);
}
inline void Merge(int x) {
    rig[x] = x + 1;
    lef[x + 1] = x;
}
bool ok[_], oki[_];
int c, px[__], py[__], pt[__];
#define ls ((p)<<1)
#define rs (((p)<<1)|1)
#define M (((L)+(R))>>1)
namespace seg {
    int st[___];
    void build(int p, int L, int R) {
        st[p] = 0;
        if (L != R) {
            build(ls, L, M);
            build(rs, M+1, R);
        }
    }
    void add(int p, int x, int k, int L, int R) {
        st[p] = max(st[p], k);
        if (L != R) {
            if (x <= M) add(ls, x, k, L, M);
            else add(rs, x, k, M+1, R);
        }
    }
    int query(int p, int l, int r, int L, int R) {
        if (l == L && r == R) {
            return st[p];
        } else if (r <= M) {
            return query(ls, l, r, L, M);
        } else if (l > M) {
            return query(rs, l, r, M+1, R);
        } else {
            return max(query(ls, l, M, L, M), query(rs, M+1, r, M+1, R));
        }
    }
}
#undef M
#undef rs
#undef ls
inline void Clear(void) {
    seg::build(1, 1, n);
}
inline void Add(int x, int y) {
    seg::add(1, x, y, 1, n);
}
inline int Query(int l, int r) {
    return seg::query(1, l, r, 1, n);
}
int m, ql[_], qr[_], qk[_], ans[_];
int q;
struct query {
    int x;
    int y;
    int z;
    int typ;
} que[___];
inline bool cmpq(const query& lhs, const query& rhs) {
    return (lhs.x == rhs.x) ? (lhs.typ < rhs.typ) : (lhs.x < rhs.x);
}
int main() {
    freopen("query.in", "r", stdin);
    freopen("query.out", "w", stdout);
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin >> n;
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        add(u, v);
        add(v, u);
    }
    cin >> m;
    for (int i = 1; i <= m; i++) {
        cin >> ql[i] >> qr[i] >> qk[i];
    }
    dep[1] = 1;
    dfs(1);
    for (int k = 1; k <= 19; k++) {
        for (int i = 1; i <= n; i++) {
            fa[i][k] = fa[fa[i][k-1]][k-1];
        }
    }
    for (int i = 1; i < n; i++) {
        mid[i] = dep[lca(i, i + 1)];
    }
    for (int i = 1; i <= n; i++) {
        arr[i].dep = dep[i];
        arr[i].pos = i;
        arr[i].tp = false;
    }
    for (int i = 1; i < n; i++) {
        arr[n+i].dep = mid[i];
        arr[n+i].pos = i;
        arr[n+i].tp = true;
    }
    sort(arr+1, arr+(n<<1), cmpn);
    for (int i = 1; i <= n; i++) {
        lef[i] = rig[i] = i;
    }
    for (int i = 1; i < (n << 1); i++) {
        int t = arr[i].dep;
        if (arr[i].tp) {
            int x = arr[i].pos;
            oki[x] = true;
            if (ok[x] && ok[x+1]) {
                Merge(x);
                int l = Lef(x);
                int r = Rig(x);
                c++;
                px[c] = l;
                py[c] = r;
                pt[c] = t;
            }
        } else {
            int x = arr[i].pos;
            ok[x] = true;
            if (x != 1) {
                if (oki[x-1] && ok[x-1]) {
                    Merge(x-1);
                }
            }
            if (x != n) {
                if (oki[x] && ok[x+1]) {
                    Merge(x);
                }
            }
            int l = Lef(x);
            int r = Rig(x);
            c++;
            px[c] = l;
            py[c] = r;
            pt[c] = t;
        }
    }
    q = 0;
    for (int i = 1; i <= c; i++) {
        que[++q] = (query){px[i], py[i], pt[i], 0};
    }
    for (int i = 1; i <= m; i++) {
        que[++q] = (query){ql[i], ql[i] + qk[i] - 1, n, i};
        que[++q] = (query){qr[i] - qk[i] + 1, qr[i], n, i};
    }
    sort(que+1, que+q+1, cmpq);
    Clear();
    for (int i = 1; i <= q; i++) {
        if (que[i].typ) {
            ans[que[i].typ] = max(ans[que[i].typ], Query(que[i].y, que[i].z));
        } else {
            Add(que[i].y, que[i].z);
        }
    }
    q = 0;
    for (int i = 1; i <= c; i++) {
        que[++q] = (query){n - py[i] + px[i], px[i], pt[i], 0};
    }
    for (int i = 1; i <= m; i++) {
        que[++q] = (query){n - qk[i] + 1, ql[i], qr[i] - qk[i] + 1, i};
    }
    sort(que+1, que+q+1, cmpq);
    Clear();
    for (int i = 1; i <= q; i++) {
        if (que[i].typ) {
            ans[que[i].typ] = max(ans[que[i].typ], Query(que[i].y, que[i].z));
        } else {
            Add(que[i].y, que[i].z);
        }
    }
    for (int i = 1; i <= m; i++) {
        cout << ans[i];
        if (i != m) {
            cout << '\n';
        }
    }
    cout << endl;
    return 0;
}