#pragma GCC optimize("O2")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdarg>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>

#define whlie while
#define retunr return
#define reutrn return
#define reutnr return
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define inf 1001001001
#define infLL (1LL << 61)
#define MOD 1000000007
#define FOR(i,a,b) for(int (i)=(int)(a); (i)<(int)(b); (i)++) // [a,b)
#define rep(i,N) FOR((i), 0, (int)(N)) // [0,N)
#define FORR(i,a,b) for(int (i)=(int)(b) - 1; (i)>=(int)(a); (i)--)
#define repr(i,N) FORR((i), 0, (int)(N))
#define each(x,v) for(auto &x : v)
#define all(v) (v).begin(),(v).end()
#define sz(v) ((int)(v).size())
#define vrep(v,it) for(auto it=v.begin();it!=v.end();it++)
#define vrepr(v,it) for(auto it=v.rbegin();it!=v.rend();it++)
#define ini(...) int __VA_ARGS__; in(__VA_ARGS__)
#define inl(...) ll __VA_ARGS__; in(__VA_ARGS__)
#define inc(...) char __VA_ARGS__; in(__VA_ARGS__)
#define ins(...) string __VA_ARGS__; in(__VA_ARGS__)
#define ind(...) double __VA_ARGS__; in(__VA_ARGS__)
#define inpii(...) pii __VA_ARGS__; in(__VA_ARGS__)
#define rand mtrand
#define randinit random_device seed_gen; mt19937 mtrand(seed_gen()+2)

#ifdef LOCAL  
  #define trc(...) do { cout << #__VA_ARGS__ << " = "; dbg_out(__VA_ARGS__);} while(0)
  #define stopif(val) assert( !(val) )
  #define trcv(v,...) do { cout << #v << " = "; vector_debug(v , ##__VA_ARGS__);cout << endl;} while(0)
#else
  #define trc(...)
  #define stopif(...)
  #define trcv(...)
#endif

using namespace std;
using ll = long long;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vs = vector<string>;
using vpii = vector<pii>;
using vvi = vector< vector<int> >;

struct IoSetupNya {IoSetupNya() { cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(15); cerr << fixed << setprecision(15);} } iosetupnya;

int gcd(int a, int b){if(a>b) swap(a,b); return a==0 ? b : gcd(b%a,a);} ll gcd(ll a, ll b){if(a>b) swap(a,b); return a==0 ? b : gcd(b%a,a);}
ll lcm(int a, int b){return (1LL * a / gcd(a,b)) * b;} ll lcm(ll a, ll b){return (a / gcd(a,b)) * b;}
inline ll pow(int a, int b){ll ans = 1; rep(i,b) ans *= a; return ans;} inline ll pow(ll a, ll b){ll ans = 1; rep(i,b) ans*= a; return ans;}
inline ll pow(int a, ll b){ll ans = 1; rep(i,b) ans *= a; return ans;} inline ll pow(ll a, int b){ll ans = 1; rep(i,b) ans*= a; return ans;}
template<typename T, typename U> inline bool amin(T &x, U y) { return (y < x) ? (x = y, true) : false; }
template<typename T, typename U> inline bool amax(T &x, U y) { return (x < y) ? (x = y, true) : false; }
template<typename C> inline void _cin(C &c){cin >> c;}
template<typename T,typename U> inline void _cin(pair<T,U> &p){cin >> p.fi; cin >> p.se;}
template<typename C> inline void _cout(const C &c){cout << c;}
template<typename T,typename U> inline void _cout(const pair<T,U> &p){cout << p.fi << ' ' << p.se;}
void in(){} template <typename T,class... U> void in(T &t,U &...u){ _cin(t); in(u...);}
void out(){cout << "\n";} template <typename T,class... U> void out(const T &t,U ...u){ _cout(t); if(sizeof...(u)) cout << ' '; out(u...);}
template<typename C> inline void in(vector<C> &v,int N=-1){if(sz(v) != 0){int M=(N == -1) ? sz(v) : N; rep(i,M) _cin(v[i]);}else{C c;rep(i,N) v.pb((_cin(c),c));}}
template<typename C> inline void in(C v[],int N){rep(i,N) _cin(v[i]);}
template<typename C> inline void out(const vector<C> &v,int N=-1){int M=(N == -1) ? sz(v) : N; rep(i,M) {cout<<( (i)?" ":"" ); _cout(v[i]);} cout<<"\n";}
template<typename C> inline void out(C v[],int N){rep(i,N) {cout<<( (i)?" ":"" ); _cout(v[i]);} cout<<"\n";}
template<typename C> inline void vector_debug(const vector<C> &v,int N=-1){cout << "{"; int M=(N == -1) ? sz(v) : N; rep(i,M) {cout<<( (i)?", ":"" ); _cout(v[i]);} cout<<"}";}
template<typename C> inline void vector_debug(C v[], int N){cout << "{"; rep(i,N) {cout<<((i)?", ":""); _cout(*(v+i));} cout<<"}";}
void dbg_out(){cout << endl;} template <typename T,class... U> void dbg_out(const T &t,U ...u){ _cout(t); if(sizeof...(u)) cout << ", "; dbg_out(u...);}
template<typename C,class... U> void dbg_out(const vector<C> &v,U ...u){vector_debug(v); if(sizeof...(u)) cout << ", "; dbg_out(u...);}
template<typename C,class... U> void dbg_out(const vector<vector<C>> &v,U ...u){cout << "{ "; rep(i,sz(v)) {if(i)cout<<", "; vector_debug(v[i]);} cout << " }"; if(sizeof...(u)) cout << ", "; dbg_out(u...);}
template<typename C> inline C vmax(const vector<C> &v){C n=v[0]; rep(i,sz(v)) amax(n,v[i]); return n;} template<typename C> inline C vmax(C v[], int N){C n=v[0]; rep( i , N ) amax(n,v[i]); return n;}
template<typename C> inline C vmin(const vector<C> &v){C n=v[0]; rep(i,sz(v)) amin(n,v[i]); return n;} template<typename C> inline C vmin(C v[], int N){C n=v[0]; rep( i , N ) amin(n,v[i]); return n;}

