#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, leaves;
    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);
        }
        if(g[v].size() <= 1) leaves.push_back(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);
        leaves.reserve(N);
        dfs(root, root);
        rmq = rmq_t(rev);
    }
    int lca(int u, int v) const {
        u = in[u], v = in[v];
        if(u > v) swap(u, v);
        return rmq.query(u, v+1).second;
    }
    int lca_root(int root, int u, int v){
        return lca(root, u) ^ lca(root, v) ^ lca(u, v);
    }
    int64_t dist(int u, int v) const {
        int l = lca(u, v);
        return prof[u] + prof[v] - 2 * prof[l];
    }
    bool is_ancestor(int a, int b) const {
        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<vector<int>> lca(n, vector<int>(n));
    lca_t mylca(g);
    {
        for(int i =0; i <n; i++)
            for(int j =i; j <n; j++)
                lca[i][j] = lca[j][i] = mylca.lca(i, j);
    }
    auto get_lca = [&](int root, int i, int j){
        return lca[root][i] ^ lca[root][j] ^ lca[i][j];
    };
    map<tuple<int, int, int>, int64_t> memo;
    while(q--){
        int start, key, trap;
        cin>>start>>key>>trap;
        start--, key--, trap--;
        if(get_lca(start, key, trap) == trap){
            cout<<"impossible\n";
            continue;
        }
        int64_t answer = 3*all_edges;
        for(int e : mylca.leaves){
            int a = get_lca(start, e, key);
            int b = get_lca(start, e, trap);
            int64_t cur =  2*all_edges - mylca.dist(start, e);
            if(get_lca(start, a, b) == b)
                cur += 2*mylca.dist(a, b);
            answer = min(answer, cur);
        }
        cout<<answer<<"\n";
    }
    return 0;
}