require "set"

class Tree
  def initialize
    @nodes = {}
  end

  def add_node(id)
    @nodes[id] ||= Node.new(id)
  end

  def add_edge(id1, id2, weight = 1)
    @nodes[id1].add_edge(@nodes[id2], weight)
    @nodes[id2].add_edge(@nodes[id1], weight)
  end

  def weight_lca(id1, id2, edges, overwrite_w)
    lca_id = lca(id1, id2)
    weight = 0
    # id1/id2 -> lca_idの距離の和
    [id1, id2].each do |id|
      next if id == lca_id
      nid = id
      loop do
        cur_id = nid
        nid = @next_nodes[0][nid]
        n = @nodes[cur_id]
        n1, n2 = [cur_id, nid].sort
        weight += if edges && edges[n1] && edges[n1].include?(n2)
                    overwrite_w
                  else
                    n.weights[@nodes[nid]]
                  end
        break if nid == lca_id
      end
    end
    weight
  end

  # Lowest Common Ancestor : 最小共通祖先
  def lca_setup(root_id = nil)
    root_id ||= @nodes.values.first.tap { |n| n.depth = 0 }.id
    n = @nodes.size
    @log_n = Math.log2(n).floor
    # next_nodes[0]の計算
    @next_nodes = [{ root_id => -1 }]
    @nodes[root_id].dfs(nil, @next_nodes[0]) do |v, _, n, on|
      v[on.id] = n.id
      v
    end
    # next_nodes[1〜log_n-1]の計算
    0.upto(@log_n - 1) do |k|
      @next_nodes[k + 1] = {}
      @nodes.keys.each do |i|
        nid = @next_nodes[k][i]
        if nid == -1
          @next_nodes[k + 1][i] = -1
        else
          @next_nodes[k + 1][i] = @next_nodes[k][nid]
        end
      end
    end
  end

  def lca_next(id, step)
    nid = id
    (@log_n - 1).downto(0) do |k|
      return -1 if nid == -1
      if ((step >> k) & 1) == 1
        nid = @next_nodes[k][nid]
      end
    end
    nid
  end

  def lca(id1, id2)
    n1 = @nodes[id1]
    n2 = @nodes[id2]
    # depthを合わせる
    if n1.depth != n2.depth
      n1, n2 = [n1, n2].sort_by { |n| n.depth }.reverse
      new_n1_id = lca_next(n1.id, n1.depth - n2.depth)
      n1 = @nodes[new_n1_id]
    end
    return n1.id if n1.id == n2.id
    # 探索
    ([@log_n - 1, Math.log2(n1.depth).floor].min).downto(0) do |k|
      if @next_nodes[k][n1.id] != @next_nodes[k][n2.id]
        lca(@next_nodes[k][n1.id], @next_nodes[k][n2.id])
      elsif k.zero?
        return @next_nodes[k][n1.id]
      end
    end
  end

  class Node
    attr_reader :id, :weights
    attr_accessor :depth
    def initialize(id)
      @id = id
      @depth = nil
      @weights = {}
    end

    def add_edge(other_node, weight)
      @weights[other_node] = weight
    end

    # Depth First Search : 深さ優先探索
    def dfs(other_node, total_val, depth = 0, visited = Set.new, &block)
      visited << @id
      @depth = depth
      @weights.each do |on, w|
        next if visited.include?(on.id)
        val = yield(total_val, w, self, on)
        if on == other_node
          return val
        elsif !on.weights.empty?
          val = on.dfs(other_node, val, depth + 1, visited, &block)
          next if val.nil?
          return val
        end
      end
      nil
    end
  end
end

tree = Tree.new
edge_color = {}
N, Q = gets.chomp.split(" ").map(&:to_i)
1.upto(N) { |i| tree.add_node(i) }
(N-1).times do
  n1, n2, c, d = gets.chomp.split(" ").map(&:to_i)
  tree.add_edge(n1, n2, d)
  edge_color[c] ||= {}
  ns, nl = [n1, n2].sort
  edge_color[c][ns] ||= Set.new
  edge_color[c][ns] << nl
end

tree.lca_setup
Q.times do
  c, d, n1, n2 = gets.chomp.split(" ").map(&:to_i)
  puts tree.weight_lca(n1, n2, edge_color[c], d)
end
