#include<bits/stdc++.h>

using namespace std;

template<typename T, typename Cmp = less<T>>
struct rmq_t : private Cmp{
    int N = 0;
    vector<vector<T>> table;
    const T& min(const T& a, const T &b) const{ 
        return Cmp::operator()(a,b) ? a : b;
    }
    rmq_t(){}
    rmq_t(const vector<T>& values): N(int(values.size())), table(__lg(N)+1){
        table[0] = values;
        for(int a=1; a < int(table.size()); ++a){
            table[a].resize(N - (1<<a) + 1);
            for(int b = 0; b + (1<<a) <= N; ++b)
                table[a][b] = min(table[a-1][b], table[a-1][b+(1<<(a-1))]);
        }
    }
    T query(int a, int b) const {
        int lg = __lg(b-a);
        return min(table[lg][a], table[lg][b-(1<<lg)]);
    }
};

struct lca_t{
    int N = 0;
    vector<vector<pair<int64_t, int>>> g;
    vector<int> in, out;
    vector<int64_t> prof;
    vector<pair<int, int>> rev;
    rmq_t<pair<int, int>> rmq;
    void dfs(int v, int p){
        in[v] = (int) rev.size();
        rev.emplace_back(in[v], v);
        for(auto [w, u] : g[v]) if(u != p){
            prof[u] = prof[v] + w;
            dfs(u, v);
            rev.emplace_back(in[v], v);
        }
        out[v] = (int) rev.size();
        rev.emplace_back(in[v], v);
    }
    lca_t(){}
    lca_t(const auto & adj, int root = 0) : N(int(adj.size())), in(N), out(N), prof(N), g(adj){
        rev.reserve(3*N);
        dfs(root, root);
        rmq = rmq_t(rev);
    }
    int lca(int u, int v){
        u = in[u], v = in[v];
        if(u > v) swap(u, v);
        return rmq.query(u, v+1).second;
    }
    int64_t dist(int u, int v){
        int l = lca(u, v);
        return prof[u] + prof[v] - 2 * prof[l];
    }
    bool is_ancestor(int a, int b){
        return in[a] < in[b] && out[a] > out[b];
    }
};


int main(){
    cin.tie(0)->sync_with_stdio(false);
    int n, q;
    cin>>n>>q;
    int64_t all_edges = 0;
    vector<vector<pair<int64_t, int>>> g(n);
    for(int e =0; e < n-1; e++){
        int u, v; int64_t w;
        cin>>u>>v>>w;
        all_edges += w;
        u--, v--;
        g[u].emplace_back(w,v);
        g[v].emplace_back(w,u);
    }
    vector<lca_t> lcas(n);
    for(int r = 0; r < n; r++){
        lcas[r] = lca_t(g, r);
    }
    while(q--){
        int start, key, trap;
        cin>>start>>key>>trap;
        start--, key--, trap--;
        if(lcas[start].is_ancestor(trap, key)){
            cout<<"impossible\n";
            continue;
        }
        int64_t answer = 3*all_edges;
        for(int e = 0; e < n; e++){
            int a = lcas[start].lca(e, key);
            int b = lcas[start].lca(e, trap);
            int64_t cur =  2*all_edges - lcas[start].prof[e];
            if(lcas[start].is_ancestor(b, a))
                cur += 2*lcas[start].dist(a, b);
            // cout<<" end "<<e+1<<" = "<<cur<<"\n\t";
            // cout<<lcas[start].prof[e]<<" "<<lcas[start].dist(a, b)<<"\n";
            answer = min(answer, cur);
        }
        cout<<answer<<"\n";
    }
    return 0;
}