#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath> // 変数名にy1が使えなくなるかも…。
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <limits>
#include <string>

typedef __int128_t int128_t;
std::istream &operator>>(std::istream& input, int128_t& value) { // int128_tの入力。入力が64bitに収まる前提。
    long long tmp; input >> tmp; value = tmp;
    return input;
}
std::ostream &operator<<(std::ostream& output, const int128_t value) { // int128_tの出力。出力が64bitに収まる前提。
    output << (long long)value;
    return output;
}

// binary search result
struct BSR {
    bool found; // 条件を満たす範囲が見つかったか。falseの場合、begin,endは意味を持たない。
    int128_t begin; // [begin, end]で条件が成り立つ。
    int128_t end;

    BSR(bool found_in, int128_t begin_in, int128_t end_in) : found(found_in), begin(begin_in), end(end_in) {}
};

template<class Fn> BSR binary_search(int128_t L, int128_t R, Fn func) {
    const bool res_L = func(L);
    const bool res_R = func(R);
    if (res_L && res_R) {
        return BSR(true, L, R);
    } else if (!res_L && !res_R) {
        return BSR(false, 0, 0);
    } else {
        int128_t lb = L;
        int128_t ub = R;
        while (lb + 1 < ub) {
            int128_t mid = (lb + ub) / 2;
            if (res_L == func(mid)) {
                lb = mid;
            } else {
                ub = mid;
            }
        }
        return res_L ? BSR(true, L, lb) : BSR(true, ub, R);
    }
}

// 木のクラス。
// 有向グラフと同様に表現する。
// （Tipsに含まれている関数で、こちらに移植していないものがあるので注意。）
class Tree_New {
    public:
    struct Edge { 
        int to; int64_t cost;
    };
    typedef std::vector<std::vector<Edge>> adj_list;
    adj_list G;
    int node_num;
    Tree_New() {}
    Tree_New(const int node_num_in) {
        node_num = node_num_in;
        G.resize(node_num);
    }
    void add_edge(const int from, const int to, const long long cost) {
        Edge edge; edge.to = to; edge.cost = cost;
        G[from].push_back(edge);
    }
    void add_edge_both(const int node1, const int node2, const long long cost) {
        add_edge(node1, node2, cost);
        add_edge(node2, node1, cost);
    }
    void cal_rank_child(int n, int r, int parent, std::vector<int>& rank) { // 辺が有向でも無向でも使える。呼び出すとき、parentは-1にしておくとよい。
        rank[n] = r;
        for (Edge e : G[n]) {
            if (e.to != parent) {
                cal_rank_child(e.to, r + 1, n, rank);
            }
        }
    }
    std::vector<int> cal_rank(const int root) { // root を根としたときのrankを計算する。
        assert(root < node_num);
        std::vector<int> rank; rank.resize(node_num, -1);
        cal_rank_child(root, 0, -1, rank);
        return rank;
    }

    void cal_parent_child(int n, int p, std::vector<int>& parent) {
        parent[n] = p;
        for (Edge e : G[n]) {
            if (e.to != p) {
                cal_parent_child(e.to, n, parent);
            }
        }
    };
    std::vector<int> cal_parent(const int root) { // root を根としたときの親を計算する。有向木では行うまでもない。rootの親はrootとしておく。
        assert(root < node_num);
        std::vector<int> parent; parent.resize(node_num, -1);
        cal_parent_child(root, root, parent);
        return parent;
    }
    std::vector<std::vector<int>> cal_parent_doubling(const int root) {
        // parentのダブリング構築。ret[i][n]は、nから2^iだけ親の方へ進んだ節点になる。
        std::vector<std::vector<int>> ret;
        std::vector<int> parent = cal_parent(root);
        ret.push_back(parent);
        while (true) {
            std::vector<int> pd; pd.resize(node_num);
            bool end_flag = true;
            for (int i = 0; i < node_num; i++) {
                if (ret.back()[i] == root || ret.back()[i] == -1) {
                    pd[i] = ret.back()[i];
                } else {
                    pd[i] = ret.back()[ret.back()[i]];
                    if (pd[i] != root) { 
                        end_flag = false;
                    }
                }
            }
            ret.push_back(pd);
            if (end_flag) { break; }
        }
        return ret;
    }
    int cal_ancestor(int node, int num, const std::vector<std::vector<int>>& parent_doubling) {
        // parent_doublingを利用して、nodeからnumだけ根の方向に進んだノードを求める。
        for (int i = 0; 0 < num; i++) {
            if (num % 2 == 1) {
                node = parent_doubling[i][node];
            }
            num /= 2;
        }
        return node;
    }
    int lca(int u, int v, const std::vector<int>& rank, const std::vector<std::vector<int>>& parent_doubling) {
        // rank と parent_doublingから、least common ancestorを計算。
        if (rank[u] < rank[v]) {
            v = cal_ancestor(v, rank[v] - rank[u], parent_doubling);
        } else {
            u = cal_ancestor(u, rank[u] - rank[v], parent_doubling);
        }
        assert(rank[v] == rank[u]);
        if (u == v) { return u; }
        int lb = 0; int ub = rank[u];
        while (lb + 1 < ub) {
            int mid = (lb + ub) / 2;
            if (cal_ancestor(u, mid, parent_doubling) == cal_ancestor(v, mid, parent_doubling)) {
                ub = mid;
            } else {
                lb = mid;
            }
        }
        return cal_ancestor(u, ub, parent_doubling);
    }

