from collections import defaultdict

def solve():
    n, q = map(int, input().split())
    adj_list = defaultdict(list)
    weights = {}
    for _ in range(n - 1):
        u, v, w = map(int, input().split())
        adj_list[u].append(v)
        adj_list[v].append(u)
        weights[(u, v)] = w
        weights[(v, u)] = w
    
    # Compute min_time values
    min_time_values = {}
    
    def min_time(node, visited_key, visited_trap):
        if (node, visited_key, visited_trap) in min_time_values:
            return min_time_values[(node, visited_key, visited_trap)]
        
        # Base cases
        if visited_key and not visited_trap and node == trap:
            return float('inf')
        if visited_trap and not visited_key and node == key:
            return float('inf')
        if visited_key and visited_trap and (node == key or node == trap):
            return 0
        if node not in adj_list:
            return float('inf')
        
        # Recursive cases
        min_time_with_key = float('inf')
        min_time_without_key = float('inf')
        for child in adj_list[node]:
            if child == parent[node]:
                continue
            rest_of_tree = [n for n in adj_list[node] if n != child] + [parent[node]]
            min_time_with_key = min(min_time_with_key,
                                    min_time(child, True, visited_trap) +
                                    min_time(rest_of_tree, visited_key, True))
            min_time_without_key = min(min_time_without_key,
                                       min_time(child, visited_key, visited_trap) +
                                       min_time(rest_of_tree, True, True))
        result = weights[(parent[node], node)] + min(min_time_with_key, min_time_without_key)
        min_time_values[(node, visited_key, visited_trap)] = result
        return result
    
    # Process scenarios
    for _ in range(q):
        start, key, trap = map(int, input().split())
        parent = defaultdict(int)
        visited = defaultdict(bool)
        stack = [start]
        while stack:
            node = stack.pop()
            visited[node] = True
            for child in adj_list[node]:
                if child != parent[node]:
                    parent[child] = node
                    stack.append(child)
        if not visited[key] or not visited[trap]:
            print('impossible')
        else:
            print(min_time(start, False, False) + weights[(parent[start], start)])