import types

_atcoder_code = """
# Python port of AtCoder Library.
__all__ = ["string","lazysegtree","convolution","maxflow","modint"
    ,"mincostflow","segtree","_scc","_math","math","dsu","twosat","fenwicktree","scc","_bit","lca","unverified","graph","matrix","algebra","combinatorics"]
__version__ = '0.0.1'
"""

atcoder = types.ModuleType('atcoder')
exec(_atcoder_code, atcoder.__dict__)

_atcoder_lca_code = """
# Lowest Common Ancestor
# 0-indexed

class LowestCommonAncestor:
    '''
    assert given_graph is tree.
    '''

    def __init__(self, edges):
        self.n = len(edges)
        self.edges = edges
        self.dfs()
        self.doubling()

    def dfs(self):
        parents = [-1] * self.n
        depths = [-1] * self.n
        depths[0] = 0
        todo = [0]
        while todo:
            a = todo.pop()
            for b in self.edges[a]:
                if depths[b] + 1:
                    continue
                parents[b] = a
                depths[b] = depths[a] + 1
                todo.append(b)
        self.parents = parents
        self.depths = depths

    def doubling(self):
        dbl = [self.parents]
        for _ in range(max(self.depths).bit_length()-1):
            parents = dbl[-1]
            new_parents = [-1] * self.n
            for i in range(self.n):
                if parents[i] + 1:
                    new_parents[i] = parents[parents[i]]
            dbl.append(new_parents)
        self.dbl = dbl

    def lca(self, a, b):
        if self.depths[a] < self.depths[b]:
            a, b = b, a
        for i in range((self.depths[a]-self.depths[b]).bit_length()):
            if self.depths[a]-self.depths[b] >> i & 1:
                a = self.dbl[i][a]

        if a == b:
            return a

        for i in range(self.depths[a].bit_length())[::-1]:
            if self.dbl[i][a] == self.dbl[i][b]:
                continue
            a, b = self.dbl[i][a], self.dbl[i][b]
        assert self.dbl[0][a] == self.dbl[0][b]
        return self.dbl[0][a]
"""

atcoder.lca = types.ModuleType('atcoder.lca')
exec(_atcoder_lca_code, atcoder.lca.__dict__)
LowestCommonAncestor = atcoder.lca.LowestCommonAncestor



# from atcoder.lca import LowestCommonAncestor
import sys


def input():
    return sys.stdin.readline().rstrip()


DXY = [(0, -1), (1, 0), (0, 1), (-1, 0)]  # LDRU
mod = 998244353
inf = 1 << 64


def main():
    n = int(input())
    g = [[] for i in range(n)]
    lca_g = [[] for i in range(n)]

    for i in range(n - 1):
        u, v, w = map(int, input().split())
        g[u].append((v, w))
        g[v].append((u, w))
        lca_g[u].append(v)
        lca_g[v].append(u)

    lca = LowestCommonAncestor(lca_g)
    q = int(input())
    Q = [tuple(map(int, input().split())) for i in range(q)]
    dist = [inf]*(n)
    S = 0
    dist[S] = 0
    que = [~S, S]
    while que:
        p = que.pop()
        if p >= 0:
            for q, w in g[p]:
                if dist[q] == inf:
                    dist[q] = dist[p] + w
                    que.append(~q)
                    que.append(q)
    for x, y, z in Q:
        ans = 0
        xy, yz, zx = lca.lca(x, y), lca.lca(y, z), lca.lca(z, x)
        ans += (dist[x] + dist[y] - 2 * dist[xy])
        ans += (dist[y] + dist[z] - 2 * dist[yz])
        ans += (dist[z] + dist[x] - 2 * dist[zx])
        ans //= 2
        print(ans)
    return 0


if __name__ == "__main__":
    main()