#include <bits/stdc++.h>
#define pb emplace_back
#define fst first
#define scd second
#define mems(a, x) memset((a), (x), sizeof(a))

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ldb;
typedef pair<int, int> pii;
typedef priority_queue< pii, vector<pii>, greater<pii> > pqi;

#define getchar() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++)
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline int read() {
    char c = getchar();
    int x = 0;
    for (; !isdigit(c); c = getchar()) ;
    for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
    return x;
}

void write(int x) {
	if (x > 9) {
		write(x / 10);
	}
	putchar('0' + x % 10);
}

const int maxn = 200100;
const int logn = 20;

int n, m, head[maxn], len, ans[maxn], ff[maxn][logn];
int dep[maxn], fa[maxn], sz[maxn], son[maxn], top[maxn];
bool vis[maxn];
pqi pq[maxn];

struct node {
	int x, y, z, id, u, v, w, op;
} a[maxn * 5], b[maxn * 5];

inline bool cmp(node a, node b) {
	if (a.x != b.x) {
		return a.x > b.x;
	} else if (a.y != b.y) {
		return a.y > b.y;
	} else if (a.z != b.z) {
		return a.z > b.z;
	} else {
		return a.op < b.op;
	}
}

inline bool cmp2(node a, node b) {
	return a.op < b.op || (a.op == b.op && a.id < b.id);
}

struct edge {
	int to, next;
} edges[maxn << 1];

void add_edge(int u, int v) {
	edges[++len].to = v;
	edges[len].next = head[u];
	head[u] = len;
}

inline pii getmx(pqi pq) {
	pii mx = make_pair(-1, -1);
	while (pq.size()) {
		mx = max(mx, pq.top());
		pq.pop();
	}
	return mx;
}

void dfs(int u, int fa) {
	pq[u].push(make_pair(0, u));
	pq[u].push(make_pair(0, u));
	pq[u].push(make_pair(0, u));
	for (int i = head[u]; i; i = edges[i].next) {
		int v = edges[i].to;
		if (v == fa) {
			continue;
		}
		ff[v][0] = u;
		dfs(v, u);
		pii t = getmx(pq[v]);
		++t.fst;
		pq[u].push(t);
		while ((int)pq[u].size() > 3) {
			pq[u].pop();
		}
	}
}

void dfs2(int u, int fa, pii d) {
	// printf("u, d: %d %d\n", u, d);
	vector<int> son;
	for (int i = head[u]; i; i = edges[i].next) {
		int v = edges[i].to;
		if (v == fa) {
			continue;
		}
		son.pb(v);
	}
	pq[u].push(d);
	while ((int)pq[u].size() > 3) {
		pq[u].pop();
	}
	if (son.empty()) {
		return;
	}
	int len = (int)son.size();
	vector<pii> pre(len), suf(len);
	pre[0] = getmx(pq[son[0]]);
	for (int i = 1; i < len; ++i) {
		pre[i] = max(pre[i - 1], getmx(pq[son[i]]));
	}
	suf[len - 1] = getmx(pq[son[len - 1]]);
	for (int i = len - 2; ~i; --i) {
		suf[i] = max(suf[i + 1], getmx(pq[son[i]]));
	}
	for (int i = 0; i < len; ++i) {
		int v = son[i];
		pii mx = make_pair(-1, -1);
		if (i) {
			mx = max(mx, pre[i - 1]);
		}
		if (i + 1 < len) {
			mx = max(mx, suf[i + 1]);
		}
		++mx.fst;
		// printf("u, v: %d %d %d\n", u, v, mx);
		pii t = max(mx, d);
		++t.fst;
		dfs2(v, u, t);
	}
}

int dfs3(int u, int f, int d) {
	fa[u] = f;
	sz[u] = 1;
	dep[u] = d;
	int maxson = -1;
	for (int i = head[u]; i; i = edges[i].next) {
		int v = edges[i].to;
		if (v == f) {
			continue;
		}
		sz[u] += dfs3(v, u, d + 1);
		if (sz[v] > maxson) {
			son[u] = v;
			maxson = sz[v];
		}
	}
	return sz[u];
}

void dfs4(int u, int tp) {
	top[u] = tp;
	vis[u] = 1;
	if (!son[u]) {
		return;
	}
	dfs4(son[u], tp);
	for (int i = head[u]; i; i = edges[i].next) {
		int v = edges[i].to;
		if (vis[v]) {
			continue;
		}
		dfs4(v, v);
	}
}

inline int qlca(int x, int y) {
	while (top[x] != top[y]) {
		if (dep[top[x]] < dep[top[y]]) {
			swap(x, y);
		}
		x = fa[top[x]];
	}
	if (dep[x] > dep[y]) {
		swap(x, y);
	}
	return x;
}

inline int qdis(int x, int y) {
	return dep[x] + dep[y] - dep[qlca(x, y)] * 2;
}

inline int jump(int x, int k) {
	if (!k) {
		return x;
	}
	for (int i = 18; ~i; --i) {
		if (k & (1 << i)) {
			x = ff[x][i];
		}
	}
	return x;
}

inline int kth(int x, int y, int k) {
	int lca = qlca(x, y), dis = qdis(x, y);
	if (k <= dep[x] - dep[lca]) {
		return jump(x, k);
	} else {
		return jump(y, dis - k);
	}
}

namespace BIT {
	int c[maxn];
	
