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

using i64 = long long;
using u64 = unsigned long long;

struct debug {
#define contPrint { *this << "["; \
        int f = 0; for(auto it : x) { *this << (f?", ":""); *this << it; f = 1;} \
        *this << "]"; return *this;}
 
    ~debug(){cerr << endl;}
    template<class c> debug& operator<<(c x) {cerr << x; return *this;}
    template<class c, class d>
    debug& operator<<(pair<c, d> x) {*this << "(" << x.first << ", " << x.second << ")"; 
        return *this;}
    template<class c> debug& operator<<(vector<c> x) contPrint;
#undef contPrint
};

#define dbg(x) "[" << #x << ": " << x << "]  "
#define Wa() cerr << "[LINE: " << __LINE__ << "] -> "; debug() << 
#define FASTIO ios_base::sync_with_stdio(false); cin.tie(NULL);

const int N = 2002;
vector<pair<int, int>> G[N];
int max_path[N][N];
i64 max_path_cost[N][N][2];
int edge_cost[N][N];
int P[N][N];

i64 dfs(int cur, int root, int p)
{
    i64 mx = 0;
    i64 mx2 = 0;
    i64 which = -1;
    P[root][cur] = p;

    for(auto it : G[cur]) {
        if(it.first != p) {
            i64 x = dfs(it.first, root, cur) + it.second;
            if(x >= mx) {
                mx2 = mx;
                mx = x;
                which = it.first;
            } else if(x >= mx2) {
                mx2 = x;
            }
        }
    }
    max_path[root][cur] = which;
    max_path_cost[root][cur][0] = mx;
    max_path_cost[root][cur][1] = mx2;

    return mx;
}

int main() 
{
    int n, q;
    scanf("%d %d", &n, &q);

    i64 tot_cost = 0;

    for(int i = 1; i < n; i++) {
        int u, v, w;
        scanf("%d %d %d", &u, &v, &w);
        G[u].push_back({v, w});
        G[v].push_back({u, w});
        edge_cost[u][v] = w;
        edge_cost[v][u] = w;
        tot_cost += w + w;
    }

    for(int i = 1; i <= n; i++) dfs(i, i, 0);

    int stk[N];
    int idx = 0;

    int vis[N];
    memset(vis, 0, sizeof vis);

    while(q--) {
        int root, key, trap;
        scanf("%d %d %d", &root, &key, &trap);

        int cur = key;
        while(cur != root) {
            stk[idx++] = cur;
            vis[cur] = 1;
            cur = P[root][cur];
        }
        stk[idx++] = cur;
        vis[cur] = 1;

        if(vis[trap]) {
            puts("impossible");
        } else {
            int lca = trap;
            while(!vis[lca]) {
                lca = P[root][lca];
            }

            i64 key_to_lca_cost = 0;
            cur = key;
            while(cur != lca) {
                key_to_lca_cost += edge_cost[cur][P[root][cur]];
                cur = P[root][cur];
            }

            i64 lca_to_root_cost = 0;
            cur = lca;
            while(cur != root) {
                lca_to_root_cost += edge_cost[cur][P[root][cur]];
                cur = P[root][cur];
            }

            i64 ans = 1e18;
            cur = key;
            int prv = cur;
            bool lca_found = false;

            if(cur == lca) {
                lca_found = true;
            }

            while(cur != root) {
                if(max_path[root][cur] != prv) {
                    ans = min(ans, tot_cost + key_to_lca_cost - max_path_cost[root][cur][0] - lca_to_root_cost);
                } else {
                    ans = min(ans, tot_cost + key_to_lca_cost - max_path_cost[root][cur][1] - lca_to_root_cost);
                }

                prv = cur;
                cur = P[root][cur];

                if(!lca_found) {
                    key_to_lca_cost -= edge_cost[prv][cur];
                } else {
                    lca_to_root_cost -= edge_cost[prv][cur];
                }

                if(cur == lca) {
                    lca_found = true;
                }
            }
            if(max_path[root][cur] != prv) {
                ans = min(ans, tot_cost + key_to_lca_cost - max_path_cost[root][cur][0] - lca_to_root_cost);
            } else {
                ans = min(ans, tot_cost + key_to_lca_cost - max_path_cost[root][cur][1] - lca_to_root_cost);
            }

            printf("%lld\n", ans);

        }

        while(idx > 0) {
            vis[stk[--idx]] = 0;
        }
    }
}