#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
#define F(i, a, b) for(int i = a; i <= (b); ++i)
#define F2(i, a, b) for(int i = a; i < (b); ++i)
#define dF(i, a, b) for(int i = a; i >= (b); --i)
#define pb push_back
#define fi first
#define se second
typedef long long ll;
inline int ri() {
	int x = 0;
	bool t = 0;
	char c = getchar();
	while (c < '0' || c > '9') t |= c == '-', c = getchar();
	while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
	return t ? -x : x;
}
const int _ = 2e5 + 5;


namespace GAME {
	int n, q;
	vi d[_];
	namespace Tree {
		int f[20][_], dep[_];
		void dfs(int u, int fa) {
			dep[u] = dep[fa] + 1, f[0][u] = fa;
			for(int v : d[u]) if(v != fa) dfs(v, u);
		}
		void init() {
			dfs(1, 0);
			F(i, 1, 19) F(j, 1, n) f[i][j] = f[i - 1][f[i - 1][j]];
		}
		int jump(int x, int d) {
			dF(i, 19, 0) if((d >> i) & 1) x = f[i][x];
			return x;
		}
		int LCA(int u, int v) {
			if(dep[u] < dep[v]) swap(u, v);
			dF(i, 19, 0) if(dep[f[i][u]] >= dep[v]) u = f[i][u];
			if(u == v) return u;
			dF(i, 19, 0) if(f[i][u] != f[i][v]) u = f[i][u], v = f[i][v];
			return f[0][u];
		}
		int Dis(int u, int v) {
			return dep[u] + dep[v] - (dep[LCA(u, v)] << 1);
		}
	}
	namespace HG {
		struct node {
			int ln, v, v2;
			node() {
			}
			node(int Ln = 0, int V = 0, int V2 = 0) {
				ln = Ln, v = V, v2 = V2;
			}
		};
		vector<node> g[_];
		int len[_], p[_], p2[_];
		int dfs(int u, int fa) {
			g[u].clear();
			len[u] = 0;
			int p = u;
			for(int v : d[u]) if(v != fa){
				int w = dfs(v, u);
				if(len[u] < len[v] + 1) {
					len[u] = len[v] + 1;
					p = w;
				}
				g[u].pb(node(len[v] + 1, v, w));
			}
			sort(g[u].begin(), g[u].end(), [&](node a, node b) { return a.ln > b.ln; });
			while(g[u].size() > 3) g[u].pop_back();
			while(g[u].size() < 3) g[u].pb(node(0, 0, u));
			if(d[u].size() == 1) return u;
			else return p;
		}
		void dfs2(int u, int fa, int ln, int k) {
			if(fa && ln && k) {
				g[u].pb(node(ln, fa, k));
				sort(g[u].begin(), g[u].end(), [&](node a, node b) { return a.ln > b.ln; });
			}
			while(g[u].size() > 3) g[u].pop_back();
			while(g[u].size() < 3) g[u].pb(node(0, 0, u));
			int nw = 0, nw2 = 0;
			for(int v : d[u]) if(v != fa) {
				nw = 0;
				if(g[u][0].v == v) nw = g[u][1].ln, nw2 = g[u][1].v2;
				else nw = g[u][0].ln, nw2 = g[u][0].v2;
				dfs2(v, u, nw + 1, nw2);
			}
		}
		void init() {
			dfs(1, 0), dfs2(1, 0, 0, 1);
		}
	}
	namespace CDQ {
		int as[_], tot;
		struct qry {
			int x, y, z, d, a, b, c; // a--u, b -- v, c -- w
			vector<pii> g;
			int pos[3];
			qry() {}
			qry(int X, int Y, int Z) {
				x = X, y = Y, z = Z;
				d = (x + y + z) / 2;
				a = d - z, b = d- y, c = d - x;
				g.pb({a, 0}), g.pb({b, 1}), g.pb({c, 2});
				sort(g.begin(), g.end(), [&](pii a, pii b) { return a > b; });
				F(i, 0, 2) pos[g[i].se] = i;
			}
		} qr[_];
		// find u, st. g[u][0] >= a, g[u][1] >= b, g[u][c] >= c
		struct node {
			int a, b, c, id;
		} t[_], qr2[_], T[_ << 1];
		void solve(int l, int r) {
			if(l == r) return;
			int mid = (l + r) >> 1;
			solve(l, mid), solve(mid + 1, r);
			int mx = -0x3f3f3f3f, Id = -1, R = r + 1;
			dF(i, mid, l) if(T[i].id < 0) {
				while(R - 1 >= mid + 1 && (T[R - 1].id < 0 || T[R - 1].b > T[i].b)) {
					R--;
					if(T[R].id > 0 && T[R].b > T[i].b) if(T[R].c > mx) { mx = T[R].c, Id = T[R].id; }
				}
				if(Id > 0 && mx > T[i].c) as[-T[i].id] = Id;
			}
			sort(T + l, T + r + 1, [&](node a, node b) { return (a.b == b.b) ? a.c < b.c : a.b < b.b; });
		}
		void init() {
			F(i, 1, n) t[i].a = HG::g[i][0].ln, t[i].b = HG::g[i][1].ln, t[i].c = HG::g[i][2].ln, t[i].id = i;
//			F(i, 1, n) cout << t[i].a << ' ' << t[i].b << '\n';
			F(i, 1, q) qr2[i].a = qr[i].g[0].fi, qr2[i].b = qr[i].g[1].fi - 1, qr2[i].c = qr[i].g[2].fi - 1, qr2[i].id = -i;
			F(i, 1, n) T[i] = t[i];
			tot = n;
			F(i, 1, q) T[++tot] = qr2[i];
			sort(T + 1, T + tot + 1, [&](node a, node b) {
				if(a.a == b.a) {
					if(a.b == b.b) return a.c < b.c;
					return a.b < b.b;
				} return a.a < b.a;
			});
			solve(1, tot);
		}
	}
	namespace Gas {
		int ans[_][3];
		void init() {
			F(i, 1, q) {
				int x = CDQ::as[i];
				F(j, 0, 2) {
					assert(x);
//					cout << i << " :: " << x <<"!!\n";
					assert(HG::g[x][j].ln >= CDQ::qr[i].g[j].fi);
					if(HG::g[x][j].ln == 0) {
						ans[i][j] = x;
					}
					else if(HG::g[x][j].v == Tree::f[0][x]) {
						ans[i][j] = (CDQ::qr[i].g[j].fi < Tree::dep[x]) ? Tree::jump(x, CDQ::qr[i].g[j].fi) : Tree::jump(HG::g[x][j].v2, HG::g[x][j].ln - CDQ::qr[i].g[j].fi);
//						assert(ans[i][j]);
						if(!ans[i][j]) {
							cout << CDQ::qr[i].g[j].fi << " " << Tree::dep[x] << " " << HG::g[x][j].ln << " " << HG::g[x][j].v2 << " " << x << "!!!!!\n";
						}
					} else {
						ans[i][j] = Tree::jump(HG::g[x][j].v2, HG::g[x][j].ln - CDQ::qr[i].g[j].fi);
						assert(ans[i][j]);
					}
				}
			}
			F(i, 1, q) cout << ans[i][CDQ::qr[i].pos[0]] << ' ' << ans[i][CDQ::qr[i].pos[1]] << ' ' << ans[i][CDQ::qr[i].pos[2]] << '\n';
		}
	}
} using namespace GAME;
bool Med;
signed main() {
	// Mry;
	n = ri();
	F(i, 1, n - 1) {
		int u = ri(), v  =ri();
		d[u].pb(v), d[v].pb(u);
	}
	Tree::init(), HG::init();
	q = ri();
	F(i, 1, q) {
		int x = ri(), y = ri(), z = ri();
		CDQ::qr[i] = CDQ::qry(x, y, z);
	}
	CDQ::init();
	Gas::init();
	// Try;
	return 0;
}