////////////
/// main ///
////////////

// セグ木
template<typename T,typename F,T UNIT>
struct ST{
  int size;
  vector<T> seg;
  F func;
  
  ST(int N,F func): func(func){
    size = 1;
    while(size < N) size <<= 1;
    seg.assign(2 * size, UNIT);
    build();
  }

  ST(const vector<T> &v,F func) : func(func){
    // initialize
    int N = (int)v.size();
    size = 1;
    while(size < N) size <<= 1;
    seg.resize(2 * size);
    // set
    for(int i=0;i < N; i++){
      seg[i + size] = v[i];
    }
    build();
  }

  void set(int k,T& x){
    seg[k + size] = x;
  }

  void build(){
    for(int k=size-1; k>0; k--){
      seg[k] = func(seg[2 * k] , seg[2 * k + 1]);
    }
  }
  
  void update(int k, T& x){
    k += size; seg[k] = x;
    while(k >>= 1){
      seg[k] = func(seg[2 * k] , seg[2 * k + 1]);
    }
  }
  
  T query(int a, int b){
    T L = UNIT, R = UNIT;
    for(a+=size,b+=size; a<b; a>>=1,b>>=1){
      if(a & 1) L = func(L,seg[a++]);
      if(b & 1) R = func(seg[--b],R);
    }
    return func(L, R);
  }

  T operator[](const int &k) const{
    return seg[k + size];
  }

};

template< typename T >
struct edge {
  int src, to;
  T cost;

  edge(int to) : src(-1) , to(to) , cost(0){}
  edge(int to, T cost) : src(-1), to(to), cost(cost) {}
  edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}

  edge &operator=(const int &x) { // edge e = n; とできる(e.to = n)
    to = x;
    return *this;
  }

  // int()をオーバーロードすることで重み付きグラフと普通のグラフでライブラリを共用できる
  operator int() const { return to; } // v[e]とできる ( v[e.to]に同じ )

};

// sort用 とりあえずcostの小さいほうが左としているが適宜書き換えて使いましょう
/*template<typename T>
bool operator <(const edge<T>& e1,const edge<T>& e2){ 
  return e1.cost < e2.cost;
}*/
template< typename T >
using Edges = vector< edge< T > >;
template< typename T >
using WG = vector< Edges< T > >;
template< typename T>
using UWG = vector< vector <int> >;

// HL分解
// 木の内部の任意の2点間をO(log_V)個に分割するデータ構造。
// これを用いることで木に対してセグ木やbitなどのデータ構造を用いることが出来る。
// 以下、内部のデータの説明。(頂点0を根とした。)
// size[i] ... iの部分木の要素数 depth[i] ... iの深さ(depth[0] = 0)
// nxt[i] ... vから根に向かって伸びるheavy pathの終着点(nxt[0] = 0)
// in[i],out[i] ... オイラーツアーした時の順番。
// [ in[i] , out[i] )で部分木へのクエリとなる。
// [ in[nxt[i]] , in[v] ]でheavy pathへのクエリとなる。
// par[i] ... iの親ノード。 (par[0] = 0)
WG<int> g;

struct HLD{
  int idx;
  vector<int> size, depth, in, out, nxt, par;
  HLD(int N,int root = 0):idx(0),size(N,0),depth(N,0),in(N,-1),
    out(N,-1),nxt(N,0),par(N,0){
    dfs_sz(root);
    trc(size); trc(depth);
    dfs_hld(root);
    trc(in); trc(out); trc(nxt);trc(par);
  }
  
