package main

import (
    "bufio"
    "os"
    "strconv"
    "fmt"
    "container/heap"
)

const INF = 100000000000000


/*********** PriorityQueue ***********/
type PriorityQueue struct {
    arr []interface{}
    comp []CompFunc
}

type CompFunc func(p, q interface{}) int

func NewPriorityQueue() *PriorityQueue {
    return new(PriorityQueue)
}

func (pq PriorityQueue) Len() int {
    return len(pq.arr)
}

func (pq PriorityQueue) Swap(i, j int) {
    pq.arr[i], pq.arr[j] = pq.arr[j], pq.arr[i]
}

func (pq PriorityQueue) Less(i, j int) bool{
    for _, comp := range pq.comp {
        result := comp(pq.arr[i], pq.arr[j])
        switch result {
            case -1: return true
            case 1:  return false
            case 0:  continue
        }
    }
    return true
}

func (pq *PriorityQueue) Push(x interface{}) {
    pq.arr = append(pq.arr, x)
}

func (pq *PriorityQueue) Pop() interface{} {
    n := pq.Len()
    item := pq.arr[n - 1]
    pq.arr = pq.arr[:n - 1]
    return item
}

func (pq *PriorityQueue) IsEmpty() bool {
    return pq.Len() == 0
}

/* for dijkstra */
/* type Edge */
type Edge struct {
    to int
    cost int
}

/* type State */
type State struct {
    score int
    node int
}

/* type Graph */
type Graph struct {
    starts []State
    edges [][]Edge
    size int
    comp []CompFunc
    defaultScore int
}

func dijkstra(graph *Graph) []int {
    var score []int
    for i := 0; i < graph.size; i++ {
        score = append(score, graph.defaultScore)
    }
    que := new(PriorityQueue)
    que.comp = graph.comp
    for _, start := range graph.starts {
        score[start.node] = start.score
        heap.Push(que, start)
    }
    for !que.IsEmpty() {
        state := heap.Pop(que).(State)
        for _, edge := range graph.edges[state.node] {
            newScore := state.score + edge.cost
            if score[edge.to] > newScore {
                score[edge.to] = newScore
                heap.Push(que, State{score: newScore, node: edge.to})
            }
        }
    }
    return score
}



/* input */
var sc = bufio.NewScanner(os.Stdin)

func readInt() int {
    sc.Scan()
    n, _ := strconv.Atoi(sc.Text())
    return n
}

func main() {
    sc.Split(bufio.ScanWords)
    n := readInt()
    var edges [][]Edge
    for i := 0; i < n; i++ {
        edges = append(edges, make([]Edge, 0))
    }
    for i := 0; i < n - 1; i++ {
        a, b, c := readInt() - 1, readInt() - 1, readInt()
        edges[a] = append(edges[a], Edge{to: b, cost: c})
        edges[b] = append(edges[b], Edge{to: a, cost: c})
    }

    comp := func(p, q interface{}) int {
        if p.(State).score < q.(State).score {
            return -1
        } else if p.(State).score == q.(State).score {
            return 1
        } else {
            return 0
        }
        return 0
    }

    q, k := readInt(), readInt() - 1
    
    graph := new(Graph)
    graph.size = n
    graph.starts = make([]State, 0)
    graph.starts = append(graph.starts, State{score: 0, node: k})
    graph.edges = edges
    graph.comp = make([]CompFunc, 0)
    graph.comp = append(graph.comp, comp)
    graph.defaultScore = INF
    
    dist := dijkstra(graph)
    
    wtr := bufio.NewWriter(os.Stdout)
    for i := 0; i < q; i++ {
        x, y := readInt() - 1, readInt() - 1
        fmt.Fprintln(wtr, dist[x] + dist[y])
    }
    wtr.Flush()
}


Measured memory_bytes: 19840