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.util.ArrayList;
import java.util.Scanner;

public class onetreequery {
	static int[][] jump;
	static ArrayList<Integer>[] a;
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		int n=scan.nextInt();
		a=new ArrayList[n];
		for(int i=0;i<n;i++) a[i]=new ArrayList<>();

		for(int i=0;i<n-1;i++) {
			int u=scan.nextInt()-1, v=scan.nextInt()-1;
			a[u].add(v);
			a[v].add(u);
		}
		depth=new int[n];
		jump=new int[n][20];//might as well jump

		init(0,-1,0);

		for(int j=1;j<20;j++) {
			for(int i=0;i<n;i++) {
				if(jump[i][j-1]==-1) jump[i][j]=-1;
				else jump[i][j]=jump[jump[i][j-1]][j-1];
			}
		}

		int q=scan.nextInt();

		for(int i=0;i<q;i++) {
			boolean good=false;
			int addu=scan.nextInt()-1, addv=scan.nextInt()-1;
			int pathu=scan.nextInt()-1, pathv=scan.nextInt()-1;
			int length=scan.nextInt();

			//check path without adding the edge

			long path1=dist(pathu,pathv);
			if(path1<=length&&path1%2==length%2) {
				good=true;
			}

			//check path from pathu to addu to addv to pathv

			long path2=dist(pathu,addu)+1+dist(addv,pathv);
			if(path2<=length&&path2%2==length%2) {
				good=true;
			}

			//check path from pathu to addv to addu to path v

			long path3=dist(pathu,addv)+1+dist(addu,pathv);
			if(path3<=length&&path3%2==length%2) {
				good=true;
			}

			//			System.out.println(path1+" "+path2+" "+path3);
			if(good) System.out.println("YES");
			else System.out.println("NO");
		}
	}
	public static long dist(int a, int b) {
		return depth[a]+depth[b]-2*depth[lca(a,b)];
	}
	public static int lca(int a, int b) {
		if(depth[a]>depth[b]) a=walk(a,depth[a]-depth[b]);
		if(depth[b]>depth[a]) b=walk(b,depth[b]-depth[a]);

		if(a==b) return a;
		if(jump[a][0]==-1) return a;

		for(int i=19;i>=0;i--) {
			if(jump[a][i]!=jump[b][i]) {
				a=jump[a][i];
				b=jump[b][i];
			}
		}
		return jump[a][0];
	}
	public static int walk(int at, int k) {
		for(int i=19;i>=0;i--) {
			if(k>=(1<<i)) {
				k-=(1<<i);
				at=jump[at][i];
				if(at==-1) return -1;
			}
		}
		return at;
	}

	static int[] depth;

	public static void init(int at, int prev, int d) {
		depth[at]=d;
		jump[at][0]=prev;

		for(int nxt:a[at]) {
			if(nxt!=prev) {
				init(nxt,at,d+1);
			}
		}
	}
}