  // 構築
  void dfs_sz(int cur){
    size[cur] = 1;
    for(auto &dst: g[cur]){
      if(dst == par[cur]) {
        if( g[cur].size() >= 2 && int(dst) == int(g[cur][0]) ) 
          swap(g[cur][0] , g[cur][1]);
        else continue;
      }
      depth[dst] = depth[cur] + 1;
      par[dst] = cur;
      dfs_sz(dst);
      size[cur] += size[dst];
      if(size[dst] > size[g[cur][0]]){
        swap(dst , g[cur][0]);
      }
    }
  }
  void dfs_hld(int cur = 0){
    in[cur] = idx++;
    for(auto dst: g[cur]){
      if(dst == par[cur]) continue;
      nxt[dst] = ( int(dst) == int(g[cur][0]) ? nxt[cur] : int(dst) );
      dfs_hld(dst);
    }
    out[cur] = idx;
  }

  // aからbへの辺(aが根の側,bが葉の側)の持つ値をstのdata[b]に代入しているとする。
  // (すなわち、辺のデータを葉の方の頂点に移し替える。)
  // (注: 例外処理のためdata[0] = fの単位元とする。)
  // この時、st.query(u,v + 1)はpar[u]からvまでの辺へのクエリとなる。
  // (注: st.query()は引数に半開区間をため第二引数のvに1を足している。)
  // これをもとに[u , v]の辺へのクエリを実装する。

  template<typename F>
  void edge_query(int u,int v,const F& f){
    while(1){
      if(in[u] > in[v]) swap(u,v);
      trc(u,v);
      if(nxt[u] != nxt[v]){
        f(in[nxt[v]] , in[v] + 1);
        v = par[ nxt[v] ];
      }
      else{
        trc(u , v,in[u] , in[v]);
        if(u != v) f(in[u] + 1, in[v] + 1);
        break;
      }
    }
  }

  // 最小共通祖先 
  int lca(int a,int b){
    while(nxt[a] != nxt[b]){
      if(in[nxt[a]] < in[nxt[b]]) swap(a,b);
      a = par[nxt[a]];
    }
    return depth[a] < depth[b] ? a : b;
  }
};

WG<int> h;

int main(){
  ini(N,Q);
  g.resize(N);
  h.resize(N);
  vector<edge<int> > v;
  rep(i,N - 1){
    ini(a,b,c,d); a--; b--;
    g[a].eb(b , d);
    g[b].eb(a , d);
    h[c].eb(a , b , d);
    v.eb(a , b , d); 
  }
  
  auto f = [](int a,int b){
    return a + b;
  };

  HLD hl(N);

  ST<int , decltype(f) , 0> st(N,f) , cnt(N,f) , sum(N,f);
  for(auto x : v){
    int l = hl.par[x.src] == x.to ? x.src : x.to;
    st.set( hl.in[l] , x.cost);
  }
  st.build();

  vi w(Q),x(Q),y(Q),z(Q);
  vpii ans(Q);
  rep(i,Q){
    in(w[i] , x[i] , y[i] , z[i]);
    y[i]--; z[i]--;
  }
  trc("aaa");
  // 辺を訂正する前の解答
  int nyanya;
  auto nyaan = [&](int a,int b){
    nyanya += st.query(a , b);
  };
  vi curans(Q);
  rep(i,Q){
    nyanya = 0;
    hl.edge_query( y[i] , z[i] , nyaan);
    curans[i] = nyanya;
  }
  trc("aaaa");
  vector<int> ord(Q);
  iota(all(ord) , 0);
  sort(all(ord) , [&](int a,int b){
    return w[a] < w[b];
  });

  auto it = ord.begin();
  int nya,nyaa;
  auto ff = [&](int i,int j){
    nya += cnt.query(i , j);
    nyaa += sum.query(i , j);
  };

  rep(i,N){
    if(it == ord.end()) break;
    if(w[*it] > i) continue;  
    int val;
    each(e , h[i]){
      int l = (hl.par[e.to] == e.src) ? e.to : e.src;
      cnt.update( hl.in[l] , (val = 1) );
      sum.update( hl.in[l] , e.cost);
    }
    while(it != ord.end() && w[*it] == i){
      nya = nyaa = 0;
      hl.edge_query( y[*it] , z[*it] , ff);
      ans[*it] = mp(nya , nyaa);
      it++;
    }
    each(e , h[i]){
      int l = (hl.par[e.to] == e.src) ? e.to : e.src;
      cnt.update( hl.in[l] , (val = 0));
      sum.update( hl.in[l] , (val = 0));
    }
  }

  rep(i,Q){
    trc(curans[i] , ans[i]);
    out( curans[i] - ans[i].second + ans[i].first * x[i] );
  }

}

Measured memory_bytes: 23404