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.*;
import java.text.*;
public final class isc
{
    static class FastReader 
    { 

        BufferedReader br; 
        StringTokenizer st; 

        public FastReader()
        { 
            br = new BufferedReader(new InputStreamReader(System.in)); 
        } 


        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 

        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 

        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 

        double nextDouble() 
        { 
            return Double.parseDouble(next()); 
        } 

        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    }
    static int n, d;
    static ArrayList<Integer>[] adj;
    static int depth[];
    static int par[][];
    static int walk(int i, int up)
    {
        for(int k=0; k<=d && k!=-1; k++)
        {
            if(((1<<k)&up)>0)
                i = par[k][i];
        }
        return i;
    }
    static int lca(int i, int j)
    {
        if(depth[i]>depth[j])
            i = walk(i, depth[i]-depth[j]);
        if(depth[j]>depth[i])
            j = walk(j, depth[j]-depth[i]);
        if(i==j)
            return i;
        for(int k=d; k>=0; k--)
        {
            if(par[k][i]!=par[k][j])
            {
                i = par[k][i];
                j = par[k][j];
            }
        }
        return par[0][i];
    }
    static int dist(int u, int v)
    {
        int a = lca(u,v);
        return depth[u]+depth[v] - (2*depth[a]);
    }
    public static void main(String[] args)
    {
        FastReader sc = new FastReader();
        int n = sc.nextInt();
        adj = new ArrayList[n];
        for(int i=0; i<n; i++)
            adj[i] = new ArrayList<Integer>();
        for(int i=0; i<n-1; i++)
        {
            int u = sc.nextInt()-1;
            int v = sc.nextInt()-1;
            adj[u].add(v);
            adj[v].add(u);
        }
        // floor of log2
        d = Integer.numberOfTrailingZeros(Integer.highestOneBit(n));
        par = new int[d+1][n];
        depth = new int[n];
        for(int []dd:par)
            Arrays.fill(dd,-1);
        Queue<Integer> q = new LinkedList<Integer>();
        boolean visited[] = new boolean[n];
        q.add(0);
        visited[0] = true;
        while(!q.isEmpty())
        {
            int i = q.remove();
            for(int j:adj[i])
            {
                if(!visited[j])
                {
                    visited[j] = true;
                    q.add(j);
                    par[0][j] = i;
                    depth[j] = depth[i]+1;
                }
            }
        }
        for(int k=1; k<=d; k++)
        {
            for(int i=0; i<n; i++)
            {
                int mid = par[k-1][i];
                if(mid != -1)
                    par[k][i] = par[k-1][mid];
            }
        }
        // for(int j=0; j<n; j++)
        // {
        //     for(int i=0; i<=d; i++)
        //         System.out.print(par[i][j]+" ");
        //     System.out.println();
        // }
        int query = sc.nextInt();
        for(int i=0; i<query; i++)
        {
            int x = sc.nextInt()-1;
            int y = sc.nextInt()-1;
            int a = sc.nextInt()-1;
            int b = sc.nextInt()-1;
            int k = sc.nextInt();
            int ans1, ans2, ans3;
            ans1 = dist(a,b);
            ans2 = dist(a,x)+1+dist(y,b);
            ans3 = dist(a,y)+1+dist(x,b);
            // System.out.println(ans1+" "+ans2+" "+ans3);
            if(ans1%2==k%2 && ans1<=k)
                System.out.println("YES");
            else if(ans2%2==k%2 && ans2<=k)
                System.out.println("YES");
            else if(ans3%2==k%2 && ans3<=k)
                System.out.println("YES");
            else
                System.out.println("NO");
        }
    }
}