Gildong was hiking a mountain, walking by millions of trees. Inspired by them, he suddenly came up with an interesting idea for trees in data structures: What if we add another edge in a tree?

Then he found that such tree-like graphs are called 1-trees. Since Gildong was bored of solving too many tree problems, he wanted to see if similar techniques in trees can be used in 1-trees as well. Instead of solving it by himself, he's going to test you by providing queries on 1-trees.

First, he'll provide you a tree (not 1-tree) with n vertices, then he will ask you q queries. Each query contains 5 integers: x, y, a, b, and k. This means you're asked to determine if there exists a path from vertex a to b that contains exactly k edges after adding a bidirectional edge between vertices x and y. A path can contain the same vertices and same edges multiple times. All queries are independent of each other; i.e. the added edge in a query is removed in the next query.

Input

The first line contains an integer n (3 ≤ n ≤ 10^5), the number of vertices of the tree.

Next n-1 lines contain two integers u and v (1 ≤ u,v ≤ n, u ≠ v) each, which means there is an edge between vertex u and v. All edges are bidirectional and distinct.

Next line contains an integer q (1 ≤ q ≤ 10^5), the number of queries Gildong wants to ask.

Next q lines contain five integers x, y, a, b, and k each (1 ≤ x,y,a,b ≤ n, x ≠ y, 1 ≤ k ≤ 10^9) – the integers explained in the description. It is guaranteed that the edge between x and y does not exist in the original tree.

Output

For each query, print "YES" if there exists a path that contains exactly k edges from vertex a to b after adding an edge between vertices x and y. Otherwise, print "NO".

You can print each letter in any case (upper or lower).

Example

Input


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


Output


YES
YES
NO
YES
NO

Note

The image below describes the tree (circles and solid lines) and the added edges for each query (dotted lines).

<image>

Possible paths for the queries with "YES" answers are: 

  * 1-st query: 1 – 3 – 2 
  * 2-nd query: 1 – 2 – 3 
  * 4-th query: 3 – 4 – 2 – 3 – 4 – 2 – 3 – 4 – 2 – 3 
import java.io.*;
import java.util.*;

public class Main {
    static PrintWriter out = new PrintWriter(System.out);
    static Scanner sc = new Scanner(System.in);
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    List<Integer>[] tree;
    int[][] father;
    int[] depth;
    int maxj=17;
    public static void main(String[] args) throws IOException {
        Main main = new Main();
        main.solve();
        out.flush();
    }
    void solve(){
        int n = sc.nextInt();
        tree = new List[n];
        for(int i=0;i<n;i++) tree[i] = new LinkedList<>();
        for(int i=0;i<n-1;i++){
            int u = sc.nextInt()-1, v = sc.nextInt()-1;
            tree[u].add(v);tree[v].add(u);
        }
        depth = new int[n];
        father = new int[n][maxj+1];
        // father[i][0] is the 2^0-th father of i, that is, the 1-st and direct father of i
        dfs(0,0,0);
        int q = sc.nextInt();
        while(q-->0){
            int x = sc.nextInt()-1, y = sc.nextInt()-1, a = sc.nextInt()-1, b = sc.nextInt()-1, k = sc.nextInt();
            String ans = helper(x,y,a,b,k);
            out.println(ans);
        }
    }
    String helper(int x, int y, int a, int b, int k){
        int ab = dist(a,b);
        if(ab<=k&&ab%2==k%2) return "YES";
        // then try to use the x-y edge
        int axyb = dist(a,x)+dist(y,b)+1;
        if(axyb<=k&&axyb%2==k%2) return "YES";
        int ayxb = dist(a,y)+dist(x,b)+1;
        if(ayxb<=k&&ayxb%2==k%2) return "YES";
        return "NO";
    }
    int dist(int a, int b){
        int mid = get_lca(a,b);
        return depth[a]+depth[b]-2*depth[mid];
    }
    void dfs(int cur, int from, int level){
        father[cur][0] = from;
        for(int i=1;i<=maxj;i++){
            father[cur][i] = father[father[cur][i-1]][i-1];
        }
        depth[cur] = level;
        for(int to:tree[cur]){
            if(to!=from) dfs(to,cur,level+1);
        }
    }
    int get_lca(int u, int v){
        if(depth[u]<depth[v]){ // let u be the deeper one
            int mid = u; u = v; v = mid;
        }
        u = lift(u,depth[u]-depth[v]);
        // now u and v are same depth
        if(u==v) return u;
        for(int j=maxj;j>=0;j--){ // here it has to be j from big to small
            if(father[u][j]!=father[v][j]){
                u = father[u][j];
                v = father[v][j];
            }
        }
        return father[u][0];
        // at last u and v have the same father for level 1
    }
    int lift(int u, int d){
        if(d==0) return u;
        for(int i=maxj;i>=0;i--){
            if(((1<<i)&d)>0) u = father[u][i];
        }
        return u;
    }
}

