// May this submission get accepted
#include <bits/stdc++.h>

// エイリアス
using  ll = long signed long;
using ull = long unsigned long;
using  ld = long double;
using namespace std;

// AtCoder/Codeforces 用 デバッグ検知
#ifdef ONLINE_JUDGE
constexpr bool DEBUG_MODE = false;
#else
constexpr bool DEBUG_MODE = true;
#endif

// エイリアス (補完・コンパイルが重くなる)
// #include <boost/multiprecision/cpp_int.hpp>
// using mll = boost::multiprecision::cpp_int;

// 汎用マクロ
#define ALL_OF(x) (x).begin(), (x).end()
#define REP(i,n) for (long long i=0, i##_len=(n); i<i##_len; i++)
#define RANGE(i,is,ie) for (long long i=(is), i##_end=(ie); i<=i##_end; i++)
#define DSRNG(i,is,ie) for (long long i=(is), i##_end=(ie); i>=i##_end; i--)
#define STEP(i, is, ie, step) for (long long i=(is), i##_end=(ie), i##_step = (step); i<=i##_end; i+=i##_step)
#define UNIQUE(v) do { sort((v).begin(), (v).end()); (v).erase(unique((v).begin(), (v).end()), (v).end()); } while (false)
#define FOREACH(i,q) for (auto &i : q)
template<class T> bool chmax(T &a, const T b) { if (a < b) {a = b; return true;} return false; }
template<class T> bool chmin(T &a, const T b) { if (a > b) {a = b; return true;} return false; }
constexpr int INF = numeric_limits<int>::max();
constexpr long long LINF = numeric_limits<long long>::max();
constexpr long double EPS = 1e-10L;
#define Yes(q) ((q) ? "Yes" : "No")
#define YES(q) ((q) ? "YES" : "NO")
#define Possible(q) ((q) ? "Possible" : "Impossible")
#define POSSIBLE(q) ((q) ? "POSSIBLE" : "IMPOSSIBLE")
#define IIF(q,t,f) ((q) ? (t) : (f))
#define DUMP(q) DUMP_FUNC(q, #q, __FILE__, __LINE__)
template <typename T> void DUMP_PROC(T x) { if (is_integral<T>() || is_floating_point<T>()) cerr << "\e[32m" << x << "\e[m"; else cerr << x; }
template<> void DUMP_PROC<char>(char x) { cerr << "\e[36m\'" << x << "\'\e[m"; }
template<> void DUMP_PROC<string>(string x) { cerr << "\e[33m\"" << x << "\"\e[m"; }
template <typename T, typename U> void DUMP_PROC(pair<T, U> x) { cerr << "{"; DUMP_PROC(x.first); cerr << ", "; DUMP_PROC(x.second); cerr << "}"; }
template <typename ...T, typename U, U... Seq> void DUMP_PROC(tuple<T...> &x, integer_sequence<U, Seq...>) { (void)(int[]){(cerr << ((const char*[]){"", ", "})[!!Seq] << (DUMP_PROC(get<Seq>(x)), ""), 0)...}; }
template <typename ...T> void DUMP_PROC(tuple<T...> x) {cerr << "{"; DUMP_PROC(x, index_sequence_for<T...>()); cerr << "}";}
template <typename T> void DUMP_PROC(vector<T> x) { cerr << "["; for (auto &xi : x) { DUMP_PROC(xi); cerr << (&xi != &*x.rbegin()?", ":""); } cerr << "]"; }
template <typename T> void DUMP_FUNC(T x, const char* name, const char* fn, int ln) { cerr << "\e[32m[DEBUG]\e[m " << name << ": "; DUMP_PROC(x); cerr << " @ " << fn << "(" << ln << ")" << endl; }

// gcc拡張マクロ
#define popcount __builtin_popcount
#define popcountll __builtin_popcountll

// 標準入出力
struct qin { // query input
    size_t sz;
    qin(size_t _sz = 1) : sz(_sz) {}
    template <typename T> operator T () const { T a; cin >> a; return a; }
    template <typename T> operator vector<T> () const { vector<T> a(sz); for (size_t i = 0; i < sz; i++) cin >> a[i]; return a; }
    template <typename T, typename U> operator pair<T, U> () const { T f; U s; cin >> f >> s; return pair<T, U>(f, s); }
};
qin in1; // input one
template <typename T> void say(const T x, const char* end = "\n") { cout << x << end; }
void say(const ld x, const char* end = "\n") { cout << setprecision(30) << x << end; }
template <typename T> void say(const vector<T> x, const char* sep = " ", const char* end = "\n") { REP(i, x.size()) { cout << x[i] << (i+1 == i_len ? end : sep); } }
template <typename T> void say(const vector<vector<T>> x, const char* sep = " ", const char* end = "\n") { REP(i, x.size()) { say(x[i], sep, end); } }

// モジュール
// [[LIBRARY]] lca.cpp eulertour.cpp
// [Inclusion] eulertour.cpp
// 辺ベースのオイラーツアー、ds[i]が頂点iに下る辺、us[i]が頂点iから上る辺に対応、根にも仮の辺がある
struct euler_tour {

    ll idx, n, root;
    vector<vector<ll>> g;
    vector<ll> dep, ds, us;
    vector<pair<ll, char>> tour; // {vertex id, 'D'|'U'}

    // _gは無向木の隣接リスト、_rootは根とする辺
    // 構築にO(N)かかる
    euler_tour(const vector<vector<ll>> &_g, ll _root = 0) :
        idx(0), n(_g.size()), root(_root), g(_g),
        dep(n), ds(n), us(n), tour()
    {
        tour.reserve(n*2);
        dfs(root, -1, 0);
        assert(idx == n*2); // gが木ならば、gの任意の頂点に下る/から上る回数はちょうど1回ずつのはず
    }

