#include<bits/stdc++.h>
#define Yukinoshita namespace
#define Yukino std
using Yukinoshita Yukino;
int read()
{
	int s=0,w=1;
	char ch=getchar();
	while(ch<'0'||ch>'9') w=ch=='-'?-1:1,ch=getchar();
	while(ch>='0'&&ch<='9') s=s*10+ch-'0',ch=getchar();
	return s*w;
}
const int mxn=5e5+5;
int n;
vector<int> t[mxn];
int sz[mxn],son[mxn];
struct seg
{
	int l,r,v;
};
vector<seg> qwq;
void dfs0(int d,int fa)
{
	sz[d]=1;
	for(auto x:t[d])
		if(x!=fa)
			dfs0(x,d),sz[d]+=sz[x],son[d]=sz[x]>sz[son[d]]?x:son[d];
}
bool vis[mxn];
int f[mxn];
int L[mxn],R[mxn];
int find(int x)
{
	return f[x]==x?x:f[x]=find(f[x]);
}
void ins(int x,int v)
{
	vis[x]=1;
	L[x]=R[x]=x;
	if(vis[x-1])
	{
		int tp=find(x-1);
		f[tp]=x,L[x]=L[tp];
	}
	if(vis[x+1])
	{
		int tp=find(x+1);
		f[tp]=x,R[x]=R[tp];
	}
	if(L[x]!=R[x])
		qwq.push_back({L[x],R[x],v});
}
void ins(int d,int fa,int v)
{
	ins(d,v);
	for(auto x:t[d])
		if(x!=fa)
			ins(x,d,v);
}
void clear(int d,int fa)
{
	f[d]=d,vis[d]=0;
	for(auto x:t[d])
		if(x!=fa)
			clear(x,d);
}
void dfs(int d,int fa,int dis)
{
	for(auto x:t[d])
		if(x!=fa&&x!=son[d])
			dfs(x,d,dis+1),clear(x,d);
	if(son[d]) dfs(son[d],d,dis+1);
	ins(d,dis);
	qwq.push_back({d,d,dis});
	for(auto x:t[d])
		if(x!=fa&&x!=son[d])
			ins(x,d,dis);
}
int ans[mxn];
struct BIT
{
	#define lowbit(x) (x&-x)
	int t[mxn];
	int n;
	void add(int x,int v)
	{
		for(x=n-x+1;x<=n;x+=lowbit(x))
			t[x]=max(t[x],v);		
	}
	int ask(int x)
	{
		int mx=0;
		for(x=n-x+1;x;x-=lowbit(x))
			mx=max(mx,t[x]);
		return mx;
	}
}T2;
struct segment_tree
{
	struct seg
	{
		int l,r,mx; 
	}t[mxn*4];
	#define ls w<<1
	#define rs ls|1
	int wz[mxn];
	void build(int w,int l,int r)
	{
		t[w].l=l,t[w].r=r,t[w].mx=0;
		if(l<r)
		{
			int mid=l+r>>1;
			build(ls,l,mid);
			build(rs,mid+1,r);
		}
		else wz[l]=w;
	}
	void add(int w,int v)
	{
		for(w=wz[w];w;w>>=1)
			if(v>t[w].mx)
				t[w].mx=v;
			else break;
	}
	int ask(int w,int l,int r)
	{
		if(t[w].l>=l&&t[w].r<=r) return t[w].mx;
		int mx=0;
		if(t[ls].r>=l) mx=ask(ls,l,r);
		if(t[rs].l<=r) mx=max(mx,ask(rs,l,r));
		return mx;
	}
}T;
inline bool cmp1(seg &x,seg &y)
{
	return x.l<y.l;
}
struct que
{
	int l,r,k,id;
}qu[mxn];
bool cmp2(que x,que y)
{
	return x.r-x.k+1<y.r-y.k+1;
}
inline bool cmp3(seg &x,seg &y)
{
	return x.r-x.l>y.r-y.l;
}
bool cmp4(que x,que y)	
{
	return x.k>y.k;
}
int main()
{
//	system("fc out query4.ans");
	freopen("query.in","r",stdin);
	freopen("query.out","w",stdout);
	n=read();
	T2.n=n;
	int i,j,x,y;
	for(i=1;i<=n;i++)
		f[i]=i;
	for(i=1;i<n;i++)
	{
		x=read(),y=read();
		t[x].push_back(y);
		t[y].push_back(x);
	}
	dfs0(1,0),dfs(1,0,1);
//	cerr<<qwq.size()<<endl;
//	cerr<<qwq.size()<<endl;
//	for(auto x:qwq)
//		cout<<x.l<<' '<<x.r<<':'<<x.v<<endl;
	int q=read();
	for(i=1;i<=q;i++)
		qu[i].l=read(),qu[i].r=read(),qu[i].k=read(),qu[i].id=i;
		
	sort(qwq.begin(),qwq.end(),cmp1);
	sort(qu+1,qu+1+q,cmp2);
	for(i=1,j=0;i<=q;i++)
	{
		for(;j<qwq.size()&&qwq[j].l<=qu[i].r-qu[i].k+1;j++)
			T2.add(qwq[j].r,qwq[j].v);
		if(qu[i].r<n)
			ans[qu[i].id]=T2.ask(qu[i].r+1);
	}
	
	sort(qwq.begin(),qwq.end(),cmp3);
	sort(qu+1,qu+1+q,cmp4);
	T.build(1,1,n);
	for(i=1,j=0;i<=q;i++)
	{
		for(;j<qwq.size()&&qwq[j].r-qwq[j].l+1>=qu[i].k;j++)
			T.add(qwq[j].r,qwq[j].v);
		ans[qu[i].id]=max(ans[qu[i].id],T.ask(1,qu[i].l+qu[i].k-1,qu[i].r));
	}
	
	
	for(i=1;i<=q;i++)
		printf("%d\n",ans[i]);
		
	
//	while(q--)
//	{
//		int l=read(),r=read(),k=read(),mx=0;
//		if(q%1000==0) cerr<<q<<endl;
//		for(auto x:qwq)
//		{
//			if(x.r>r&&x.l<=r-k+1)
//				mx=max(mx,x.v);
//			if(x.r>=l+k-1&&x.r<=r&&(x.r-x.l+1)>=k)
//				mx=max(mx,x.v);
//		}
//		printf("%d\n",mx);	
//	}
}
/*
6
5 6
6 1
6 2
2 3
2 4
3
2 5 2
1 4 1
1 6 3
*/
