Problem:
Score : 600 points

Problem Statement

There is a tree with N vertices numbered 1 to N.
The i-th edge in this tree connects Vertex a_i and Vertex b_i, and the color and length of that edge are c_i and d_i, respectively.
Here the color of each edge is represented by an integer between 1 and N-1 (inclusive). The same integer corresponds to the same color, and different integers correspond to different colors.

Answer the following Q queries:

Query j (1 \leq j \leq Q): assuming that the length of every edge whose color is x_j is changed to y_j, find the distance between Vertex u_j and Vertex v_j. (The changes of the lengths of edges do not affect the subsequent queries.)

Constraints

2 \leq N \leq 10^5

1 \leq Q \leq 10^5

1 \leq a_i, b_i \leq N

1 \leq c_i \leq N-1

1 \leq d_i \leq 10^4

1 \leq x_j \leq N-1

1 \leq y_j \leq 10^4

1 \leq u_j < v_j \leq N

The given graph is a tree.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N Q
a_1 b_1 c_1 d_1
:
a_{N-1} b_{N-1} c_{N-1} d_{N-1}
x_1 y_1 u_1 v_1
:
x_Q y_Q u_Q v_Q

Output

Print Q lines. The j-th line (1 \leq j \leq Q) should contain the answer to Query j.

Sample Input 1

5 3
1 2 1 10
1 3 2 20
2 4 4 30
5 2 1 40
1 100 1 4
1 100 1 5
3 1000 3 4

Sample Output 1

130
200
60

The graph in this input is as follows:

Here the edges of Color 1 are shown as solid red lines, the edge of Color 2 is shown as a bold green line, and the edge of Color 4 is shown as a blue dashed line.

Query 1: Assuming that the length of every edge whose color is 1 is changed to 100, the distance between Vertex 1 and Vertex 4 is 100 + 30 = 130.

Query 2: Assuming that the length of every edge whose color is 1 is changed to 100, the distance between Vertex 1 and Vertex 5 is 100 + 100 = 200.

Query 3: Assuming that the length of every edge whose color is 3 is changed to 1000 (there is no such edge), the distance between Vertex 3 and Vertex 4 is 20 + 10 + 30 = 60. Note that the edges of Color 1 now have their original lengths.

Solution in PyPy3 (7.3.0) (judge verdict: Wrong Answer)

import sys
sys.setrecursionlimit(10**6)
from collections import defaultdict
class LCA:

    def __init__(self,n):
        self.size = n+1
        x = 1
        while 1<<x < n:
            x += 1
        self.bitlen = x
        self.lca = [[0]*self.bitlen for i in range(self.size)]
        self.depth = [-1]*self.size
    def dfs(self,now,par,dep):
        if self.depth[now] >= 0:
            return self.lca[now][0]
        self.lca[now][0] = par
        self.depth[now] = dep
        for nex in e[now]:
            if nex[0] == par or self.depth[nex[0]] >= 0:
                continue
            self.dfs(nex[0],now,dep+1)
        return self.lca[now][0]
    def make(self,root):
        self.dfs(root,0,0)
        for i in range(1,self.bitlen):
            for j in range(self.size):
                self.lca[j][i] = self.lca[self.lca[j][i-1]][i-1]
    
    def search(self,x,y):
        dx = self.depth[x]
        dy = self.depth[y]
        if dx < dy:
            x,y = y,x
            dx,dy = dy,dx
        dif = dx-dy
        while dif:
            s = dif & (-dif)
            x = self.lca[x][s.bit_length()-1]
            dif -= s
        if x == y:
            return x
        for i in range(self.bitlen-1,-1,-1):
            if self.lca[x][i] != self.lca[y][i]:
                x = self.lca[x][i]
                y = self.lca[y][i]
        return self.lca[x][0]

n,q = map(int,input().split())
e = [[] for i in range(n+1)]
for i in range(n-1):
    a,b,c,d = map(int,input().split())
    e[a].append((b,c,d))
    e[b].append((a,c,d))
    
lca = LCA(n)
lca.make(1)

Q = []
dcount = defaultdict(lambda : defaultdict(int))
dweight = defaultdict(lambda : defaultdict(int))
for i in range(q):
    x,y,u,v = map(int,input().split())
    a = lca.search(u,v)
    dcount[u][x] = -1
    dcount[v][x] = -1
    dcount[a][x] = -1
    dweight[u][x] = -1
    dweight[v][x] = -1
    dweight[a][x] = -1
    Q.append((x,y,u,v,a))

dis = [-1]*(n+1)
dis[0] = 0
count1 = [0]*(n+1)
count2 = [0]*(n+1)
def dfs1(now,p,c,d):
    if dis[now] >= 0:
        return dis[now]
    dis[now] = dis[p]+d
    count1[c] += 1
    count2[c] += d
    for cou in dcount[now]:
        dcount[now][cou] = count1[cou]
    for wei in dweight[now]:
        dweight[now][wei] = count2[wei]

    for nex in e[now]:
        if nex[0] == p or dis[nex[0]] >= 0:
            continue
        dfs1(nex[0],now,nex[1],nex[2])
    return dis[now]
dfs1(1,0,0,0)

for x,y,u,v,a in Q:
    cal = dis[u]+dis[v]-2*dis[a]
    cal += y*(dcount[u][x]+dcount[v][x]-2*dcount[a][x]) - dweight[u][x]-dweight[v][x]+2*dweight[a][x]
    print(cal)