# -*- coding: utf-8 -*-



import sys

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



# 再帰呼び出しの回数制限(デフォルト1000)

sys.setrecursionlimit(10 ** 9)



N = int(eval(input()))

nodes = [[] for _ in range(N+1)]

for i in range(N-1):

    a, b, c = list(map(int, input().split()))

    # nodes[出発ノード](到着ノード, コスト))

    nodes[a].append((b, c))

    # 無向グラフなのでこっちも入れる

    nodes[b].append((a, c))



memo = [0] * (N+1)

def dfs(cur, prev, dist):

    memo[cur] = dist

    for nxt, cost in nodes[cur]:

        if nxt == prev:

            continue

        dfs(nxt, cur, dist+cost)



Q, K = list(map(int, input().split()))

dfs(K, -1, 0)



for i in range(Q):

    x, y = list(map(int, input().split()))

    # 今回は全てKを経由するので、Kからの距離さえ分かれば全部出る

    print((memo[x] + memo[y]))

# -*- coding: utf-8 -*-



import sys



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

def list2d(a, b, c): return [[c] * b for i in range(a)]

def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1): return int(-(-x // y))

def INT(): return int(eval(input()))

def MAP(): return list(map(int, input().split()))

def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes(): print('Yes')

def No(): print('No')

def YES(): print('YES')

def NO(): print('NO')

sys.setrecursionlimit(10 ** 9)

INF = 10 ** 18

MOD = 10 ** 9 + 7



def dijkstra(N: int, nodes: list, src: int) -> list:

    """ ダイクストラ高速化版(頂点数, 隣接リスト(0-indexed), 始点) """

    from heapq import heappush, heappop



    # 頂点[ある始点からの最短距離]

    res = [INF] * N

    # スタート位置

    que = [src]

    res[src] = 0

    # キューが空になるまで

    while len(que) != 0:

        # 距離*N + 現在のノード

        cur = heappop(que)

        # 距離とノードに分ける

        dist = cur // N

        cur %= N

        # 出発ノードcurの到着ノードでループ

        for nxt, cost in nodes[cur]:

            # 今回の経路のが短い時

            if dist + cost < res[nxt]:

                res[nxt] = dist + cost

                # 距離*N+ノード番号 の形でキューに詰める

                heappush(que, (dist+cost)*N+nxt)

    # ノードsrcからの最短距離リストを返却

    return res



N = INT()

nodes = [[] for i in range(N)]

for i in range(N-1):

    a, b, c = MAP()

    a -= 1; b -= 1

    nodes[a].append((b, c))

    nodes[b].append((a, c))



Q, K = MAP()

K -= 1

res = dijkstra(N, nodes, K)

for i in range(Q):

    x, y = MAP()

    x -= 1; y -= 1

    ans = res[x] + res[y]

    print(ans)

# -*- coding: utf-8 -*-
import sys


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


# 再帰呼び出しの回数制限(デフォルト1000)
sys.setrecursionlimit(10**9)
N = int(eval(input()))
nodes = [[] for _ in range(N + 1)]
for i in range(N - 1):
    a, b, c = list(map(int, input().split()))
    # nodes[出発ノード](到着ノード, コスト))
    nodes[a].append((b, c))
    # 無向グラフなのでこっちも入れる
    nodes[b].append((a, c))
memo = [0] * (N + 1)


def dfs(cur, prev, dist):
    memo[cur] = dist
    for nxt, cost in nodes[cur]:
        if nxt == prev:
            continue
        dfs(nxt, cur, dist + cost)


Q, K = list(map(int, input().split()))
dfs(K, -1, 0)
for i in range(Q):
    x, y = list(map(int, input().split()))
    # 今回は全てKを経由するので、Kからの距離さえ分かれば全部出る
    print((memo[x] + memo[y]))

# -*- coding: utf-8 -*-
import sys


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


def list2d(a, b, c):
    return [[c] * b for i in range(a)]


def list3d(a, b, c, d):
    return [[[d] * c for j in range(b)] for i in range(a)]


def list4d(a, b, c, d, e):
    return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]


def ceil(x, y=1):
    return int(-(-x // y))


def INT():
    return int(eval(input()))


def MAP():
    return list(map(int, input().split()))


def LIST(N=None):
    return list(MAP()) if N is None else [INT() for i in range(N)]


def Yes():
    print("Yes")


def No():
    print("No")


def YES():
    print("YES")


def NO():
    print("NO")


sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 10**9 + 7


def dijkstra(N: int, nodes: list, src: int) -> list:
    """ダイクストラ高速化版(頂点数, 隣接リスト(0-indexed), 始点)"""
    from heapq import heappush, heappop

    # 頂点[ある始点からの最短距離]
    res = [INF] * N
    # スタート位置
    que = [src]
    res[src] = 0
    # キューが空になるまで
    while len(que) != 0:
        # 距離*N + 現在のノード
        cur = heappop(que)
        # 距離とノードに分ける
        dist = cur // N
        cur %= N
        # 出発ノードcurの到着ノードでループ
        for nxt, cost in nodes[cur]:
            # 今回の経路のが短い時
            if dist + cost < res[nxt]:
                res[nxt] = dist + cost
                # 距離*N+ノード番号 の形でキューに詰める
                heappush(que, (dist + cost) * N + nxt)
    # ノードsrcからの最短距離リストを返却
    return res


N = INT()
nodes = [[] for i in range(N)]
for i in range(N - 1):
    a, b, c = MAP()
    a -= 1
    b -= 1
    nodes[a].append((b, c))
    nodes[b].append((a, c))
Q, K = MAP()
K -= 1
res = dijkstra(N, nodes, K)
for i in range(Q):
    x, y = MAP()
    x -= 1
    y -= 1
    ans = res[x] + res[y]
    print(ans)

-# 再帰呼び出しの回数制限(デフォルト1000) -sys.setrecursionlimit(10**9) -N = int(eval(input())) -nodes = [[] for _ in range(N + 1)] -for i in range(N - 1): -    a, b, c = list(map(int, input().split())) -    # nodes[出発ノード](到着ノード, コスト)) -    nodes[a].append((b, c)) -    # 無向グラフなのでこっちも入れる -    nodes[b].append((a, c)) -memo = [0] * (N + 1) +def list2d(a, b, c): +    return [[c] * b for i in range(a)] -def dfs(cur, prev, dist): -    memo[cur] = dist -    for nxt, cost in nodes[cur]: -        if nxt == prev: -            continue -        dfs(nxt, cur, dist + cost) +def list3d(a, b, c, d): +    return [[[d] * c for j in range(b)] for i in range(a)] -Q, K = list(map(int, input().split())) -dfs(K, -1, 0) +def list4d(a, b, c, d, e): +    return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)] + + +def ceil(x, y=1): +    return int(-(-x // y)) + + +def INT(): +    return int(eval(input())) + + +def MAP(): +    return list(map(int, input().split())) + + +def LIST(N=None): +    return list(MAP()) if N is None else [INT() for i in range(N)] + + +def Yes(): +    print("Yes") + + +def No(): +    print("No") + + +def YES(): +    print("YES") + + +def NO(): +    print("NO") + + +sys.setrecursionlimit(10**9) +INF = 10**18 +MOD = 10**9 + 7 + + +def dijkstra(N: int, nodes: list, src: int) -> list: +    """ダイクストラ高速化版(頂点数, 隣接リスト(0-indexed), 始点)""" +    from heapq import heappush, heappop + +    # 頂点[ある始点からの最短距離] +    res = [INF] * N +    # スタート位置 +    que = [src] +    res[src] = 0 +    # キューが空になるまで +    while len(que) != 0: +        # 距離*N + 現在のノード +        cur = heappop(que) +        # 距離とノードに分ける +        dist = cur // N +        cur %= N +        # 出発ノードcurの到着ノードでループ +        for nxt, cost in nodes[cur]: +            # 今回の経路のが短い時 +            if dist + cost < res[nxt]: +                res[nxt] = dist + cost +                # 距離*N+ノード番号 の形でキューに詰める +                heappush(que, (dist + cost) * N + nxt) +    # ノードsrcからの最短距離リストを返却 +    return res + + +N = INT() +nodes = [[] for i in range(N)] +for i in range(N - 1): +    a, b, c = MAP() +    a -= 1 +    b -= 1 +    nodes[a].append((b, c)) +    nodes[b].append((a, c)) +Q, K = MAP() +K -= 1 +res = dijkstra(N, nodes, K) -    x, y = list(map(int, input().split())) -    # 今回は全てKを経由するので、Kからの距離さえ分かれば全部出る -    print((memo[x] + memo[y])) +    x, y = MAP() +    x -= 1 +    y -= 1 +    ans = res[x] + res[y] +    print(ans)