#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <algorithm>
#include <sstream>
#include <cmath>
#include <set>
#include <iomanip>
#include <deque>
#include <stdio.h>
#include <random>
using namespace std;
 
#define REP(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
#define RREP(i,n) for(int (i)=(int)(n)-1;i>=0;i--)
#define REMOVE(Itr,n) (Itr).erase(remove((Itr).begin(),(Itr).end(),n),(Itr).end())
typedef long long ll;
 
struct LCA {
 
    int N,LOG_N;
    vector< vector< int > > parent;
    vector< vector< int > > G;
    vector< int > depth;
 
    LCA (int n) : N(n), depth(n), G(n), LOG_N((int)(log2(n)+1)) {
        parent = vector< vector< int > >(LOG_N, vector<int>(N));
    }
 
    void add_edge(int a, int b) {
        G[a].push_back(b);
        G[b].push_back(a);
    }
    
    void init(int root) {
        dfs(root, -1, 0);
        for (int k = 0; k + 1 < LOG_N; k++) {
            for (int v = 0; v < N; v++) {
                if (parent[k][v] < 0) parent[k+1][v] = -1;
                else parent[k+1][v] = parent[k][parent[k][v]];
            }
        }
    }
 
    void dfs(int v, int p, int d) {
        parent[0][v] = p;
        depth[v] = d;
        for (int i = 0; i < G[v].size(); i++) {
            if (G[v][i] != p) dfs(G[v][i], v, d+1);
        }
    }
 
    int dist(int a, int b) {
        int par = getParent(a,b);
        return depth[a] + depth[b] - depth[par] * 2;
    }
    
    int getParent(int u, int v) {
        if (depth[u] > depth[v]) swap(u,v);
        for (int k = 0; k < LOG_N; k++) {
            if (((depth[v] - depth[u]) >> k) & 1) v = parent[k][v];
        }
        if (u == v) return u;
        for (int k = LOG_N - 1; k >= 0; k--) {
            if(parent[k][u] != parent[k][v]){
                u = parent[k][u];
                v = parent[k][v];
            }
        }
        return parent[0][u];
    }
 
};
 
template <class T> struct Dijkstra {

    struct Edge{
        int to;
        T cost;
        Edge(int _to, T _cost) : to(_to), cost(_cost) {}
    };
    
    const T INF = numeric_limits<T>::max() / 2;
    vector< vector< Edge > > G;
    vector< T > d;
    Dijkstra (int n) : G(n), d(n) {}

    void add_directed_edge(int a, int b, T c) {
        G[a].push_back(Edge(b,c));
    }
    
    void add_undirected_edge(int a, int b, T c) {
        G[a].push_back(Edge(b,c));
        G[b].push_back(Edge(a,c));
    }

    void init(int s) {
        priority_queue< pair<T,int>,vector< pair<T,int> >, greater< pair<T,int> > > que;
        fill(d.begin(), d.end(), INF);
        d[s] = 0;
        que.push(make_pair(0,s));
        while (!que.empty()){
            pair<T,int> p = que.top();
            que.pop();
            int v = p.second;
            if (d[v] < p.first) continue;
            for (int i = 0; i < G[v].size(); i++) {
                Edge e = G[v][i];
                if (d[e.to] > d[v] + e.cost) {
                    d[e.to] = d[v] + e.cost;
                    que.push(make_pair(d[e.to],e.to));
                }
            }
        }
    }
    
    T dist(int a) {
        return d[a];
    }
    
}; 

 
 
int main() {
 
    LCA inst(100010);
    Dijkstra<ll> inst1(100010);
 
    int N; cin >> N;
    REP(i,N-1) {
        int a,b;
        ll c;
        cin >> a >> b >> c;
        inst.add_edge(a,b);
        inst1.add_undirected_edge(a,b,c);
    }
 
    inst.init(1);
 
    int Q,K; cin >> Q >> K;    
    inst1.init(K);
    REP(i,Q) {
        int a,b;
        cin >> a >> b;
        if(inst.dist(a,b) == inst.dist(a,K) + inst.dist(b,K)) {
            cout << inst1.dist(a) + inst1.dist(b) << endl;
        }else {
            cout << inst1.dist(a) + inst1.dist(b) << endl;
        }
    }
 
    return 0;
}
 
 




Measured memory_bytes: 25080