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 
//package com.kraken.cf.cf620;
/*
 * created by Kraken at 6:37 PM
 */

import java.io.*;
import java.util.*;

public class E {
	static int[] height, first, segTree;
	static boolean[] visited;
	static ArrayList<Integer> euler = new ArrayList<>();

	public static void main(String[] args) {
		FastReader sc = new FastReader();
		int n = sc.nextInt();

		height = new int[n];
		first = new int[n];
		visited = new boolean[n];
		for (int i = 0; i < n; i++) visited[i] = false;

		ArrayList<ArrayList<Integer>> tree = new ArrayList<>();
		for (int i = 0; i < n; i++) tree.add(new ArrayList<>());

		for (int i = 0; i < n - 1; i++) {
			int a = sc.nextInt() - 1;
			int b = sc.nextInt() - 1;
			tree.get(a).add(b);
			tree.get(b).add(a);
		}

		dfs(tree, 0, 0);
		int m = euler.size();
		segTree = new int[m * 4];
		build(1, 0, m - 1);

		StringBuilder sb = new StringBuilder();
		int q = sc.nextInt();
		for (int i = 0; i < q; i++) {
			int x = sc.nextInt() - 1, y = sc.nextInt() - 1, a = sc.nextInt() - 1, b = sc.nextInt() - 1, k = sc.nextInt();
			int ab = dist(a, b), ax = dist(a, x), ay = dist(a, y), bx = dist(b, x), by = dist(b, y);
			if (k >= ab && (ab & 1) == (k & 1))
				sb.append("YES").append("\n");
			else if (k >= (ax + by + 1) && ((ax + by + 1) & 1) == (k & 1))
				sb.append("YES").append("\n");
			else if (k >= (ay + bx + 1) && ((ay + bx + 1) & 1) == (k & 1))
				sb.append("YES").append("\n");
			else
				sb.append("NO").append("\n");
		}
		System.out.println(sb.toString());
	}

	private static int dist(int a, int b) {
//		System.out.printf("finding distance between: %d, %d\n", a, b);
		int ca = lca(a, b);
		return (height[a] - height[ca]) + (height[b] - height[ca]);
	}

	private static int lca(int a, int b) {
		int left = first[a], right = first[b];
		if (left > right) {
			int temp = right;
			right = left;
			left = temp;
		}
//		System.out.printf("finding lca in range[%d, %d]\n", left, right);
		return query(1, left, right, 0, euler.size() - 1);
	}

	private static int query(int node, int left, int right, int nLeft, int nRight) {
//		System.out.printf("query received for range: [%d, %d] in range of size: [%d, %d]\n", left, right, nLeft, nRight);
		if (left > right) return -1;
		if (left == nLeft && right == nRight) return segTree[node];
		int mid = (nLeft + nRight) >> 1;
		int l = query(node * 2, left, Math.min(mid, right), nLeft, mid);
		int r = query(node * 2 + 1, Math.max(mid + 1, left), right, mid + 1, nRight);
		if (l == -1) return r;
		if (r == -1) return l;
		if (height[l] < height[r]) return l; else return r;
	}

	private static void build(int node, int left, int right) {
//		System.out.printf("node: %d, left: %d, right: %d, val: %d\n", node, left, right, segTree[node]);
		if (left == right) {
			segTree[node] = euler.get(left);
		} else {
			int mid = (left + right) >> 1;
			build((node * 2), left, mid);
			build((node * 2) + 1, mid + 1, right);
			int l = segTree[(node * 2)], r = segTree[(node * 2) + 1];
			if (height[l] < height[r]) segTree[node] = l; else segTree[node] = r;
		}
//		System.out.printf("node: %d, left: %d, right: %d, val: %d\n", node, left, right, segTree[node]);
	}

	private static void dfs(ArrayList<ArrayList<Integer>> tree, int node, int h) {
		visited[node] = true;
		height[node] = h;
		first[node] = euler.size();
		euler.add(node);
//		System.out.printf("added to euler: %d\n", node);
		for (int i : tree.get(node)) {
			if (!visited[i]) {
				dfs(tree, i, h + 1);
				euler.add(node);
//				System.out.printf("added to euler: %d\n", i);
			}
		}
	}

	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;
		}
	}
}
