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 {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=1;
        while(T-->0)
        {
            int n=input.nextInt();
            ArrayList<Integer> adj[]=new ArrayList[n+1];
            for(int i=1;i<=n;i++)
            {
                adj[i]=new ArrayList<>();
            }
            for(int i=0;i<n-1;i++)
            {
                int u=input.nextInt();
                int v=input.nextInt();
                adj[u].add(v);
                adj[v].add(u);
            }
            int visit[]=new int[n+1];
            int parent[][]=new int[n+1][20];
            int depth[]=new int[n+1];
            dfs(adj,1,depth,visit,parent);
            int q=input.nextInt();
            for(int i=0;i<q;i++)
            {
                int x=input.nextInt();
                int y=input.nextInt();
                int a=input.nextInt();
                int b=input.nextInt();
                int k=input.nextInt();
                int ab=dist(a,b,parent,depth);
                int ax=dist(a,x,parent,depth);
                int ay=dist(a,y,parent,depth);
                int xb=dist(x,b,parent,depth);
                int yb=dist(y,b,parent,depth);
                int xy=dist(x,y,parent,depth);
                int d1=ab;
                int d2=ax+1+yb;
                int d3=ay+1+xb;
                int d=xy+1;
//                out.println(d1+" "+d2+" "+d3+" "+d);
                if(k==d1 || (k-d1>=0 && (k-d1)%2==0))
                {
                    System.out.println("YES");
                }
                else
                {
                    if(k-d2>=0 && (k-d2)%d==0 || (k-d2>=0 && (k-d2)%2==0))
                    {
                        System.out.println("YES");
                    }
                    else if(k-d3>=0 && (k-d3)%d==0 || (k-d3>=0 && (k-d3)%2==0))
                    {
                        System.out.println("YES");
                    }
                    else
                    {
                        System.out.println("NO");
                    }
                }
            }
        }
        out.close();
    }
    public static int dist(int u,int v,int parent[][],int depth[])
    {
        int lca=lowestCommonAncestor(u,v,parent,depth);
        int d=depth[u]+depth[v]-2*depth[lca];
        return d;
    }
    public static int lowestCommonAncestor(int u,int v,int parent[][],int depth[])
    {
        if(depth[u]<depth[v])
        {
            int temp=u;
            u=v;
            v=temp;
        }
        int k=depth[u]-depth[v];
        u=kthAncestor(u,k,parent);
        if(u==v)
        {
            return u;
        }
        int log=19;
        for(int i=log;i>=0;i--)
        {
            if(parent[u][i]!=parent[v][i])
            {
                u=parent[u][i];
                v=parent[v][i];
            }
        }
        return parent[u][0];
    }
    public static int kthAncestor(int u,int k,int parent[][])
    {
        while(k>0)
        {
            int q=(int)(Math.log(k)/Math.log(2));
            u=parent[u][q];
            q=(int)Math.pow(2,q);
            k-=q;
        }
        if(u==0) u=-1;
        return u;
    }
    public static void dfs(ArrayList<Integer> adj[],int u,int depth[],int visit[],int parent[][])
    {
        visit[u]=1;
        for(int i=0;i<adj[u].size();i++)
        {
            int v=adj[u].get(i);
            if(visit[v]==0)
            {
                depth[v]=depth[u]+1;
                parent[v][0]=u;
                int j=1;
                while(1<<j<=depth[v])
                {
                    parent[v][j]=parent[parent[v][j-1]][j-1];
                    j++;
                }
                dfs(adj,v,depth,visit,parent);
            }
        }
    }
    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;
        }
    }
}