#include <bits/stdc++.h>
#define sz(v) (int)v.size()
#define all(v) v.begin(), v.end()

using namespace std;
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;

template<class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
    for (auto x : v) os << x << ' ';
    os << '\n';
    return os;
}

void solve() {
    int n,q; cin >> n >> q;

    ll distAll = 0;
    vector<vector<pair<int, ll>>> g(n);
    for (int i = 0; i < n - 1; i++) {
        int u,v,w; cin >> u >> v >> w; u--; v--;
        g[u].emplace_back(v, w);
        g[v].emplace_back(u, w);
        distAll += w;
    }

    distAll *= 2;

    vector<vector<int>> moveTo(n, vector<int>(n, -1));
    vector<vector<int>> moveFrom(n, vector<int>(n, -1));
    for (int root = 0; root < n; root++) {
        function<void(int, int)> dfs = [&](int u, int p) {
            moveTo[u][root] = p;
            moveFrom[root][u] = p;
            for (auto& [v, w] : g[u]) {
                if (v == p) continue;
                dfs(v, u);
            }
        };
        dfs(root, root);
    }

    vector<vector<ll>> distOf(n, vector<ll>(n, 0));
    for (int root = 0; root < n; root++) {
        distOf[root][root] = 0;
        function<void(int, int)> dfs = [&](int u, int p) {
            for (auto& [v, w] : g[u]) {
                if (v == p) continue;
                distOf[root][v] = distOf[root][u] + w;
                dfs(v, u);
            }
        };
        dfs(root, root);
    }

    auto getLCA = [&](int root, int u, int v) {
        int cur = root;
        while (moveFrom[u][cur] == moveFrom[v][cur])
            cur = moveFrom[u][cur];
        return cur;
    };

    while (q--) {
        int start, key, trap; cin >> start >> key >> trap; start--; key--; trap--;

        const int KEY_TRAP_LCA = getLCA(start, key, trap);
        if (KEY_TRAP_LCA == trap) {
            cout << "impossible\n";
            continue;
        }
        
        ll ans = LLONG_MAX;
        auto dfs = [&](auto&& dfs, int u, int p, int key_x_lca, ll dist) -> void {
            ll triplePath = 0;
            if (moveTo[KEY_TRAP_LCA][u] == moveTo[KEY_TRAP_LCA][key])
                triplePath = distOf[KEY_TRAP_LCA][key_x_lca];

            ans = min(ans, -dist + 2 * triplePath);

            for (auto& [v, w] : g[u]) {
                if (v == p) continue;
                const bool isKeyPath = (moveFrom[key][u] == v);
                if (isKeyPath)
                    dfs(dfs, v, u, v, dist + w);
                else
                    dfs(dfs, v, u, key_x_lca, dist + w);
            }
        };
        dfs(dfs, start, start, start, 0);

        cout << distAll + ans << '\n';
    }
}

signed main() {
#ifndef LOCAL
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
#endif
    cout << fixed << setprecision(10);
    int T = 1;
    // cin >> T;
    while (T--) solve();
    return 0;
}