/*
 *                             _ooOoo_
 *                            o8888888o
 *                            88" . "88
 *                            (| -_- |)
 *                            O\  =  /O
 *                         ____/`---'\____
 *                       .'  \\|     |//  `.
 *                      /  \\|||  :  |||//  \
 *                     /  _||||| -:- |||||-  \
 *                     |   | \\\  -  /// |   |
 *                     | \_|  ''\---/''  |   |
 *                     \  .-\__  `-`  ___/-. /
 *                   ___`. .'  /--.--\  `. . __
 *                ."" '<  `.___\_<|>_/___.'  >'"".
 *               | | :  `- \`.;`\ _ /`;.`/ - ` : | |
 *               \  \ `-.   \_ __\ /__ _/   .-` /  /
 *          ======`-.____`-.___\_____/___.-`____.-'======
 *                             `=---='
 *          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 *                     佛祖保佑        永无BUG
 */

#include<bits/stdc++.h>

#define ll long long

using namespace std;
const int maxn = 1e5 + 1000;
int n, t, k;
//long long dis[maxn];
//int vis[maxn];
//int la[maxn];
//struct node {
//    int from, to;
//    long long val;
//} e[maxn * 4];
//
//struct mua{
//    int s,val;
//    bool operator<(const mua&a)const {
//        return val>a.val;
//    }
//};
//
//priority_queue<mua>q;
//
//void dijstra(int s){
//    for(int i=0;i<n;i++) dis[i] = 1e16;
//    mua now;
//    now.val=0,now.s=s;
//    q.push(now);
//    while (!q.empty()){
//        now = q.top(),q.pop();
//        if(vis[now.s]) continue;
//        for(int i=la[now.s];i;i=e[i].to){
//            int to=e[i].from;
//            if (dis[to]>dis[now.s]+e[i].val)
//            {
//                dis[to]=dis[now.s]+e[i].val;
//                mua nex;
//                nex.s=to; nex.val=dis[to];
//                q.push(nex);
//            }
//        }
//        vis[now.s]=1;
//    }
//}
const int MAXN = 1e5+1000;
const int INF = 0x3f3f3f3f;

struct Edge {
    int v;
    long long  cost;

    Edge(int _v = 0, int _cost = 0) : v(_v), cost(_cost) {}
};

vector<Edge> E[MAXN];

void addEdge(int u, int v, int w) {
    E[u].push_back(Edge(v, w));
}

bool vis[MAXN]; // 在队列标志
int cnt[MAXN]; // 每个点的⼊列队次数
long long  dist[MAXN];

bool SPFA(int start, int n) {
    memset(vis, false, sizeof(vis));
    memset(dist, 0x3f, sizeof(dist));
    vis[start] = true;
    dist[start] = 0;
    queue<int> que;
    while (!que.empty()) {
        que.pop();
    }
    que.push(start);
    memset(cnt, 0, sizeof(cnt));
    cnt[start] = 1;
    while (!que.empty()) {
        int u = que.front();
        que.pop();
        vis[u] = false;
        for (int i = 0; i < E[u].size(); i++) {
            int v = E[u][i].v;
            if (dist[v] > dist[u] + E[u][i].cost) {
                dist[v] = dist[u] + E[u][i].cost;
                if (!vis[v]) {
                    vis[v] = true;
                    que.push(v);
                    if (++cnt[v] > n) {
                        return false; // cnt[i]为⼊队列次数，⽤来判定是否存在负环回路
                    }
                }
            }
        }
    }
    return true;
}

int main() {
    cin >> n;
    int a, b;
    long long c;
    for (int i = 0; i < n-1; i++) {
        cin >> a >> b >> c;
        addEdge(a,b,c);
        addEdge(b,a,c);
    }
    cin >> t >> k;
    SPFA(k,2*n);
    for (int i = 0; i < t; i++) {
        cin >> a >> b;
        cout << dist[a] + dist[b] << endl;
    }
    return 0;
}


Measured memory_bytes: 10496