    void dfs(ll u, ll p, ll d) {
        dep[u] = d;
        tour.emplace_back(u, 'D');
        ds[u] = idx++;
        for (ll v : g[u]) {
            if (v != p) {
                dfs(v, u, d+1);
            }
        }
        tour.emplace_back(u, 'U');
        us[u] = idx++;
    }
    
};

// [Inclusion] lca.cpp
// Lowest Common Ancestor 最小共通祖先
struct tree_doubling {
    
    ll N, LOG_N;
    vector<ll> depth;
    vector<vector<ll>> par;
    ll root;
    const vector<vector<ll>> &g;
    
    // g は 0-indexed の隣接リスト
    tree_doubling(const vector<vector<ll>> &_g, const ll _root = 0) : N(_g.size()), depth(N, -1), par(N), g(_g), root(_root) {
        
        // LOG_N を厳密に求める O(log N)
        N = g.size();
        for (LOG_N = 0; (1LL << LOG_N) <= N; LOG_N++);
        
        // ダブリングリストの用意 O(N)
        for (ll i = 0; i < N; i++) {
            par[i] = vector<ll>(LOG_N + 1, -1);
        }
        
        // DFS
        dfs_doubling(root);
        
    }
    
    ll lca(ll u, ll v) {
        
        if (depth[u] > depth[v]) swap(u, v);
        
        REP(k, LOG_N + 1) {
            if ((depth[v] - depth[u]) >> k & 1) {
                v = par[v][k];
            }
        }
        if (u == v) return u;
        DSRNG(k, LOG_N, 0) {
            if (par[u][k] != par[v][k]) {
                u = par[u][k];
                v = par[v][k];
            }
        }
        return par[u][0];
        
    }
    
private:
    
    void dfs_doubling(ll i, ll from = -1, ll d = 0) {
        depth[i] = d;
        // ダブリングリストの更新
        par[i][0] = from;
        for (ll k = 0; k < LOG_N; k++) {
            if (par[i][k] == -1) {
                par[i][k + 1] = -1;
            } else {
                par[i][k + 1] = par[par[i][k]][k];
            }
        }
        // DFS
        for (const ll &c : g[i]) {
            if (c != from) {
                dfs_doubling(c, i, d + 1);
            }
        }
    }
    
};

// [[/LIBRARY]]

// 処理内容
int main() {
    
    ios::sync_with_stdio(false); // stdioを使うときはコメントアウトすること
    cin.tie(nullptr);            // インタラクティブ問題ではコメントアウトすること
    
    ll n, q; cin >> n >> q;
    vector<vector<ll>> g(n);
    vector<tuple<ll, ll, ll, ll>> edges;
    REP(i, n-1) {
        ll a, b, c, d; cin >> a >> b >> c >> d;
        a--; b--; c--;
        g[a].push_back(b);
        g[b].push_back(a);
        edges.emplace_back(a, b, c, d);
    }

    euler_tour et(g);
    tree_doubling tdb(g);

    vector<ll> cu(n, -1), du(n, -1);
    REP(i, n-1) {
        ll a, b, c, d;
        tie(a, b, c, d) = edges[i];
        if (et.dep[a] > et.dep[b]) swap(a, b);
        cu[b] = c;
        du[b] = d;
    }

    vector<vector<tuple<ll, ll, ll>>> h(n);
    vector<tuple<ll, ll, ll, ll>> queries;
    REP(i, q) {
        ll x, y, u, v; cin >> x >> y >> u >> v;
        x--; u--; v--;
        ll l = tdb.lca(u, v);
        h[u].emplace_back(x, 0, 0);
        h[v].emplace_back(x, 0, 0);
        h[l].emplace_back(x, 0, 0);
        queries.emplace_back(x, y, u, v);
    }

    REP(i, n) {
        UNIQUE(h[i]);
    }

    vector<ll> cn(n, 0), cl(n, 0);
    vector<ll> dl(n);
    
    ll ddd = 0;
    REP(i, et.tour.size()) {
        auto &e = et.tour[i];
        ll u; char dir; tie(u, dir) = e;
        ll c = cu[u];
        ll d = du[u];
        if (dir == 'D') {
            if (c != -1) {
                cn[c]++;
                cl[c] += d;
                ddd += d;
            }
            REP(j, h[u].size()) {
                ll cj = get<0>(h[u][j]);
                get<1>(h[u][j]) = cn[cj];
                get<2>(h[u][j]) = cl[cj];
            }
            dl[u] = ddd;
        } else {
            if (c != -1) {
                cn[c]--;
                cl[c] -= d;
                ddd -= d;
            }
        }
    }

    REP(i, q) {
        ll x, y, u, v; tie(x, y, u, v) = queries[i];
        // if (et.us[v] < et.ds[u]) swap(u, v);
        ll l = tdb.lca(u, v);
        ll ans = dl[u] + dl[v] - dl[l] * 2;
        auto itru = lower_bound(ALL_OF(h[u]), make_tuple(x, 0LL, 0LL));
        auto itrv = lower_bound(ALL_OF(h[v]), make_tuple(x, 0LL, 0LL));
        auto itrl = lower_bound(ALL_OF(h[l]), make_tuple(x, 0LL, 0LL));
        ll cqn = get<1>(*itru) + get<1>(*itrv) - get<1>(*itrl) * 2;
        ll cql = get<2>(*itru) + get<2>(*itrv) - get<2>(*itrl) * 2;
        ans -= cql;
        ans += cqn * y;
        say(ans);
    }
    
}

Measured memory_bytes: 63084