#include <bits/stdc++.h>
using namespace std;
#define For(Ti,Ta,Tb) for(auto Ti=(Ta);Ti<=(Tb);++Ti)
#define Dec(Ti,Ta,Tb) for(auto Ti=(Ta);Ti>=(Tb);--Ti)
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define range(Tx) begin(Tx),end(Tx)
using ll=long long;
const int N=2e5+5;
int n,q,vis[N],siz[N],mxsiz[N];
vector<int> e[N];
struct Query{
	int u,v,k;
}qry[N];
int ans[N];
void get_root(int u,int fa,int tot,int& rt){
	siz[u]=1;
	mxsiz[u]=0;
	for(int v:e[u]){
		if(v!=fa&&!vis[v]){
			get_root(v,u,tot,rt);
			siz[u]+=siz[v];
			mxsiz[u]=max(mxsiz[u],siz[v]);
		}
	}
	mxsiz[u]=max(mxsiz[u],tot-siz[u]);
	if(!rt||mxsiz[u]<mxsiz[rt]){
		rt=u;
	}
}
int bel[N];
vector<int> deps[N],nxt_qs[N];
void fill(int u,int fa,int d,int rt){
	if(int(deps[rt].size())<=d){
		deps[rt].resize(d+1);
	}
	++deps[rt][d];
	bel[u]=rt;
	for(int v:e[u]){
		if(v!=fa){
			fill(v,u,d+1,rt);
		}
	}
}
namespace Solver{
	int fa[N],dep[N],son[N],hson[N],siz[N],mxdep[N];
	vector<int> e[N],poi;
	struct Query{
		int id,v,k;
	}qry[N];
	void dfs(int u){
		poi.push_back(u);
		dep[u]=dep[fa[u]]+1;
		siz[u]=1;
		for(int v:e[u]){
			if(v!=fa[u]&&!vis[v]){
				fa[v]=u;
				dfs(v);
				mxdep[u]=max(mxdep[u],mxdep[v]+1);
				siz[u]+=siz[v];
				if(mxdep[v]>=mxdep[son[u]]) son[u]=v;
				if(siz[v]>siz[hson[u]]) hson[u]=v;
			}
		}
	}
	int top[N],dfn[N],dfx,rk[N];
	void dfs2(int u,int tp){
		top[u]=tp;
		rk[dfn[u]=++dfx]=u;
		if(hson[u]) dfs2(hson[u],tp);
		for(int v:e[u]){
			if(v!=fa[u]&&v!=hson[u]&&!vis[v]){
				dfs2(v,v);
			}
		}
	}
	vector<tuple<int,int,int>> qs[N];
	vector<pair<int,int>> hldqs[N];
	int *f[N],buff[N*2],*cur;
	void dfs3(int u){
		if(son[u]) f[son[u]]=f[u]+1,dfs3(son[u]);
		for(int v:e[u]){
			if(v!=fa[u]&&v!=son[u]&&!vis[v]){
				f[v]=cur,cur+=mxdep[v]+1;
				dfs3(v);
				For(i,0,mxdep[v]) f[u][i+1]+=f[v][i];
			}
		}
		if(son[u]) f[u][0]=f[u][1]+1;
		else f[u][0]=1;
		for(auto [id,k,w]:qs[u]){
			ans[qry[id].id]+=w*(f[u][0]-(k<mxdep[u]?f[u][k+1]:0));
		}
	}
	void solve(int q,int rt){
		dfs(rt);
		dfs2(rt,rt);
		For(i,1,q){
			ans[i]=dep[qry[i].v]-1;
			if(!qry[i].k){
				++ans[qry[i].id];
				continue;
			}
			qs[qry[i].v].emplace_back(i,qry[i].k,1);
			for(int u=qry[i].v;u>1;u=top[u]){
				hldqs[fa[u]].emplace_back(i,1);
				qs[u].emplace_back(i,qry[i].k-1,-1);
				qs[hson[fa[u]]].emplace_back(i,qry[i].k-1,1);
				u=fa[u];
			}
		}
		vector<int> val;
		for(int i:poi){
			int cnt=0;
			for(int v:e[i]){
				if(v!=fa[i]){
					++cnt;
				}
			}
			if(!cnt){
				vector<int> pth;
				for(int u=i;u!=top[u];u=fa[u]) pth.push_back(u);
				pth.push_back(top[i]);
				reverse(range(pth));
				val.clear();
				int ssiz=0;
				for(int u:pth){
					for(int v:e[u]){
						if(v!=hson[u]){
							val.resize(max<int>(val.size(),mxdep[v]+1));
							For(j,dfn[v],dfn[v]+siz[v]-1){
								int x=rk[j];
								++ssiz;
								val[dep[x]-dep[v]]+=siz[x];
							}
						}
					}
					for(auto [id,w]:hldqs[u]){
						int k=qry[id].k;
						ans[qry[id].id]+=w*(ssiz-(k<int(val.size())?val[k]:0));
					}
				}
			}
		}
		f[rt]=cur=buff;
		cur+=mxdep[rt]+1;
		dfs3(rt);
		for(int u:poi){
			fa[u]=son[u]=hson[u]=mxdep[u]=0;
			e[u].clear();
			qs[u].clear();
			hldqs[u].clear();
		}
		poi.clear();
		dfx=0;
	}
}
void solve(int u,const vector<int>& qs){
	int rt=0;
	get_root(u,0,siz[u],rt);
	u=rt;
	vis[u]=1;
	bel[u]=u;
	deps[u]={1};
	vector<int> vec{1};
	for(int v:e[u]){
		if(!vis[v]){
			fill(v,u,1,v);
			if(vec.size()<deps[v].size()){
				vec.resize(deps[v].size());
			}
			For(i,1,int(deps[v].size())-1){
				deps[v][i]+=deps[v][i-1];
			}
			For(i,0,int(deps[v].size())-1){
				vec[i]+=deps[v][i];
			}
		}
	}
	int qcnt=0;
	for(int i:qs){
		auto [u,v,k]=qry[i];
		if(bel[u]!=bel[v]||(bel[u]==rt&&bel[v]==rt)){
			ans[i]-=int(vec.size())>k?vec[k]:0;
			Solver::qry[++qcnt]={i,u,k};
			Solver::qry[++qcnt]={i,v,k};
		}else{
			nxt_qs[bel[u]].push_back(i);
		}
	}
	Solver::solve(qcnt,u);
	deps[u].clear();
	for(int v:e[u]){
		if(!vis[v]){
			deps[v].clear();
		}
	}
	for(int v:e[u]){
		if(!vis[v]){
			solve(v,nxt_qs[v]);
		}
	}
}
int main(){
	cin.tie(nullptr)->sync_with_stdio(false);
	cin>>n;
	For(i,1,n-1){
		int u,v;
		cin>>u>>v;
		e[u].push_back(v);
		e[v].push_back(u);
	}
	siz[1]=n;
	vector<int> qs;
	cin>>q;
	For(i,1,q){
		cin>>qry[i].u>>qry[i].v>>qry[i].k;
		qs.push_back(i);
	}
	solve(1,qs);
	For(i,1,q) cout<<ans[i]<<'\n';
	return 0;
}