#include<bits/stdc++.h>
#define ll long long
#define For(i,a,b) for(int i=(a);i<=(b);++i)
#define Rof(i,a,b) for(int i=(a);i>=(b);--i)
using namespace std;
const int Maxn=2e5,Maxk=5e5;
 
inline int read()
{
    int x=0,f=1;
    char ch=getchar();
    while(ch<'0' || ch>'9')
    {
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(ch>='0' && ch<='9')
    {
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x*f;
}
 
int n,m,fa[Maxn+5]; ll dis[Maxn+5];
int dfn[Maxn+5],st[Maxn+5][20],cur;
vector<pair<int,int>> v[Maxn+5];
 
inline int Get(int x,int y) {return (dfn[x]<dfn[y])?x:y;}
inline int LCA(int x,int y)
{
    if(x==y) return x; if((x=dfn[x])>(y=dfn[y])) swap(x,y);
    int len=__lg(y-x++); return Get(st[x][len],st[y-(1<<len)+1][len]);
}
inline ll Dis(int x,int y) {return dis[x]+dis[y]-2*dis[LCA(x,y)];}
 
struct Node{int x,y;} f[Maxn+5],g[Maxn+5];
inline Node operator+(Node a,Node b)
{
    if(a.x==0 && a.y==0) return b; if(b.x==0 && b.y==0) return a;
    int ax=a.x,ay=a.y,bx=b.x,by=b.y;
    ll s1=Dis(ax,ay),s2=Dis(bx,by),s3=Dis(ax,bx),s4=Dis(ay,by),s5=Dis(ax,by),s6=Dis(ay,bx);
    ll mx=max(s1,max(s2,max(s3,max(s4,max(s5,s6)))));
    if(mx==s1) return Node{ax,ay}; if(mx==s2) return Node{bx,by};
    if(mx==s3) return Node{ax,bx}; if(mx==s4) return Node{ay,by};
    if(mx==s5) return Node{ax,by}; if(mx==s6) return Node{ay,bx};
}
inline void dfs(int x,int f)
{
    fa[x]=f,dfn[x]=++cur,st[cur][0]=f;
    for(auto [y,z]:v[x]) if(y!=f) dis[y]=dis[x]+z,dfs(y,x);
}
inline void dfs1(int x,int fa)
{f[x]=Node{x,x}; for(auto [y,z]:v[x]) if(y!=fa) dfs1(y,x),f[x]=f[x]+f[y];}
inline void dfs2(int x,int fa)
{
    static Node pr[Maxn+5],sf[Maxn+5];
    Node res=g[x]+Node{x,x}; for(auto [y,z]:v[x]) if(y!=fa) pr[y]=res,res=res+f[y];
    res=Node{0,0}; reverse(v[x].begin(),v[x].end());
    for(auto [y,z]:v[x]) if(y!=fa) sf[y]=res,res=res+f[y];
    reverse(v[x].begin(),v[x].end());
    for(auto [y,z]:v[x]) if(y!=fa) g[y]=pr[y]+sf[y];
    for(auto [y,z]:v[x]) if(y!=fa) dfs2(y,x);
}
 
inline int Check1() {For(i,1,n) if(v[i].size()>2) return 0; return 1;}
namespace T1
{
    struct Point
    {
        ll x,y; inline Point() {}
        inline Point(ll _x,ll _y): x(_x),y(_y) {}
    }; vector<Point> t[Maxn*4+5];
    inline bool operator<(Point a,Point b)
    {return a.x<b.x || (a.x==b.x && a.y<b.y);}
    #define ls(x) (x<<1)
    #define rs(x) (x<<1|1)
    int rt,rk[Maxn+5],id[Maxn+5],h[Maxn+5],tot; ll sum[Maxn+5];
    int mn[Maxn+5][20];
    inline void dfs(int x,int f,int k)
    {
        id[++tot]=x,rk[x]=tot,h[tot]=k;
        for(auto [y,z]:v[x]) if(y!=f) dfs(y,x,z);
    }
    inline int Get(int l,int r)
    {int len=__lg(r-l+1); return min(mn[l][len],mn[r-(1<<len)+1][len]);}
    inline double Slope(Point a,Point b) {return 1.0*(b.y-a.y)/(b.x-a.x);}
    inline auto Merge(vector<Point> v1,vector<Point> v2)
    {
        vector<Point> v3,v;
        for(auto i:v1) v3.push_back(i);
        for(auto i:v2) v3.push_back(i);
        sort(v3.begin(),v3.end());
        for(auto i:v3)
        {
            while(v.size()>1 && Slope(v[v.size()-2],v.back())<=
                 Slope(v.back(),i)) v.pop_back();
            v.push_back(i);
        } return v;
    }
    inline void Build(int l,int r,int p)
    {
        if(l==r) {t[p].push_back(Point(sum[l+1],sum[l])); return;}
        int mid=(l+r)>>1; Build(l,mid,ls(p)),Build(mid+1,r,rs(p));
        t[p]=Merge(t[ls(p)],t[rs(p)]);
    }
    inline ll Get(int p,int A,int B)
    {
        vector<Point> &v=t[p]; int sz=v.size(); double res=1.0*B/A;
        int l=0,r=sz-1; while(l<r)
        {
            int mid=(l+r+1)/2;
            if(Slope(v[mid-1],v[mid])>=res) l=mid;
            else r=mid-1;
        } auto [x,y]=v[l]; return 1ll*A*y-1ll*B*x;
    }
    inline ll Count(int nl,int nr,int l,int r,int p,int A,int B)
    {
        if(l<=nl && nr<=r) return Get(p,A,B);
        int mid=(nl+nr)>>1; ll res=LLONG_MIN;
        if(l<=mid) res=max(res,Count(nl,mid,l,r,ls(p),A,B));
        if(r>mid) res=max(res,Count(mid+1,nr,l,r,rs(p),A,B));
        return res;
    }
    inline void Run()
    {
        For(i,1,n) if(v[i].size()==1) {rt=i; break;}
        dfs(rt,0,0); For(i,1,n) sum[i]=sum[i-1]+h[i];
        For(i,1,n) mn[i][0]=h[i];
        For(j,1,19) for(int i=1;i+(1<<j)-1<=n;++i)
            mn[i][j]=min(mn[i][j-1],mn[i+(1<<j-1)][j-1]);
        Build(1,n,1);
        while(m--)
        {
            int x=rk[read()],y=rk[read()],A=read(),B=read();
            if(x>y) swap(x,y),swap(A,B);
            ll res=sum[x]*A+(sum[n]-sum[y])*B;
            res=max(res,(sum[y]-sum[x+1])*B+sum[x]*A);
            res=max(res,(sum[n]-sum[y])*B+(sum[y-1]-sum[x])*A);
            ll now=Count(1,n,x,y-1,1,A,B);
            now=now-sum[x]*A+sum[y]*B; res=max(res,now);
            printf("%lld\n",res);
        }
        // cerr<<1.0*clock()/CLOCKS_PER_SEC<<endl;
    }
}
 
int main()
{
    // freopen("C.in","r",stdin);
    // freopen("C.out","w",stdout);
 
    n=read(),m=read();
    For(i,1,n-1)
    {
        int a=read(),b=read(),c=read();
        v[a].emplace_back(b,c),v[b].emplace_back(a,c);
    }
    if(Check1()) {T1::Run(); return 0;}
    dfs(1,0);
    For(j,1,19) for(int i=1;i+(1<<j)-1<=n;++i)
        st[i][j]=Get(st[i][j-1],st[i+(1<<j-1)][j-1]);
    dfs1(1,0),dfs2(1,0);
    while(m--)
    {
        int x=read(),y=read(),A=read(),B=read(),l=LCA(x,y);
        ll ans=0;
        for(int i=x;i!=l;i=fa[i])
        {
            Node a=f[i],b=g[i];
            ll dx=max(Dis(x,a.x),Dis(x,a.y));
            ll dy=max(Dis(y,b.x),Dis(y,b.y));
            ans=max(ans,dx*A+dy*B);
        }
        for(int i=y;i!=l;i=fa[i])
        {
            Node a=f[i],b=g[i];
            ll dx=max(Dis(x,b.x),Dis(x,b.y));
            ll dy=max(Dis(y,a.x),Dis(y,a.y));
            ans=max(ans,dx*A+dy*B);
        }
        printf("%lld\n",ans);
    }
    return 0;
}