data class Edge(val from: Int, val to: Int, val color: Int, val weight: Long)
data class Query(val color: Int, val weight: Long, val from: Int, val to: Int)

class LcaSolver(val graph: Array<List<Edge>>) {
    private val maxLogV = 18
    private val n = graph.size
    private val parentMatrix = Array(maxLogV, { IntArray(n) })
    private val depthArray = IntArray(n)

    init {
        fun dfs(v: Int, parent: Int, depth: Int) {
            parentMatrix[0][v] = parent
            depthArray[v] = depth
            for (e in graph[v]) {
                if (e.to == parent) continue
                dfs(e.to, v, depth + 1)
            }
        }
        dfs(0, -1, 0)

        for (k in 0 until maxLogV - 1) {
            for (v in 0 until n) {
                if (parentMatrix[k][v] < 0) parentMatrix[k + 1][v] = -1
                else parentMatrix[k + 1][v] = parentMatrix[k][parentMatrix[k][v]]
            }
        }
    }

    fun lca(u: Int, v: Int): Int {
        if (depthArray[u] > depthArray[v]) return lca(v, u)
        var mu = u
        var mv = v
        for (k in 0 until maxLogV) {
            if ((depthArray[mv] - depthArray[mu]) shr k and 1 > 0) {
                mv = parentMatrix[k][mv]
            }
        }
        if (mu == mv) return mu

        for (k in maxLogV - 1 downTo 0) {
            if (parentMatrix[k][mu] != parentMatrix[k][mv]) {
                mu = parentMatrix[k][mu]
                mv = parentMatrix[k][mv]
            }
        }
        return parentMatrix[0][mu]
    }

}

fun main(args: Array<String>) {
    val (n, numQ) = readLine()!!.split(" ").map { it.toInt() }
    val mutableGraph = Array(n, { mutableListOf<Edge>() })
    repeat( n - 1) {
        val (fromRaw, toRaw, color, weightRaw) = readLine()!!.split(" ").map { it.toInt() }
        val from = fromRaw - 1
        val to = toRaw - 1
        val weight = weightRaw.toLong()
        // val edge = Edge(from, to, color, weight)
        mutableGraph[from].add(Edge(from, to, color, weight))
        mutableGraph[to].add(Edge(to, from, color, weight))
    }
    val graph = Array(n, { mutableGraph[it].toList() })
    val queries = Array(numQ, {
        val (color, weightRaw, fromRaw, toRaw) = readLine()!!.split(" ").map { it.toInt() }
        val from = fromRaw - 1
        val to = toRaw - 1
        Query(color, weightRaw.toLong(), from, to)
    })

    val lcaSolver = LcaSolver(graph)

    val queryColorsArray = Array(n, { mutableSetOf<Int>() })
    for (query in queries) {
        queryColorsArray[query.from].add(query.color)
        queryColorsArray[query.to].add(query.color)
        queryColorsArray[lcaSolver.lca(query.from, query.to)].add(query.color)
    }

    val weightArray = LongArray(n)
    val colorToCount = IntArray(n)
    val colorToWeight = LongArray(n)
    val colorToCountArray = Array(n, { mutableMapOf<Int, Int>() })
    val colorToWeightArray = Array(n, { mutableMapOf<Int, Long>() })
    fun dfs(v: Int, parent: Int, weight: Long) {
        for (c in queryColorsArray[v]) {
            colorToCountArray[v][c] = colorToCount[c]
            colorToWeightArray[v][c] = colorToWeight[c]
        }

        weightArray[v] = weight
        for (e in graph[v]) {
            if (e.to == parent) continue
            colorToCount[e.color]++
            colorToWeight[e.color] += e.weight
            dfs(e.to, v, weight + e.weight)
            colorToCount[e.color]--
            colorToWeight[e.color] -= e.weight
        }
    }
    dfs(0, -1, 0L)

    for (query in queries) {
        val lca = lcaSolver.lca(query.from, query.to)
        var ans = weightArray[query.from] + weightArray[query.to] - 2 * weightArray[lca]
        ans += (colorToCountArray[query.from][query.color]!! * query.weight - colorToWeightArray[query.from][query.color]!!)
        ans += (colorToCountArray[query.to][query.color]!! * query.weight - colorToWeightArray[query.to][query.color]!!)
        ans -= 2 * (colorToCountArray[lca][query.color]!! * query.weight - colorToWeightArray[lca][query.color]!!)
        println(ans)
    }
}