#include <bits/stdc++.h>
#define fst first
#define snd second
#define fore(i,a,b) for(int i=a,ThxDem=b;i<ThxDem;++i)
#define pb push_back
#define ALL(s) s.begin(),s.end()
#define FIN ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define SZ(s) int(s.size())
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;

struct STree{
	vector<ll> t; int n;
	STree(int n):n(n),t(2*n+5,-1e18){}
	void upd(int p, ll v){
		p+=n;
		for(t[p]=v;p>1;p>>=1) t[p>>1]=max(t[p],t[p^1]);
	}
	ll query(int l, int r){ // [l, r)
		ll res=-1e18;
		for(l+=n,r+=n;l<r;l>>=1,r>>=1){
			if(l&1) res=max(res,t[l++]);
			if(r&1) res=max(res,t[--r]);
		}
		return res;
	}
};

const int K=11, MAXN=1<<K;
vector<ii> g[MAXN];
vector<pair<ii,int>> op[MAXN];
int idd,in[MAXN],sz[MAXN],bad[200010],par[MAXN],n;
ll pt[MAXN],ans[200010],wh[MAXN][MAXN];

int F[K][1<<K],D[1<<K];
void lca_dfs(int x){
	fore(i,0,g[x].size()){
		int y=g[x][i].fst;if(y==F[0][x])continue;
		F[0][y]=x;D[y]=D[x]+1;lca_dfs(y);
	}
}
void lca_init(int rt){
	D[rt]=0;F[0][rt]=-1;
	lca_dfs(rt);
	fore(k,1,K)fore(x,0,n)
		if(F[k-1][x]<0)F[k][x]=-1;
		else F[k][x]=F[k-1][F[k-1][x]];
}
int lca(int x, int y){
	if(D[x]<D[y])swap(x,y);
	for(int k=K-1;k>=0;--k)if(D[x]-(1<<k)>=D[y])x=F[k][x];
	if(x==y)return x;
	for(int k=K-1;k>=0;--k)if(F[k][x]!=F[k][y])x=F[k][x],y=F[k][y];
	return F[0][x];
}
int jump(int x, int k){
	fore(i,0,K) if(k&(1<<i)) x=F[i][x];
	return x;
}

int dfs(int pos, int p=-1, ll d=0){
	sz[pos]=1; in[pos]=idd++; par[pos]=p;
	pt[pos]=d;
	for(auto x:g[pos]) if(x.fst!=p) sz[pos]+=dfs(x.fst,pos,d+x.snd);
	return sz[pos];
}

int has(int x, int y){
	return in[x] <= in[y] && in[y]<in[x]+sz[x];
}

void doit(int s){
	idd=0; dfs(s);
	
	ll tot=0;
	fore(i,0,n) for(auto x:g[i]) tot+=x.snd;
	
	STree st(n);
	fore(i,0,n) st.upd(in[i],pt[i]);
	lca_init(s);
	
	fore(i,0,n) for(auto xx:g[i]){
		int x=xx.fst;
		if(!has(x,i)){
			ll bst=max(st.query(in[i],in[x]), st.query(in[x]+sz[x],in[i]+sz[i]));
			wh[i][x]=bst-2ll*pt[i];
		}
	}
	
	fore(i,0,n) wh[i][i]=st.query(in[i],in[i]+sz[i])-2ll*pt[i];
	
	for(auto pp:op[s]){
		int me=pp.fst.fst, he=pp.fst.snd, id=pp.snd;
		
		//imposible
		if(has(he,me)){
			bad[id]=1;
			continue;
		}
		
		//puedo cualquiera
		if(has(me,he)){
			ans[id]=tot-st.query(0,n);
			continue;
		}
		
		//cualquiera que no vaya desde el lca hasta me
		int lc=lca(me,he);
		int low=jump(me, D[me]-D[lc]-1);
		ll bst=max(st.query(0,in[low]), st.query(in[low]+sz[low],n));
		
		//en el camino desde el lca hasta me, cualquiera sin el subarbol de me
		
		
		//en el subarbol de me + el camino desde el lca a la raiz - lo del medio
		int pre=me,now=me;
		while(now!=lc){
			ll val=wh[now][pre]+2*pt[lc];
			bst=max(bst, val);
			pre=now;
			now=par[now];
		}
		
		ans[id]=tot-bst;
	}
}

int main(){FIN;
	int q; cin>>n>>q;
	fore(i,1,n){
		int x,y,w; cin>>x>>y>>w; x--; y--;
		g[x].pb({y,w}); g[y].pb({x,w});
	}
	
	fore(i,0,q){
		int s,k,t; cin>>s>>k>>t; s--; k--; t--;
		op[s].pb({{k,t},i});
	}
	
	fore(i,0,n) doit(i);
	
	fore(i,0,q){
		if(bad[i])cout<<"impossible\n";
		else cout<<ans[i]<<"\n";
	}
}