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 sys
x = 150000
sys.setrecursionlimit(x)

def go():
    n = int(input())
    e = {i: set() for i in range(n)}
    for i in range(n - 1):
        a, b = map(lambda s: int(s) - 1, input().split())
        e[a].add(b)
        e[b].add(a)

    parent = [-1 for v in range(n)]
    lev = [-1 for v in range(n)]

    # def dfs(v, level, par):
    #     lev[v] = level
    #     parent[v] = par
    #     for u in e[v]:
    #         if parent[u] == -1:
    #             dfs(u, level + 1, v)
    stack = [0]
    lev[0]=0
    parent[0]=0
    while stack:
        v = stack.pop()
        for u in e[v]:
            if parent[u] == -1:
                lev[u] = lev[v]+1
                parent[u] = v
                stack.append(u)
    # dfs(0, 0, 0)



    levmx = max(lev)
    bindep = levmx.bit_length()
    P = [[-1] * bindep for _ in range(n)]

    for i in range(n):
        P[i][0] = parent[i]

    for j in range(1, bindep):
        for i in range(n):
            if P[i][j - 1] != -1:
                P[i][j] = P[P[i][j - 1]][j - 1]


    def lca(u, v):
        if lev[u] < lev[v]:
            u, v = v, u

        dist = lev[u] - lev[v]
        while dist:
            podn = dist.bit_length() - 1
            u = P[u][podn]
            dist -= (1 << podn)

        if u == v:
            return u

        j = bindep - 1
        while j >= 0:
            if (P[u][j] != -1) and (P[u][j] != P[v][j]):
                u = P[u][j]
                v = P[v][j]
            j -= 1

        return parent[u]


    def dist(a, b):
        return lev[a] + lev[b] - 2 * lev[lca(a, b)]

    ans=[]
    Q = int(input())
    for _ in range(Q):
        x, y, a, b, k = map(int, input().split())
        x, y, a, b = map(lambda aa: aa - 1, [x, y, a, b])
        dab = dist(a, b)
        if dab <= k and (dab - k) % 2 == 0:
            ans.append('YES')
        else:
            # dxy = dist(x, y)
            dax = dist(a, x)
            dby = dist(b, y)
            if dax + 1 + dby <= k and \
                    (k- (dax + 1 + dby))%2==0:
                ans.append ('YES')
            else:
                day = dist(a, y)
                dbx = dist(b, x)
                if dbx + 1 + day <= k and \
                    (k- (dbx + 1 + day))%2==0:
                    ans.append ('YES')
                else:
                    ans.append('NO')
    print('\n'.join(ans))
go()