#include<bits/stdc++.h>
#define Yukinoshita namespace
#define Yukino std
#define int long long
using Yukinoshita Yukino;
int read()
{
    int s=0,w=1;
    char ch=getchar();
    while(ch<'0'||ch>'9') w=ch=='-'?-1:1,ch=getchar();
    while(ch>='0'&&ch<='9') s=s*10+ch-'0',ch=getchar();
    return s*w;
}
const int mxn=2e5+5; 
int n;
vector<pair<int,int>> t[mxn];
struct ST_table
{
    pair<int,int> st[20][mxn];
    void build()
    {
        int i,j;
        for(i=1;(1<<i)<=n;i++)
            for(j=1;j+(1<<i)-1<=n;j++)
                st[i][j]=min(st[i-1][j],st[i-1][j+(1<<i-1)]);
    }
    int ask(int l,int r)
    {
        int k=__lg(r-l+1);
        return min(st[k][l],st[k][r-(1<<k)+1]).second;
    }
};  
struct ys
{
    ST_table st;
    int fa[mxn],dcnt,dfn[mxn],dfr[mxn];
    int Dep[mxn];
    int asklca(int x,int y)
    {
        if(x==y) return x;
        x=dfn[x],y=dfn[y];
        if(x>y) swap(x,y);
        y--;
        return st.ask(x,y);
    }
    int askdis(int x,int y)
    {
        return Dep[x]+Dep[y]-Dep[asklca(x,y)]*2;
    }
    void dfs(int d,int fa,int dep,int dis)
    {
        st.st[0][dcnt++]=make_pair(dep,fa),dfn[d]=dcnt;
        Dep[d]=dis;
        for(auto i:t[d])
            if(i.first!=fa)
                dfs(i.first,d,dep+1,dis+i.second);
        dfr[d]=dcnt;
    }
    void build(int rt)
    {
        dfs(rt,0,0,0);
        st.build();
    }
}T0;
struct lj
{
    int x,y;
    friend bool operator <(const lj &x,const lj &y)
    {
        return T0.askdis(x.x,x.y)<T0.askdis(y.x,y.y);
    }
    friend lj operator +(const lj &x,const lj &y)
    {
        return max({x,y,lj({x.x,y.x}),lj({x.x,y.y}),lj({x.y,y.x}),lj({x.y,y.y})});
    }
    int ask(int v)
    {
        return max(T0.askdis(x,v),T0.askdis(y,v));
    }
};
struct part1
{
    vector<pair<int,int>> t2[mxn];
    ST_table st;
    lj dp[mxn];
    int Fa[mxn],dcnt,dfn[mxn],dfr[mxn];
    int Dep[mxn];
    int asklca(int x,int y)
    {
        if(x==y) return x;
        x=dfn[x],y=dfn[y];
        if(x>y) swap(x,y);
        y--;
        return st.ask(x,y);
    }
    void dfs(int d,int fa,int dep,int dis)
    {
        st.st[0][dcnt++]=make_pair(dep,fa),dfn[d]=dcnt;
        Dep[d]=dis;
        dp[d]=lj({d,d});
        Fa[d]=fa;
        for(auto i:t[d])
            if(i.first!=fa)
                dfs(i.first,d,dep+1,dis+i.second),dp[d]=dp[d]+dp[i.first];
        dfr[d]=dcnt;
    }
    void build(int rt)
    {
        dfs(rt,0,0,0);
        st.build();
        int i;
        for(i=1;i<=n;i++)
        {
            for(auto x:t[i])
                if(x.first!=Fa[i])
                    t2[i].push_back({dfn[x.first],x.first});
            sort(t2[i].begin(),t2[i].end());
        }   
    }
    int ask(int x,int y,int A,int B)
    {
        int l=asklca(x,y),w;
//      cout<<x<<' '<<y<<':'<<l<<endl;
        if(l==y) return -1;
        w=(--upper_bound(t2[l].begin(),t2[l].end(),make_pair(dfn[y],y)))->second;
//      cout<<w<<endl;
        return Dep[x]*A+dp[w].ask(y)*B;
    }
}T1,T2;
pair<int,int> findmax(int d,int fa,int v)
{
    pair<int,int> mx{v,d};
    for(auto i:t[d])
        if(i.first!=fa)
            mx=max(mx,findmax(i.first,d,v+i.second));
    return mx;
}
int rd[mxn],rcnt;
int stk[mxn],stcnt;
void get(int x,int fa,int y)
{
    stk[++stcnt]=x;
    if(x==y)
    {
        rcnt=stcnt;
        memcpy(rd,stk,sizeof(rd));
        return;
    }
    for(auto i:t[x])
        if(i.first!=fa)
            get(i.first,x,y);
    stcnt--;
}
map<pair<int,int>,int> vv;
int col[mxn];
int dfs(int d,int f1,int f2,int c,int mxd)
{
    int mx=mxd;
    col[d]=c;
    for(auto i:t[d])
        if(i.first!=f1&&i.first!=f2)
            mx=max(mx,dfs(i.first,d,0,c,mxd+i.second));
    return mx;
}
int pref[mxn];
int mm[mxn];
int tx[mxn],ty[mxn];
struct vec
{
    int x,y;
    friend vec operator -(const vec &x,const vec &y)
    {
        return vec({x.x-y.x,x.y-y.y});
    }
    friend int operator *(const vec &x,const vec &y)
    {
        return x.x*y.y-x.y*y.x;
    }
    friend bool operator <(const vec &x,const vec &y)
    {
        return x.x==y.x?x.y<y.y:x.x<y.x;
    }
};
int check(vec a,vec b,vec c)
{
    return (b-a)*(c-a);
}
int mx;
struct segment_tree
{
    struct seg
    {
        int l,r,mxx,mxy;
    }t[mxn*4];
    #define ls w<<1
    #define rs ls|1
    vector<vec> p[mxn*4];
    void pushup(int w)
    {
        t[w].mxx=max(t[ls].mxx,t[rs].mxx);
        t[w].mxy=max(t[ls].mxy,t[rs].mxy);
    }
    vec qwq[mxn],stk[mxn];
    void get(vector<vec> &u,int l,int r,int x[],int y[])
    {
        int i,mx=x[l],cnt=0,top=0;
        for(i=l+1;i<=r;i++)
            qwq[++cnt]=vec({mx,y[i]}),mx=max(mx,x[i]);
        sort(qwq+1,qwq+1+cnt);
        for(i=1;i<=cnt;i++)
        {
            for(;top>1&&check(stk[top-1],stk[top],qwq[i])>0;top--);
            stk[++top]=qwq[i];
        }
        for(i=1;i<=top;i++)
            u.push_back(stk[i]);    
    }
    void build(int w,int l,int r,int x[],int y[])
    {
        t[w].l=l,t[w].r=r;
        get(p[w],l,r,x,y);
        if(l<r)
        {
            int mid=l+r>>1;
            build(ls,l,mid,x,y);
            build(rs,mid+1,r,x,y);
            pushup(w);
        }
        else t[w].mxx=x[l],t[w].mxy=y[l];
    }
    int getp(vector<vec> &x,int A,int B)
    {
        int mx=-1e18,i;
        for(auto v:x)
            mx=max(mx,v.x*A+v.y*B);
        return mx;
    }
    pair<int,int> ask(int w,int l,int r,int A,int B)
    {
        if(t[w].l>=l&&t[w].r<=r) return mx=max(mx,getp(p[w],A,B)),make_pair(t[w].mxx,t[w].mxy);
        if(t[ls].r>=l&&t[rs].l<=r)
        {
            pair<int,int> tl=ask(ls,l,r,A,B),tr=ask(rs,l,r,A,B);
            mx=max(mx,tl.first*A+tr.second*B);
            return {max(tl.first,tr.first),max(tl.second,tr.second)};
        }
        if(t[ls].r>=l) return ask(ls,l,r,A,B);
        return ask(rs,l,r,A,B);
    }
}T13;
int ask(int u,int v,int A,int B)
{
    if(col[u]>col[v]) swap(u,v),swap(A,B);
    int l=col[u],r=col[v],res,i,j;
    mx=-1e18;
    if(r-l<=1) return -1;
    res=T0.askdis(u,rd[l])*A+T0.askdis(v,rd[r])*B;
    res-=pref[l]*A;
    res+=pref[r]*B;
    T13.ask(1,l+1,r-1,A,B);
//  for(i=l+1;i<r;i++)
//      for(j=i+1;j<r;j++)
//          mx=max(mx,A*tx[i]+B*ty[j]);
    return mx+res;
}
signed main()
{
    n=read();
    int m=read(),i,x,y,v,u,A,B;
    for(i=1;i<n;i++)
        x=read(),y=read(),v=read(),
        vv[{x,y}]=vv[{y,x}]=v,
        t[x].push_back({y,v}),
        t[y].push_back({x,v});
    T0.build(1);
    x=findmax(1,0,0).second;
    y=findmax(x,0,0).second;
    T1.build(x),T2.build(y);
//  cout<<x<<' '<<y<<endl;
    get(x,0,y);
//  cout<<rcnt<<':';
//  for(i=1;i<=rcnt;i++)
//      cout<<rd[i]<<' ';
//  cout<<endl;
    for(i=1;i<=rcnt;i++)
        mm[i]=dfs(rd[i],rd[i-1],rd[i+1],i,0);
    for(i=2;i<=rcnt;i++)
        pref[i]=pref[i-1]+vv[{rd[i],rd[i-1]}];
    for(i=1;i<=rcnt;i++)
        tx[i]=pref[i]+mm[i],
        ty[i]=-pref[i]+mm[i];
    T13.build(1,1,rcnt,tx,ty);
    while(m--)
    {
        u=read(),v=read(),A=read(),B=read();
//      cout<<T1.ask(u,v,A,B)<<endl;
        printf("%lld\n",max({T1.ask(u,v,A,B),T1.ask(v,u,B,A),T2.ask(u,v,A,B),T2.ask(v,u,B,A),ask(u,v,A,B)}));
    }
}