	inline void update(int x, int d) {
		for (int i = (++x); i; i -= (i & (-i))) {
			c[i] = max(c[i], d);
		}
	}
	
	inline int query(int x) {
		int res = 0;
		for (int i = (++x); i <= n + 1; i += (i & (-i))) {
			res = max(res, c[i]);
		}
		return res;
	}
	
	inline void clear(int x) {
		for (int i = (++x); i; i -= (i & (-i))) {
			c[i] = 0;
		}
	}
}

void cdq(int l, int r) {
	if (l >= r) {
		return;
	}
	int mid = (l + r) >> 1, p1 = l, p2 = mid + 1, tot = 0;
	cdq(l, mid);
	cdq(mid + 1, r);
	while (p1 <= mid && p2 <= r) {
		if (a[p1].y >= a[p2].y) {
			if (a[p1].op == 0) {
				BIT::update(a[p1].z, a[p1].id);
			}
			b[++tot] = a[p1++];
		} else {
			if (a[p2].op == 1) {
				ans[a[p2].id] = max(ans[a[p2].id], BIT::query(a[p2].z));
			}
			b[++tot] = a[p2++];
		}
	}
	while (p1 <= mid) {
		if (a[p1].op == 0) {
			BIT::update(a[p1].z, a[p1].id);
		}
		b[++tot] = a[p1++];
	}
	while (p2 <= r) {
		if (a[p2].op == 1) {
			ans[a[p2].id] = max(ans[a[p2].id], BIT::query(a[p2].z));
		}
		b[++tot] = a[p2++];
	}
	for (int i = l; i <= mid; ++i) {
		if (a[i].op == 0) {
			BIT::clear(a[i].z);
		}
	}
	for (int i = 1; i <= tot; ++i) {
		a[l + i - 1] = b[i];
	}
}

void solve() {
	n = read();
	for (int i = 1, u, v; i < n; ++i) {
		u = read();
		v = read();
		add_edge(u, v);
		add_edge(v, u);
	}
	dfs(1, -1);
	dfs2(1, -1, make_pair(0, 1));
	dfs3(1, -1, 1);
	dfs4(1, 1);
	for (int j = 1; (1 << j) <= n; ++j) {
		for (int i = 1; i <= n; ++i) {
			ff[i][j] = ff[ff[i][j - 1]][j - 1];
		}
	}
	for (int i = 1; i <= n; ++i) {
		a[i].id = i;
		a[i].op = 0;
		a[i].x = pq[i].top().fst;
		a[i].u = pq[i].top().scd;
		pq[i].pop();
		a[i].y = pq[i].top().fst;
		a[i].v = pq[i].top().scd;
		pq[i].pop();
		a[i].z = pq[i].top().fst;
		a[i].w = pq[i].top().scd;
		swap(a[i].x, a[i].z);
		swap(a[i].u, a[i].w);
		// printf("%d %d %d\n", a[i].x, a[i].y, a[i].z);
		// printf("%d %d %d %d %d %d\n", a[i].x, a[i].y, a[i].z, a[i].u, a[i].v, a[i].w);
	}
	m = read();
	for (int i = 1, x, y, z; i <= m; ++i) {
		x = read();
		y = read();
		z = read();
		a[i + n].x = (x + y - z) / 2;
		a[i + n].y = (x + z - y) / 2;
		a[i + n].z = (y + z - x) / 2;
		a[i + n].u = x;
		a[i + n].v = y;
		a[i + n].w = z;
		vector<int> vc;
		vc.pb(a[i + n].x);
		vc.pb(a[i + n].y);
		vc.pb(a[i + n].z);
		sort(vc.begin(), vc.end(), greater<int>());
		a[i + n].x = vc[0];
		a[i + n].y = vc[1];
		a[i + n].z = vc[2];
		// printf("%d %d %d\n", a[i + n].x, a[i + n].y, a[i + n].z);
		a[i + n].id = i;
		a[i + n].op = 1;
	}
	sort(a + 1, a + n + m + 1, cmp);
	cdq(1, n + m);
	sort(a + 1, a + n + m + 1, cmp2);
	// for (int i = 1; i <= m; ++i) {
		// printf("%d\n", ans[i]);
	// }
	for (int i = 1; i <= m; ++i) {
		int k = ans[i];
		// printf("k: %d\n", k);
		// printf("%d %d %d\n", a[k].x, a[k].y, a[k].z);
		int u = a[k].u, v = a[k].v, w = a[k].w;
		// printf("u, v, w: %d %d %d\n", u, v, w);
		u = kth(k, u, a[i + n].x);
		v = kth(k, v, a[i + n].y);
		w = kth(k, w, a[i + n].z);
		int x = a[i + n].u, y = a[i + n].v, z = a[i + n].w;
		vector<int> vc;
		vc.pb(u);
		vc.pb(v);
		vc.pb(w);
		sort(vc.begin(), vc.end());
		bool flag = 1;
		do {
			u = vc[0];
			v = vc[1];
			w = vc[2];
			if (qdis(u, v) == x && qdis(u, w) == y && qdis(v, w) == z) {
				write(u);
				putchar(' ');
				write(v);
				putchar(' ');
				write(w);
				putchar('\n');
				flag = 0;
				break;
			}
		} while (next_permutation(vc.begin(), vc.end()));
		if (flag) {
			// printf("i: %d\n", i);
		}
	}
}

int main() {
	int T = 1;
	// scanf("%d", &T);
	while (T--) {
		solve();
	}
	return 0;
}