You are given a tree with N vertices.
Here, a tree is a kind of graph, and more specifically, a connected undirected graph with N-1 edges, where N is the number of its vertices.
The i-th edge (1≤i≤N-1) connects Vertices a_i and b_i, and has a length of c_i.

You are also given Q queries and an integer K. In the j-th query (1≤j≤Q):

* find the length of the shortest path from Vertex x_j and Vertex y_j via Vertex K.

Constraints

* 3≤N≤10^5
* 1≤a_i,b_i≤N (1≤i≤N-1)
* 1≤c_i≤10^9 (1≤i≤N-1)
* The given graph is a tree.
* 1≤Q≤10^5
* 1≤K≤N
* 1≤x_j,y_j≤N (1≤j≤Q)
* x_j≠y_j (1≤j≤Q)
* x_j≠K,y_j≠K (1≤j≤Q)

Input

Input is given from Standard Input in the following format:


N
a_1 b_1 c_1
:
a_{N-1} b_{N-1} c_{N-1}
Q K
x_1 y_1
:
x_{Q} y_{Q}


Output

Print the responses to the queries in Q lines.
In the j-th line j(1≤j≤Q), print the response to the j-th query.

Examples

Input

5
1 2 1
1 3 1
2 4 1
3 5 1
3 1
2 4
2 3
4 5


Output

3
2
4


Input

7
1 2 1
1 3 3
1 4 5
1 5 7
1 6 9
1 7 11
3 2
1 3
4 5
6 7


Output

5
14
22


Input

10
1 2 1000000000
2 3 1000000000
3 4 1000000000
4 5 1000000000
5 6 1000000000
6 7 1000000000
7 8 1000000000
8 9 1000000000
9 10 1000000000
1 1
9 10


Output

17000000000
import java.util.*;
import java.io.*;

public class Main {
    
    public static void main(String[] args) throws Exception {
        // Your code here!
        Scanner scanner = new Scanner(System.in);
        
        int N = scanner.nextInt();
        
        Map<Cost,Cost> cmap = new HashMap<>();
        PathMap pmap = new PathMap();
        
        for(int i = 0; i < N-1; i++){
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            long c = scanner.nextInt();
            Cost cost = new Cost(a,b,c);
            cmap.put(cost,cost);
            pmap.put(cost);
        }
        int Q = scanner.nextInt();
        int K = scanner.nextInt();
        
        Map<Integer,Node> nodemap = new HashMap<>();
        makeTree(K,-1,nodemap,cmap,pmap);
        
        for(int i = 0; i < Q; i++){
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            System.out.println(nodemap.get(a).costFromRoot + nodemap.get(b).costFromRoot);
        }
        
    }
    
    static void makeTree(int current, int parent, Map<Integer,Node> nodemap, Map<Cost,Cost> costmap, PathMap pathmap){
        Node node = new Node();
        node.n = current;
        node.parent = parent;
        if(parent == -1){
            node.level = 0;
            node.costFromRoot = 0;
        }else{
            node.level = nodemap.get(parent).level + 1;
            node.costFromRoot = nodemap.get(parent).costFromRoot 
                                + costmap.get(new Cost(parent,current,0)).cost;
        }
        nodemap.put(current,node);
        for(int n: pathmap.getOtherNodes(current)){
            if(n != parent)
                makeTree(n,current,nodemap,costmap,pathmap);
        }
    }
}

class PathMap {
    Map<Integer,List<Cost>> map = new HashMap<>();
    void put(Cost obj){
        if(!map.containsKey(obj.self))
            map.put(obj.self, new ArrayList<Cost>());
        if(!map.containsKey(obj.other))
            map.put(obj.other, new ArrayList<Cost>());
        map.get(obj.self).add(obj);
        map.get(obj.other).add(obj);
    }
    
    int[] getOtherNodes(int n){
        List<Cost> clist = map.get(n);
        int size = clist.size();
        int[] res = new int[size];
        for(int i = 0; i < size; i++){
            Cost c = clist.get(i);
            res[i] = c.self == n ? c.other : c.self;
        }
        return res;
    }
}

class Node {
    int n = -1;
    int parent = -1;
    //Set<Integer> children = new HashSet();
    int level = -1;
    long costFromRoot = -1;
}

class Cost {
    int self = -1;
    int other = -1;
    long cost = -1;
    Cost(int a, int b, long c){
        self = a; other = b; cost = c;
    }
    @Override
    public int hashCode(){
        return this.self + this.other;
    }
    @Override
    public boolean equals(Object obj){
        if(obj instanceof Cost){
            Cost o = (Cost)obj;
            if(o.self == this.self && o.other == this.other){
                return true;
            }else if(o.self == this.other && o.other == this.self){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }
}