    void dfs_in_order_child(int n, int parent, std::vector<std::pair<int, int>>& order) {
        order.push_back({parent, n});
        for (Edge e : G[n]) {
            if (e.to != parent) {
                dfs_in_order_child(e.to, n, order);
            }
        }
        order.push_back({n, parent});
    } 
    std::vector<std::pair<int, int>> dfs_in_order(const int root) { 
        // root を根としたdfsで、通りがけ順に辺を並べる。オイラーツアーというらしい。
        // 全ての辺が、子に向かう方向と根に向かう方向でそれぞれ1度カウントされるので、サイズは(N-1)*2となる。
        assert(root < node_num);
        std::vector<std::pair<int, int>> order;
        for (Edge e : G[root]) {
            dfs_in_order_child(e.to, root, order);
        }
        return order;
    }
};

const int MAX_N = 1e5 + 10;
const int MAX_Q = 1e5 + 10;
int N, Q;
int a[MAX_N], b[MAX_N], c[MAX_N], d[MAX_N];
int x[MAX_Q], y[MAX_Q], u[MAX_N], v[MAX_N];

Tree_New tree = Tree_New(MAX_N);
std::map<std::pair<int, int>, int> edge_mp;

int color_num_tmp[MAX_N] = {};
int color_dist_tmp[MAX_N] = {};

std::vector<int> color_id[MAX_N], color_num[MAX_N], color_dist[MAX_N];
std::vector<int> first; 

int calc(int u, int nc, int nd) {
    if (u == 1) { return 0; }
    int ret = color_dist[0][first[u]];
    if (0 < color_id[nc].size()) {
        assert(color_id[nc].size() == color_dist[nc].size());
        assert(color_id[nc].size() == color_num[nc].size());
        auto bsr = binary_search(0, color_id[nc].size() - 1, [&](const int i){
            return color_id[nc][i] <= first[u];
        });
        if (bsr.found) {
            ret -= color_dist[nc][bsr.end];
            ret += color_num[nc][bsr.end] * nd;
        }
    }
    assert(ret <= 1e9);
    return ret;
} 

int main(int argc, char **argv) {
    std::cin >> N >> Q;

    for (int i = 1; i <= N-1; i++) {
        std::cin >> a[i] >> b[i] >> c[i] >> d[i];
    }

    for (int i = 1; i <= Q; i++) {
        std::cin >> x[i] >> y[i] >> u[i] >> v[i];
    }

    for (int i = 1; i <= N - 1; i++) {
        tree.add_edge_both(a[i], b[i], d[i]);
        edge_mp[{a[i], b[i]}] = i;
        edge_mp[{b[i], a[i]}] = i;
    }

    auto rank = tree.cal_rank(1);
    auto pd = tree.cal_parent_doubling(1);
    auto in_order = tree.dfs_in_order(1);
    assert(in_order.size() == (N-1)*2);

    first.resize(MAX_N, -1);
    std::vector<int> edge_ap; edge_ap.resize(MAX_N, 0);
    for (int i = 0; i < in_order.size(); i++) {
        if (first[in_order[i].second] < 0) {
            first[in_order[i].second] = i;
        }
        int ei = edge_mp[in_order[i]];
        if (edge_ap[ei]) {
            assert(edge_ap[ei] == 1);
            color_num_tmp[c[ei]]--;
            color_dist_tmp[c[ei]] -= d[ei];
            color_dist_tmp[0] -= d[ei];
        } else {
            color_num_tmp[c[ei]]++;
            color_dist_tmp[c[ei]] += d[ei];
            color_dist_tmp[0] += d[ei];
            edge_ap[ei]++;
        }
        color_id[c[ei]].push_back(i);
        color_num[c[ei]].push_back(color_num_tmp[c[ei]]);
        color_dist[c[ei]].push_back(color_dist_tmp[c[ei]]);
        color_dist[0].push_back(color_dist_tmp[0]);
    }
 
    for(int i = 1; i <= Q; i++) {
        int anc = tree.lca(u[i], v[i], rank, pd);
        int ret = calc(u[i], x[i], y[i]) + calc(v[i], x[i], y[i]) - calc(anc, x[i], y[i]) * 2;
        std::cout << ret << std::endl;
    }

    return 0;
}

Measured memory_bytes: 49512