#include <bits/stdc++.h>
#define LL long long
#define sl(n) strlen(n)
#define endline puts("")
#define pii pair<LL , int>
#define pr_q priority_queue
#define debug puts("DEBUG.")
using namespace std;
const int N = 2e5 + 10;
const LL inf1 = 4e18,inf2 = 2e9;
int n,m;
int cnt,hd[N];
struct edge
{
    int v,w,nxt;
}e[N << 1];
void add(int u , int v , int w)
{
    ++cnt,e[cnt].v = v,e[cnt].w = w;
    e[cnt].nxt = hd[u],hd[u] = cnt;
}
int rt,tl;
namespace baseworker
{
    int dfn[N],dfn_t,st[N][20],idfn[N],dep[N];
    LL ds[N];
    int f[N],siz[N],fw[N];
    pii dfs0(int u , int fa)
    {
        f[u] = fa;
        pii res(0 , u);
        for(int i = hd[u];i;i = e[i].nxt)
        {
            int v = e[i].v;
            if(v == fa)
                continue;
            pii y = dfs0(v , u);
            y.first += e[i].w;
            res = max(res , y);
        }
        return res;
    }
    int top[N];
    bool in[N]; // 在 rt->tl 的链中
    void dfs1(int u , int fa , int t)
    {
        top[u] = t,siz[u] = 1;
        idfn[dfn[u] = ++dfn_t] = u;
        st[dfn_t][0] = fa;
        dep[u] = dep[fa] + 1;
        for(int i = hd[u];i;i = e[i].nxt)
        {
            int v = e[i].v;
            if(v == fa)
                continue;
            ds[v] = ds[u] + e[i].w,fw[v] = e[i].w,dfs1(v , u , in[v] ? v : t);
            siz[u] += siz[v];
        }
    }
    inline int mymin(int x , int y)
    {
        return dep[x] < dep[y] ? x : y;
    }
    inline int lca(int l , int r)
    {
        if(l == r)
            return l;
        l = dfn[l],r = dfn[r];
        if(l > r)
            swap(l , r);
        ++l;
        int k = __lg(r - l + 1);
        return mymin(st[l][k] , st[r - (1 << k) + 1][k] );
    }
    LL dis(int u , int v)
    {
        return ds[u] + ds[v] - 2 * ds[ lca(u , v) ];
    }
    #define ls o << 1
    #define rs o << 1 | 1
    struct node0
    {
        int x,y;
        LL d;
        node0(){}
        node0(int _x , int _y , LL _d)
            {x = _x,y = _y,d = _d;}
    }t[N << 2];
    void chkmx(node0 &x , int u , int v)
    {
        LL d = dis(u , v);
        if(d > x.d)
            x.x = u,x.y = v,x.d = d;
    }
    node0 operator + (node0 lhs , node0 rhs)
    {
        node0 res = lhs;
        chkmx(res , lhs.x , rhs.x);
        chkmx(res , lhs.x , rhs.y);
        chkmx(res , lhs.y , rhs.x);
        chkmx(res , lhs.y , rhs.y);
        chkmx(res , rhs.x , rhs.y);
        return res;
    }
    void build(int o , int l , int r)
    {
        if(l == r)
            return t[o] = node0(idfn[l] , idfn[l] , 0),void();
        int mid = l + r >> 1;
        build(ls , l , mid),build(rs , mid + 1 , r);
        t[o] = t[ls] + t[rs];
    }
    node0 query(int sl , int sr , int o , int l , int r)
    {
        if(sl <= l && r <= sr)
            return t[o];
        int mid = l + r >> 1;
        if(mid >= sl && mid + 1 <= sr)
            return query(sl , sr , ls , l , mid) + query(sl , sr , rs , mid + 1 , r);
        if(mid >= sl)
            return query(sl , sr , ls , l , mid);
        return query(sl , sr , rs , mid + 1 , r);
    }
    vector<pii> vc[N];
    int move(int u , int v) // u 在 v 方向的儿子
    {
        if(u == v)
            return -1;
        return ( --upper_bound( vc[u].begin() , vc[u].end() , pii(dfn[v] , n + 1) ) )->second;
    }
    LL querymxd(int u , int l , int r) // u 到 dfn in [l, r] 内点的距离最大值
    {
        if(l > r)
            return -inf2;
        node0 res = query(l , r , 1 , 1 , n);
        return max(dis(u , res.x) , dis(u , res.y) );
    }
    int tot,b[N];
    LL s1[N],s2[N],mx[N];
    void dfs2(int u , int fa)
    {
        for(int i = hd[u];i;i = e[i].nxt)
        {
            int v = e[i].v;
            if( v == fa || in[v] )
                continue;
            dfs2(v , u);
            mx[u] = max(mx[u] , mx[v] + e[i].w);
        }
    }
    namespace slaves
    {
        struct vect
        {
            LL x,y;
            vect(){}
            vect(LL _x , LL _y)
                {x = _x,y = _y;}
            friend vect operator - (vect A , vect B)
                {return vect(A.x - B.x , A.y - B.y);}
            friend __int128 operator * (vect A , vect B)
                {return (__int128)A.x * B.y - (__int128)A.y * B.x;}
            friend bool operator < (vect lhs , vect rhs)
                {return lhs.x == rhs.x ? lhs.y < rhs.y : lhs.x < rhs.x;}
        }c[N];
        struct node
        {
            vector<vect> vc;
            LL mxx,mxy;
        }t[N << 2];
        LL suf[N];
        void build(int o , int l , int r)
        {
            for(int i = l;i <= r;i++)
            {
                c[i].x = s1[i] + mx[ b[i] ];
                t[o].mxx = max(t[o].mxx , c[i].x);
                t[o].mxy = max(t[o].mxy , s2[i] + mx[ b[i] ] );
            }
            suf[r + 1] = 0;
            for(int i = r;i >= l + 1;i--)
                suf[i] = max(suf[i + 1] , s2[i] + mx[ b[i] ] );
            for(int i = l;i <= r - 1;i++)
                c[i].y = suf[i + 1];
            sort(c + l , c + r);
            t[o].vc.push_back( vect(0 , -inf2) );
            for(int i = l;i <= r - 1;i++)
            {
                while(t[o].vc.size() > 1 && (c[i] - t[o].vc.back() ) * (c[i] - t[o].vc[t[o].vc.size() - 2] ) <= 0)
                    t[o].vc.pop_back();
                t[o].vc.push_back( c[i] );
            }
            t[o].vc.push_back( vect(t[o].vc.back().x , -inf2) );
            if(l == r)
                return ;
            int mid = l + r >> 1;
            build(ls , l , mid),build(rs , mid + 1 , r);
        }
        int d[N],len;
        LL pre[N];
        LL query(int sl , int sr , int o , int l , int r , int A , int B)
        {
            if(sl <= l && r <= sr)
            {
                d[++len] = o;
                if(t[o].vc.size() == 2)
                    return -inf1;
                int L = 1,R = t[o].vc.size() - 2;
                // cerr << l << " " << r << " " << L << " " << R << endl;
                while(L < R)
                {
                    int mid = L + R >> 1;
                    if(A * t[o].vc[mid].x + B * t[o].vc[mid].y > A * t[o].vc[mid + 1].x + B * t[o].vc[mid + 1].y)
                        R = mid;
                    else
                        L = mid + 1;
                }
                // cerr << L << " " << R << endl;
                // assert(L == R);
                return A * t[o].vc[L].x + B * t[o].vc[L].y;
            }
            int mid = l + r >> 1;
            LL res = -inf1;
            if(mid >= sl)
                res = query(sl , sr , ls , l , mid , A , B);
            if(mid + 1 <= sr)
                res = max(query(sl , sr , rs , mid + 1 , r , A , B) , res);
            return res;
        }
        LL query(int l , int r , int A , int B)
        {
            if(r - l + 1 <= 1)
                return -inf1;
            len = 0;
            LL res = query(l , r , 1 , 1 , tot , A , B);
            // cout << res << endl;
            for(int i = 1;i <= len;i++)
                pre[i] = max(pre[i - 1] , t[ d[i] ].mxx);
            for(int i = len;i >= 2;i--)
                res = max(res , A * pre[i - 1] + B * t[ d[i] ].mxy);//,cout << pre[i - 1] << " " << t[ d[i] ].mxy << endl;
            return res;
            // LL res = -inf1;
            // for(int i = l;i <= r;i++)
            //     for(int j = i + 1;j <= r;j++)
            //         res = max(res , A * (s[i] + mx[ b[i] ] ) + B * (mx[ b[j] ] - s[j] ) );
            // return res;
        }
    }
    int rk[N];
    inline void build()
    {
        rt = dfs0(1 , 0).second,tl = dfs0(rt , 0).second;
        // cerr << rt << " " << tl << endl;
        int u = tl;
        while(u)
            in[u] = 1,b[++tot] = u,u = f[u];
        reverse(b + 1 , b + tot + 1);
        assert(b[1] == rt && b[tot] == tl);

        dfs1(rt , 0 , rt);
        for(int j = 1;j <= 18;j++)
            for(int i = 1;i + (1 << j) - 1 <= n;i++)
                st[i][j] = mymin( st[i][j - 1] , st[ i + (1 << j - 1) ][j - 1] );
        build(1 , 1 , n);
        for(int u = 1;u <= n;u++)
        {
            for(int i = hd[u];i;i = e[i].nxt)
            {
                int v = e[i].v;
                if( v == f[u] )
                    continue;
                vc[u].push_back( pii(dfn[v] , v) );
            }
            sort( vc[u].begin() , vc[u].end() );
            // cerr << u << " --> " << vc[u].size() << endl;
        }
        for(int i = 1;i <= tot;i++)
            dfs2(b[i] , 0),s1[i] = s1[i - 1] + fw[ b[i] ],rk[ b[i] ] = i;
        for(int i = tot;i;i--)
            s2[i] = s2[i + 1] + fw[ b[i + 1] ];
        slaves::build(1 , 1 , tot);
    }
}
using namespace baseworker;
int main()
{
    // system("fc path1.out my.out");
    // return 0;
    // freopen("path1.in" , "rt" , stdin);
    // freopen("my.out" , "wt" , stdout);
    cin >> n >> m;
    for(int i = 1,u,v,w;i <= n - 1;i++)
        scanf("%d%d%d" , &u , &v , &w),add(u , v , w),add(v , u , w);
    build();
    // for(int i = 1;i <= n;i++)
    //     cerr << top[i] << " ";
    // cerr << endl;
    while(m--)
    {
        int u,v,A,B;
        LL ans = 0;
        scanf("%d%d%d%d" , &u , &v , &A , &B);
        if(top[u] == top[v] )
        {
            int w = lca(u , v);
            int u2 = move(w , u),v2 = move(w , v);
            if(w != u)
                ans = B * max(dis(v , rt) , dis(v , tl) ) + A * querymxd(u , dfn[u2] , dfn[u2] + siz[u2] - 1);
            if(w != v)
                ans = max(A * max(dis(u , rt) , dis(u , tl) ) + B * querymxd(v , dfn[v2] , dfn[v2] + siz[v2] - 1) , ans);
        }
        else
        {
            if( dep[ top[u] ] > dep[ top[v] ] )
                swap(u , v),swap(A , B);
            int v2 = move(top[u] , v);
            ans = A * dis(u , rt) + B * querymxd(v , dfn[v2] , dfn[v2] + siz[v2] - 1);
            // cerr << ans << endl;
            v2 = move(top[v] , v);
            if(top[v] != v)
                ans = max(A * dis(u , tl) + B * querymxd(v , dfn[v2] , dfn[v2] + siz[v2] - 1) , ans);
            // cerr << ans << endl;
            int u2 = move(top[u] , u);
            if(top[u] != u)
                ans = max(B * dis(v , rt) + A * querymxd(u , dfn[u2] , dfn[u2] + siz[u2] - 1) , ans);
            // cerr << ans << endl;
            ans = max(B * dis(v , tl) + A * max( querymxd(u , 1 , dfn[ top[v] ] - 1) , 
                                         querymxd(u , dfn[ top[v] ] + siz[ top[v] ] , n) ) , ans);
            LL res = slaves::query(rk[ top[u] ] + 1 , rk[ top[v] ] - 1 , A , B);
            // cerr << rk[ top[u] ] + 1 << " " << rk[ top[v] ] - 1 << endl;
            res += A * (dis(top[u] , u) - s1[ rk[ top[u] ] ] ) + B * (dis(top[v] , v) - s2[ rk[ top[v] ] ] );
            ans = max(res , ans);
        }
        // debug;
        printf("%lld\n" , ans);
    }
    return 0;
}