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 
from sys import stdin, stdout

LEVEL_COUNT = 20


def get_preprocessed_input():
    n = int(stdin.readline())
    g = [[] for _ in range(n)]
    for _ in range(n - 1):
        u, v = map(int, stdin.readline().split())
        u -= 1
        v -= 1
        g[u].append(v)
        g[v].append(u)
    d = [0] * n
    dp = [[0] * n for _ in range(LEVEL_COUNT)]
    p = dp[0]
    stack = [0]
    while stack:
        u = stack.pop()
        d[u] = d[p[u]] + 1
        for v in g[u]:
            if v != p[u]:
                p[v] = u
                stack.append(v)
    for level in range(1, LEVEL_COUNT):
        for i in range(n):
            dp[level][i] = dp[level - 1][dp[level - 1][i]]
    return d, dp


def lca(d, dp, a, b):
    if d[a] < d[b]:
        a, b = b, a
    for dp1 in reversed(dp):
        a1 = dp1[a]
        if d[a1] >= d[b]:
            a = a1
    if a == b:
        return a
    for dp1 in reversed(dp):
        a1 = dp1[a]
        b1 = dp1[b]
        if a1 != b1:
            a = a1
            b = b1
    # assert dp[0][a] == dp[0][b]
    return dp[0][a]


def path_len(d, dp, a, b):
    return d[a] + d[b] - 2 * d[lca(d, dp, a, b)]


def main():
    d, dp = get_preprocessed_input()
    for _ in range(int(stdin.readline())):
        x, y, a, b, k = map(int, stdin.readline().split())
        x -= 1
        y -= 1
        a -= 1
        b -= 1
        path1 = path_len(d, dp, a, b)
        path2 = min(path_len(d, dp, a, x) + path_len(d, dp, y, b),
                    path_len(d, dp, a, y) + path_len(d, dp, x, b)) + 1
        if k >= path1 and k % 2 == path1 % 2 or\
           k >= path2 and k % 2 == path2 % 2:
            print("YES")
        else:
            print("NO")


main()
