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)

// Reads multiple ints in a line, separate by a space.
// It works even if the actual number of ints is smaller than n.
// WARNING: This function does not work for -2^31.
// NOTE: This function does not handle error cases.
fun fastReadInts(n: Int): IntArray {
    val xs = IntArray(n)
    val s = readLine()!!
    var currentValue = 0
    var isNegative = false
    var currentIndex = 0
    for (c in s) {
        if (c == ' ') {
            xs[currentIndex] = currentValue * if (isNegative) -1 else 1
            currentValue = 0
            isNegative = false
            currentIndex++
        } else if (c == '-') {
            isNegative = true
        } else {
            currentValue *= 10
            currentValue += c - '0'
        }
    }
    xs[currentIndex] = currentValue * if (isNegative) -1 else 1
    return xs
}

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]
    }

}

// NOTE: This class assumes that Int.MIN_VALUE is not used as a key.
class IntIntMap {
    val nullValue = Int.MIN_VALUE
    private val initArraySize = 16
    private var arraySize = initArraySize
    private var mask = arraySize - 1
    private var keys = IntArray(arraySize, { nullValue })
    private var values = IntArray(arraySize, { nullValue })
    private var size = 0

    private fun rehash(x: Int): Int {
        var currentX = x
        var hash = x and 15
        for (i in 0 until 7) {
            currentX /= 16
            hash *= 31
            hash += currentX and 15
        }
        return hash
    }

    operator fun get(key: Int): Int {
        // println("keys: " + keys.toList())
        var hash = key
        while (true) {
            val index = hash and mask
            if (keys[index] == nullValue) return nullValue
            if (keys[index] == key) return values[index]
            hash = rehash(hash)
        }
    }

    operator fun set(key: Int, value: Int) {
        setInternal(key, value)
        if (size > arraySize / 2) expandArray()
    }

    private fun setInternal(key: Int, value: Int) {
        var hash = key
        while (true) {
            val index = hash and mask
            if (keys[index] == nullValue) {
                keys[index] = key
                values[index] = value
                size++
                return
            }
            if (keys[index] == key) {
                values[index] = value
                return
            }
            hash = rehash(hash)
        }
    }

    private fun expandArray() {
        var oldKeys = keys
        var oldValues = values
        arraySize *= 2
        mask = arraySize - 1
        keys = IntArray(arraySize, { nullValue })
        values = IntArray(arraySize, { nullValue })
        size = 0
        for (i in 0 until oldKeys.size) {
            if (oldKeys[i] != nullValue) {
                set(oldKeys[i], oldValues[i])
            }
        }
    }

    fun keys(): List<Int> = keys.filter { it != nullValue }
}

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) = fastReadInts(4)
        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) = fastReadInts(4)
        val from = fromRaw - 1
        val to = toRaw - 1
        Query(color, weightRaw.toLong(), from, to)
    })

    val lcaSolver = LcaSolver(graph)

    val queryColorsArray = Array(n, { IntIntMap() })
    for (query in queries) {
        queryColorsArray[query.from][query.color] = 1
        queryColorsArray[query.to][query.color] = 1
        queryColorsArray[lcaSolver.lca(query.from, query.to)][query.color] = 1
    }

    val weightArray = LongArray(n)
    val colorToCount = IntArray(n)
    val colorToWeight = LongArray(n)
    val vertexToColorCountMap = Array(n, { IntIntMap() })
    val vertexToColorWeightMap = Array(n, { mutableMapOf<Int, Long>() })
    fun dfs(v: Int, parent: Int, weight: Long) {
        for (c in queryColorsArray[v].keys()) {
            vertexToColorCountMap[v][c] = colorToCount[c]
            vertexToColorWeightMap[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 += (vertexToColorCountMap[query.from][query.color] * query.weight - vertexToColorWeightMap[query.from][query.color]!!)
        ans += (vertexToColorCountMap[query.to][query.color] * query.weight - vertexToColorWeightMap[query.to][query.color]!!)
        ans -= 2 * (vertexToColorCountMap[lca][query.color] * query.weight - vertexToColorWeightMap[lca][query.color]!!)
        println(ans)
    }
}

Measured memory_bytes: 206596