#include <bits/stdc++.h>
using namespace std;

//#pragma GCC optimize("O3,unroll-loops")
//#pragma GCC target("avx2,bmi,bmi2,lzcnt")

using ll = long long int;
using ull = unsigned long long int;
using vi = vector<ll>;
using ii = pair<ll,ll>;
using vii = vector<ii>;
using ld = long double;

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template<class T>
using ordered_set = tree < T, null_type, less<T>,
rb_tree_tag,
tree_order_statistics_node_update >;

#ifdef SA_DEBUG
template <class T>
void print(T a) {cerr << a << endl;}
template <class T, class... V> 
void print(T a, V... b) {cerr << a << ", "; print(b...);}
#define dbg(...) cerr << "[" << __LINE__ << "] " << #__VA_ARGS__ << " :: ", print(__VA_ARGS__)
#else
#define dbg(...) 7
#endif

#define eb emplace_back
#define fi first
#define se second

const ll INFL = 2e18;
const int INF = 1e9;
const double PI = acos(-1);
const ll mod = 1e9+7;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

template<class T, class V> 
ostream& operator << (ostream &s, pair<T, V> a){
	s << a.fi << ' ' << a.se; return s;
}

template<class T, class V> 
istream& operator >> (istream &s, pair<T, V> &a){
	s >> a.fi >> a.se; return s;
}

template<class T> 
ostream& operator << (ostream &s, vector<T> a){
	for(int i = 0; i < (int)a.size(); i++){
		if(i > 0)s << ' ' ; 
		s << a[i];
	} return s;
}

template<class T> 
istream& operator >> (istream &s, vector<T> &a){
	for(T &x : a)s >> x; 
	return s;
}

template<class T> 
void input(T a[], int l, int r, istream &s = cin){
	while(l <= r)s >> a[l++];
}

template<class T> 
void output(T a[], int l, int r, bool en = true, ostream &s = cout){
	while(l <= r){ s << a[l++];
		if(l <= r) s << ' ';
	} if(en)s << "\n";
}



const int N = 2e3+3, K = 13, M = 2e5 + 5;
//====================================================================//

ll st[N << 2];
void update(int k, int val, int n){
    k += n;
    st[k] = val;
    while(k > 1){
        st[k >> 1] = max(st[k], st[k ^ 1]);
        k >>= 1;
    }
}
ll query(int l, int r, int n){
    l += n, r += n + 1;
    ll ans = 0;
    while(l < r){
        if(l & 1)ans = max(ans, st[l++]);
        if(r & 1)ans = max(ans, st[--r]);
        l >>= 1;
        r >>= 1;
    }
    return ans;
}

ll dis[N];
ll D[N];
int up[N][K];
ll ans[M];
vector<ii> adj[N];
int tin[N], tout[N];
map<int, vector<int>> khuja[N];
vii khuja2[N];
int T;
void dfs(int ind, int par, ll d){
	up[ind][0] = par;
	for(int i = 1; i < K; i++){
		up[ind][i] = up[up[ind][i - 1]][i - 1];
	}
	tin[ind] = T++;
	dis[ind] = d;
	D[ind] = d;
	for(auto [x, w] : adj[ind]){
		if(x == par)continue;
		dfs(x, ind, d + w);
		dis[ind] = max(dis[ind], dis[x]);
	}
	
	tout[ind] = T++;
}

#define isanc(u,v) (tin[u] <= tin[v] && tout[u] >= tout[v])

ii LCA(int u, int v){
	if(isanc(u, v))return {u, u};
	for(int i = K - 1; i >= 0; i--){
		if(!isanc(up[u][i], v))u = up[u][i];
	}
	return {up[u][0], u};
}
int cnt[N], tim = 0;

void fetch(int ind, int par, ll val){
	ii mx1 = {-1, -1};
	ii mx2 = {-1, -1};
	for(auto [x, y] : adj[ind]){
		if(x == par)continue;
		if(mx1.fi < dis[x]){
			mx2 = mx1;
			mx1 = {dis[x], x};
		}else if(mx2.fi < dis[x]){
			mx2 = {dis[x], x};
		}
	}
	for(auto [x, y] : adj[ind]){
		if(x == par)continue;
		ll temp = val;
		ll t2 = -INFL;
		if(mx1.se != x)t2 = max(t2, mx1.fi);
		if(mx2.se != x)t2 = max(t2, mx2.fi);
		temp = max(temp, t2);
		cnt[ind] = tim;
		update(tim++, t2 - 2 * D[ind], N);
		fetch(x, ind, temp);
		update(--tim, -INFL, N);
		for(auto z : khuja[ind][x]){
			ans[z] = max(temp, ans[z]);
		}
	}
	khuja[ind].clear();
	ll t2 = dis[ind] - 2 * D[ind];
	for(auto [l, idx] : khuja2[ind]){
		ll gt = max(t2, query(cnt[l], tim - 1, N));
		//dbg(gt);
		ans[idx] = max(ans[idx], gt + 2 * D[l]);
	}
	khuja2[ind].clear();
}
void testcase(){
	int n, q;
	cin >> n >> q;
	ll tot = 0;
	for(int i = 1; i < n; i++){
		int x, y, z;
		cin >> x >> y >> z;
		adj[x].eb(y, z);
		adj[y].eb(x, z);
		tot += 2 * z;
	}
	
	vector<vector<tuple<int, int, int>>> qr(n + 1);
	for(int i = 0; i < q; i++){
		int s, k, t;
		cin >> s >> k >> t;
		qr[s].eb(k, t, i);
	}
	for(int i = 1; i <= n; i++){
		if(qr[i].empty())continue;
		T = 0;
		dfs(i, i, 0);
		for(auto [k, t, idx] : qr[i]){
			auto [l, l2] = LCA(k, t);
			
			if(l == k){
				ans[idx] = dis[i];
				continue;
			}
			if(l == t){
				ans[idx] = -1;
				continue;
			}
			assert(isanc(l, l2));
			assert(isanc(l2, k));
			assert(isanc(l, t));
			assert(!isanc(l2, t));
			khuja[l][l2].eb(idx);
			khuja2[k].eb(l, idx);
			
		}
		
		fetch(i, i, -1);
	}
	
	for(int i = 0; i < q; i++){
		if(ans[i] == -1)cout << "impossible\n";
		else {
			cout << tot - ans[i] << "\n";
		}
	}
}





int main(){
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	
	int TT = 1;
	//cin >> T;
	
	for(int qq = 1; qq <= TT; ++qq){
		//cout << "Case #" << qq << ": ";
		testcase();
	}
	return 0;
}
/*
6 1597352862016328480
*/