import qualified Data.Set as S
import qualified Data.ByteString.Char8 as B
import qualified Data.Array.IArray as A
import qualified Data.IntMap.Strict as M
import Control.Monad

readIntPair :: B.ByteString -> [(Int, Int)]
readIntPair = map (pair . map readInt . B.words) . B.lines

pair :: [t] -> (t, t)
pair [x, y] = (x, y)
pair _ = undefined

main = do
  n <- readLn
  es <- readUndirectedEdge <$> replicateM (n-1) B.getLine
  [q,k] <- map read . words <$> getLine
  xys <- readIntPair <$> B.getContents
  let g = buildG (1,n) es
  let m = dijkstra g k
  putStrLn $ unwords $ map (show . transit m) xys

transit m (x,y) = m M.! x + m M.! y  

type Bound = (Vertex, Vertex)
type Vertex = Int
type Weight = Int
type Edge = ((Vertex, Vertex), Weight)
type Graph = A.Array Vertex [(Vertex, Weight)]

buildG :: Bound -> [Edge] -> Graph
buildG b = A.accumArray (flip (:)) [] b . map (\((s, t), w) -> (s, (t, w)))

from :: Graph -> Vertex -> [(Vertex, Weight)]
from = (A.!)

readUndirectedEdge :: [B.ByteString] -> [Edge]
readUndirectedEdge = concatMap (constructTwoWay . map readInt . B.words)

constructTwoWay :: [Int] -> [Edge]
constructTwoWay [s,t,w] = [((s, t), w), ((t, s), w)]
constructTwoWay _ = undefined

readInt :: B.ByteString -> Int
readInt = maybe undefined fst . B.readInt

type Memo = M.IntMap Weight

dijkstra :: Graph -> Vertex -> Memo
dijkstra g s = _dijkstra g q0 m0
  where
   q0 = singleton (0, s)
   m0 = M.singleton s 0

_dijkstra :: Graph -> PriorityQueue -> Memo -> Memo
_dijkstra g q m
  | isEmpty q = m
  | otherwise = _dijkstra g q2 m1
  where
    ((w0, s), q1) = deleteFindMin q
    m1 = foldr (\(t, w) acc -> M.insertWith min t (w0 + w) acc) m vns
    q2 = foldr (\(t, w) acc -> insert (w0 + w, t) acc) q1 vns
    vns = filter (\(t, w) -> M.notMember t m || w0 + w <= m M.! t) (from g s)

type PriorityQueue = S.Set (Weight, Vertex)

isEmpty :: PriorityQueue -> Bool
isEmpty = S.null

singleton :: (Weight, Vertex) -> PriorityQueue
singleton = S.singleton

insert :: (Weight, Vertex) -> PriorityQueue -> PriorityQueue
insert = S.insert

deleteFindMin :: PriorityQueue -> ((Weight, Vertex), PriorityQueue)
deleteFindMin = S.deleteFindMin
