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

#define re register
#define ll long long

// Path: start -> key -> trap -> finish
// LCA + DP
// O(rooms * scenarios)

inline int read()
{
    re int t = 0;
    re char v = getchar();
    while(v < '0') v = getchar();
    while(v >= '0') t = (t<<3) + (t<<1) + v - 48, v = getchar();
    return t;
}

const int M = 998244353;
inline void add(re int &x, re int &y) {(x+=y) >= M ? x-=M : x;}
inline int Mod(re int x) {return x>=M ? x-M : x;}
inline int ksm(re int x, re int y)
{
    re int s = 1;
    while(y)
    {
        if(y&1) s = 1ll * s * x % M;
        x = 1ll * x * x % M, y >>= 1;
    }
    return s;
}

vector<int> E[2002], W[2002]; // record corridors and time

int rt, tim;
int siz[2002][2002]; // length (i,j)
int dfn[2002][2002]; // depth of node j when root = i
int fa[2002][2002];
ll dis[2002][2002]; // time (i,j)
ll Mx[2002][2002];
inline void dfs(re int x, re int y) // dfs with dp
{
    siz[rt][x] = 1, dfn[rt][x] = ++tim, fa[rt][x] = y, Mx[rt][x] = dis[rt][x];
    for(re int i = 0; i < E[x].size(); ++i)
    {
        if(E[x][i]^y)
        {
            dis[rt][E[x][i]] = dis[rt][x] + W[x][i];
            dfs(E[x][i],x);
            siz[rt][x] += siz[rt][E[x][i]];
            Mx[rt][x] = max(Mx[rt][x], Mx[rt][E[x][i]]);
        }
    }
}
inline bool in(re int x, re int y, re int z)
{
    return dfn[x][z] >= dfn[x][y] && dfn[x][z] < dfn[x][y]+siz[x][y];
}
inline int lca(re int x, re int y, re int z) // lowest common ancestor
{
    while(y^z)
    {
        if(dfn[x][y] > dfn[x][z])
            y = fa[x][y];
        else
            z = fa[x][z];
    }
    return y;
}

int main()
{
    int rooms = read(), scenarios = read();
    ll sum = 0;
    for(re int i = 1; i < rooms; ++i)
    {
        re int u = read(), v = read(), time = read();
        E[u].push_back(v), E[v].push_back(u);
        W[u].push_back(time), W[v].push_back(time);
        sum += time;
    }
    for(re int i = 1; i <= rooms; ++i)
    {
        rt = i;
        tim = 0;
        dfs(i,i); // dfs from root = i; dp for each scenario
    }
    while(scenarios--)
    {
        re int start = read(), key = read(), trap = read();
        re ll mx = 0;
        if(in(start,key,trap)) // key first trap second
        {
            for(re int i = 1; i <= rooms; ++i)
                mx = max(mx, dis[start][i]);
            printf("%lld\n", sum+sum-mx);
        }
        else if(in(start,trap,key)) // trap first key second
            puts("impossible");
        else
        {
            re int o = lca(start,trap,key), oy = key;
            while(fa[start][key]^o) key = fa[start][key];
            for(re int i = 1; i <= rooms; ++i)
            {
                if(!in(start,key,i))
                    mx = max(mx, dis[start][i]);
            }
            ll tmp = sum+sum-mx;
            int lst = 0;
            while(oy^o)
            {
                tmp = min(tmp, sum+sum-dis[start][oy]+dis[o][oy]*2);
                for(auto z : E[oy])
                {
                    if(z^fa[start][oy] && z^lst)
                        tmp = min(tmp, sum+sum-Mx[start][z]+dis[o][oy]*2);
                }
                lst = oy, oy = fa[start][oy];
            }
            printf("%lld\n", tmp);
        }
    }
}