#include <bits/stdc++.h>
using namespace std;

#define int long long

int n;
int q, k;

// vector<vector<pair<int, int>>> G;

// struct LCA {
//     int V, logV;
//     vector<int> depth, len;
//     vector<vector<int> > parent;
//
//     LCA(int V) {
//         this->V = V;
//         logV = 0;
//         while (V > (1LL<<logV)) logV++;
//         this->depth = vector<int>(V);
//         this->len = vector<int>(V);
//         this->parent = vector<vector<int> >(logV, vector<int>(V));
//     }
//
//     void init(int v, int par, int d, int l) {
//         depth[v] = d;
//         parent[0][v] = par;
//         len[v] = l;
//         for (int i = 0; i < (int)G[v].size(); i++) {
//             int w = G[v][i].first;
//             int lc = G[v][i].second;
//             if (w == par) continue;
//             init(w, v, d+1, lc + l);
//         }
//     }
//
//     void build() {
//         for (int k = 0; k + 1 < logV; k++) {
//             for (int v = 0; v < V; v++) {
//                 if (parent[k][v] < 0) parent[k+1][v] = -1;
//                 else parent[k+1][v] = parent[k][parent[k][v]];
//             }
//         }
//     }
//
//     int query(int u, int v) {
//         if (depth[u] > depth[v]) swap(u, v);
//         for (int k = 0; k < logV; k++) {
//             if ((depth[v] - depth[u]) >> k & 1)
//                 v = parent[k][v];
//         }
//         if (u == v) return u;
//
//         for (int k = logV-1; k >= 0; k--) {
//             if (parent[k][u] != parent[k][v]) {
//                 u = parent[k][u];
//                 v = parent[k][v];
//             }
//         }
//         return parent[0][u];
//     }
//
//     int dist(int u, int v) {
//       int z = query(u, v);
//       return len[u] + len[v] - 2 * len[z];
//     }
//
//     int solver(int u, int v, int k) {
//       return dist(u, k) + dist(k, v);
//     }
// };

struct LowestCommonAncestor {
  const int MAX_LOG_V = 50;

  int V, root = 0;
  vector<vector<pair<int, int>>> G;
  vector<int> depth, length;
  vector<vector<int> > parent;

  LowestCommonAncestor() {}
  LowestCommonAncestor(int V) : V(V) { init(); }
  LowestCommonAncestor(int V, int root) : V(V), root(root) { init(); }

  void init() {
    G.resize(V);
    depth.resize(V);
    length.resize(V);
    parent.resize(MAX_LOG_V, vector<int>(V));
  }

  void add_edge(int u, int v, int c) {
    G[u].push_back(make_pair(v, c));
    G[v].push_back(make_pair(u, c));
  }

  void add_edge(int u, int v) {
    add_edge(u, v, 1);
  }

  void dfs(int v, int u, int d, int l){
    depth[v] = d;
    length[v] = l;
    parent[0][v] = u;
    for (int i = 0; i < G[v].size(); ++i) {
      pair<int, int> p = G[v][i];
      if (p.first != u) {
        dfs(p.first, v, d + 1, l + p.second);
      }
    }
  }

  void build() {
    dfs(root, -1, 0, 0);
    for (int k = 0; k + 1 < MAX_LOG_V; k++) {
      for (int v = 0; v < V; v++) {
        if (parent[k][v] < 0) parent[k + 1][v] = -1;
        else parent[k + 1][v] = parent[k][parent[k][v]];
      }
    }
  }

  int lca(int u, int v) {
    if (depth[u] > depth[v]) swap(u, v);
    for (int k = 0; k < MAX_LOG_V; k++) {
      if ((depth[v] - depth[u]) >> k & 1) {
        v = parent[k][v];
      }
    }

    if (u == v) return u;

    for (int k = MAX_LOG_V - 1; k >= 0; k--) {
      if (parent[k][u] != parent[k][v]) {
        u = parent[k][u];
        v = parent[k][v];
      }
    }

    return parent[0][u];
  }

  int dist(int u, int v) {
    int z = lca(u, v);
    return length[u] + length[v] - 2 * length[z];
  }
};

signed main() {
  cin >> n;

  LowestCommonAncestor LCA(n);
  // G.resize(n);
  for (int i = 0; i < n - 1; ++i) {
    int u, v, c;
    cin >> u >> v >> c;
    u--; v--;

    LCA.add_edge(u, v, c);
    // G[u].push_back(make_pair(v, c));
    // G[v].push_back(make_pair(u, c));
  }

  LCA.build();

  // LCA po(n);
  // po.init(0, -1, 0, 0);
  // po.build();

  cin >> q >> k;
  while (q--) {
    int x, y;
    cin >> x >> y;

    cout << LCA.dist(x - 1, k - 1) + LCA.dist(k - 1, y - 1) << endl;;
    // cout << po.solver(x - 1, y - 1, k - 1) << endl;
  }
}


Measured memory_bytes: 54000