output_description: Print Q lines. The j-th line (1 \leq j \leq Q) should contain the answer to
  Query j.
  
  * * *
input_description: 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
attempt: import sys
  
  sys.setrecursionlimit(10**7)
  
  n, q = map(int, input().split())
  abcd = [list(map(int, input().split())) for _ in range(n - 1)]
  xyuv = [list(map(int, input().split())) for _ in range(q)]
  g = [[] for _ in range(n)]
  for a, b, c, d in abcd:
      a, b = a - 1, b - 1
      g[a].append((b, c, d))
      g[b].append((a, c, d))
  # LCAを求める。自作する。
  # 各頂点の深さ。根は深さ0
  depth = [0] * n
  tour = []
  hatsu = [0] * n
  dist = [0] * n
  tmp = 0
  
  
  def et(p, v, tour):
      global tmp
      for nv, c, d in g[v]:
          if nv == p:
              continue
          hatsu[nv] = len(tour)
          tour.append((nv, c, d))
          depth[nv] = depth[v] + 1
          tmp += d
          dist[nv] = tmp
          tour = et(v, nv, tour)
          tmp -= d
          tour.append((nv, c, -d))
      return tour
  
  
  tour.append((0, 0, 0))
  tour = et(-1, 0, tour)
  
  
  class SegmentTree:
      def __init__(self, size, f=lambda x, y: x + y, default=0):
          self.size = pow(2, (size - 1).bit_length())
          self.f = f
          self.default = default
          self.data = [default] * (self.size * 2)
  
      def update(self, i, x):
          i += self.size
          self.data[i] = x
          while i:
              i >>= 1
              self.data[i] = self.f(self.data[i * 2], self.data[i * 2 + 1])
  
      # 区間[l,r)へのクエリ
      def query(self, l, r):
          l, r = l + self.size, r + self.size
          lret, rret = self.default, self.default
          while l < r:
              if l & 1:
                  lret = self.f(self.data[l], lret)
                  l += 1
              if r & 1:
                  r -= 1
                  rret = self.f(self.data[r], rret)
              l >>= 1
              r >>= 1
          return self.f(lret, rret)
  
  
  def func(x, y):
      if x[0] < y[0]:
          return x
      return y
  
  
  st = SegmentTree(len(tour), func, (n + 1, 0))
  for i, x in enumerate(tour):
      v = x[0]
      st.update(i, (depth[v], v))
  
  
  def lca(u, v):
      return st.query(hatsu[u], hatsu[v] + 1)[1]
  
  
  dc = {}
  dcary = {}
  for i, (v, c, d) in enumerate(tour):
      if c in dc:
          ci = 1 if d > 0 else -1
          dc[c].append((dc[c][-1][0] + ci, dc[c][-1][1] + d))
          dcary[c].append(i)
      else:
          dc[c] = [(0, 0), (1, d)]
          dcary[c] = [0, i]
  from bisect import bisect_right as bl
  
  for x, y, u, v in xyuv:
      u, v = u - 1, v - 1
      w = lca(u, v)
      uvlen = dist[u] + dist[v] - dist[w] * 2
      if x not in dc:
          print(uvlen)
          continue
      widx = bl(dcary[x], hatsu[w]) - 1
      wnum, wsum = dc[x][widx]
      uidx = bl(dcary[x], hatsu[u]) - 1
      vidx = bl(dcary[x], hatsu[v]) - 1
      unum, usum = dc[x][uidx]
      vnum, vsum = dc[x][vidx]
      uvsum = usum + vsum - wsum * 2
      uvnum = unum + vnum - wnum * 2
      # print(uvlen-uvsum+uvnum*y,uvlen,usum,vsum,wsum,uvnum)
      print(uvlen - uvsum + uvnum * y)
  exit()
  for k in dc:
      print("=====", k, "=====")
      print(dcary[k])
      print(dc[k])
  print(hatsu)
  
  """
  5 3
  1 2 1 10
  1 3 2 20
  2 4 4 30
  5 2 1 40
  1 100 1 4
  1 100 3 4
  4 1000 3 4
  
  """
  
problem_description: 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.)
samples: [{"input": "5 3\n    1 2 1 10\n    1 3 2 20\n    2 4 4 30\n    5 2 1 40\n    1 100 1 4\n    1 100 1 5\n    3 1000 3 4", "output": "130\n    200\n    60\n    \n\nThe graph in this input is as follows:\n\n![Figure](https://img.atcoder.jp/ghi/ca75688b08f73eb63a30ce6daa54a781.png)\n\nHere the edges of Color 1 are shown as solid red lines, the edge of Color 2 is\nshown as a bold green line, and the edge of Color 4 is shown as a blue dashed\nline.\n\n  * 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.\n  * 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.\n  * 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."}]