#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <tuple>
#include <unordered_set>
#include <vector>

template <typename N = std::size_t, typename E = std::size_t> class SparseGraph
{
public:
    using NodeType = N;
    using EdgeType = E;
    using NeighborListType = std::unordered_set<std::size_t>;

    SparseGraph(bool undirected = true) noexcept
        : undirected_(undirected)
    {
    }

    void push_node(NodeType n) noexcept
    {
        nodes_.push_back(n);
        neighbor_list_.emplace_back();
    }

    void connect(const std::size_t from, const std::size_t to, const EdgeType edge = EdgeType()) noexcept
    {
        if (undirected_)
        {
            neighbor_list_[from].insert(to);
            neighbor_list_[to].insert(from);
            edges_[std::make_pair(std::min(from, to), std::max(from, to))] = edge;
        }
        else
        {
            neighbor_list_[from].insert(to);
            edges_[std::make_pair(from, to)] = edge;
        }
    }

    void disconnect(const std::size_t from, const std::size_t to) noexcept
    {
        if (undirected_)
        {
            neighbor_list_[from].erase(to);
            neighbor_list_[to].erase(from);
            edges_.erase(std::make_pair(std::min(from, to), std::max(from, to)));
        }
        else
        {
            neighbor_list_[from].erase(to);
            edges_.erase(std::make_pair(from, to));
        }
    }

    const NodeType& node(const std::size_t index) const noexcept { return nodes_.at(index); }

    NodeType& node(const std::size_t index) noexcept { return nodes_.at(index); }

    const EdgeType& edge(const std::size_t from, const std::size_t to) const noexcept
    {
        if (undirected_)
        {
            auto key = std::make_pair(std::min(from, to), std::max(from, to));
            return edges_.at(key);
        }
        else
        {
            auto key = std::make_pair(from, to);
            return edges_.at(key);
        }
    }

    EdgeType& edge(const std::size_t from, const std::size_t to) noexcept
    {
        if (undirected_)
        {
            auto key = std::make_pair(std::min(from, to), std::max(from, to));
            return edges_.at(key);
        }
        else
        {
            auto key = std::make_pair(from, to);
            return edges_.at(key);
        }
    }

    const NeighborListType& neighbor(const std::size_t index) const noexcept { return neighbor_list_[index]; }

    std::size_t size() const noexcept { return neighbor_list_.size(); }

    SparseGraph<N, E> decide_root(const int node_index) const noexcept
    {
        SparseGraph<N, E> graph(false);
        for (int i = 0; i < nodes_.size(); i++)
        {
            graph.push_node(node(i));
        }

        std::queue<int> que;
        que.push(node_index);
        std::vector<bool> visited(size(), false);
        visited[node_index] = false;

        while (!que.empty())
        {
            const int node = que.front();
            que.pop();
            for (auto next : neighbor(node))
            {
                if (!visited[next])
                {
                    graph.connect(node, next, edge(node, next));
                    visited[next] = true;
                    que.push(next);
                }
            }
        }
        return graph;
    }

private:
    using EdgeMap = std::map<std::pair<std::size_t, std::size_t>, EdgeType>;

    std::vector<NeighborListType> neighbor_list_;

    EdgeMap edges_;

    std::vector<NodeType> nodes_;

    bool undirected_;
};

using namespace std;

void bfs(SparseGraph<size_t, size_t>& graph, std::vector<std::size_t>& distance, int start)
{
    queue<pair<size_t, size_t>> que;
    que.emplace(0, start);
    std::fill(distance.begin(), distance.end(), 0);

    while (!que.empty())
    {
        size_t dist, node;
        tie(dist, node) = que.front();
        que.pop();

        for (auto next : graph.neighbor(node))
        {
            if (next != start && distance[next] == 0)
            {
                distance[next] = dist + graph.edge(node, next);
                que.emplace(distance[next], next);
            }
        }
    }
}

int main()
{
    int n;
    cin >> n;

    SparseGraph<> graph;
    for (int i = 0; i < n; i++)
    {
        graph.push_node(i);
    }

    for (int i = 0; i < n - 1; i++)
    {
        size_t a, b, c;
        cin >> a >> b >> c;
        graph.connect(a - 1, b - 1, c);
    }

    int q, k;
    cin >> q >> k;
    k--;

    std::vector<std::size_t> distance_from_k(n, 0);
    bfs(graph, distance_from_k, k);

    for (int i = 0; i < q; i++)
    {
        int x, y;
        cin >> x >> y;
        cout << (distance_from_k[x - 1] + distance_from_k[y - 1]) << endl;
    }
}


Measured memory_bytes: 28076