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.math.BigInteger;
import java.util.*;


public class Rough{
	public static class FastReader {
		BufferedReader br;
		StringTokenizer root;
		
 
		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}
 
		String next() {
			while (root == null || !root.hasMoreTokens()) {
				try {
					root = new StringTokenizer(br.readLine());
				} catch (Exception r) {
					r.printStackTrace();
				}
			}
			return root.nextToken();
		}
 
		int nextInt() {
			return Integer.parseInt(next());
		}
 
		double nextDouble() {
			return Double.parseDouble(next());
		}
 
		long nextLong() {
			return Long.parseLong(next());
		}
 
		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (Exception r) {
				r.printStackTrace();
			}
			return str;
		}
	}
	
	public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
	static int mod = (int) (1e9+7);
	static long cf = 998244353;
    static final int MAX = (int) (1e6+1);
    public static long[] Bit;
    public static List<Integer>[] edges;
	public static int[][] parent;
	public static int col = 20;
	public static FastReader sc = new FastReader();
	public static void main(String[] args) {
		int n = sc.nextInt();
		parent = new int[n+1][col];
		edges = new ArrayList[n+1];
		for(int i=0;i<=n;++i) {
			edges[i] = new ArrayList<>();
			Arrays.fill(parent[i],-1);
		}
		for(int i=1;i<n;++i) {
			int u = sc.nextInt();
			int v = sc.nextInt();
			edges[u].add(v);
			edges[v].add(u);
		}
		int[] level = new int[n+1];
		dfs(1,0,level);
		for(int j=1;j<col;++j) {
			for(int i=1;i<=n;++i) {
				if(parent[i][j-1] != -1)
				parent[i][j] = parent[parent[i][j-1]][j-1];
			}
		}
		
		int q = sc.nextInt();
		while(q-->0) {
			int x = sc.nextInt();
			int y = sc.nextInt();
			int a = sc.nextInt();
			int b = sc.nextInt();
			int k = sc.nextInt();
			int dis = dis(a,b,level);
			int len = Math.min(dis(a,x,level)+dis(y,b,level), dis(a,y,level)+dis(x,b,level))+1;
			int ans = Integer.MAX_VALUE;
			if(dis%2 == k%2) ans = dis;
			if(len%2 == k%2) ans = Math.min(ans, len);
			if(ans <= k) out.println("YES");
			else out.println("NO");
			
		}
		
		
		out.close();

	}
	private static int dis(int x, int y, int[] level) {
		return level[x] + level[y] - 2*level[LCA(x,y,level)];
	}
	private static int LCA(int u, int v, int[] level) {
		if(level[u] < level[v]) {
			u = u^v;
			v = u^v;
			u = u^v;
		}
		// now v is above u
		int diff = level[u] - level[v]; //  MOVING TO THE SAME LEVEL
		for(int i=0;i<col;++i) {
			if(((diff>>i)&1) == 1) {
				u = parent[u][i]; // move to its 2ei parent above
			}
		}
		
		if(u == v) return u; // case when one of them is LCA itself
		
		for(int i=col-1;i>=0;--i) {
			// move upward till their parent are not equal
			if(parent[u][i] != parent[v][i]) {
				u = parent[u][i];
				v = parent[v][i];
			}
		}
		// finally you reach the point where your direct parent is LCA
		return parent[u][0];
	}
	private static void dfs(int v, int par, int[] level) {
		level[v]=level[par]+1;
		 parent[v][0] = par;
		 for(int child : edges[v]) {
			 if(child != par) {
				 dfs(child,v,level);
			 }
		 }
		
	}
	
}