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 
class Stree:
    def __init__(self, f, n, default, init_data):
        self.ln = 2**(n-1).bit_length()
        self.data = [default] * (self.ln * 2)
        self.f = f
        for i, d in init_data.items():
            self.data[self.ln + i] = d
        for j in range(self.ln - 1, -1, -1):
            self.data[j] = f(self.data[j*2], self.data[j*2+1])

    def update(self, i, a):
        p = self.ln + i
        self.data[p] = a
        while p > 1:
            p = p // 2
            self.data[p] = self.f(self.data[p*2], self.data[p*2+1])

    def get(self, i, j):
        def _get(l, r, p):
            if i <= l and j >= r:
                return self.data[p]
            else:
                m = (l+r)//2
                if j <= m:
                    return _get(l, m, p*2)
                elif i >= m:
                    return _get(m, r, p*2+1)
                else:
                    return self.f(_get(l, m, p*2), _get(m, r, p*2+1))
        return _get(0, self.ln, 1)


def dfs(adj):
    n = len(adj)
    parent = [None] * n
    depth = [-1] * n
    depth[0] = 0
    stack = [(0, adj[0])]
    euler = []
    eulerfirst = [-1] * n

    while stack:
        p, aa = stack.pop()
        if eulerfirst[p] == -1:
            eulerfirst[p] = len(euler)
        euler.append(p)
        for c in aa[::-1]:
            if c != parent[p]:
                parent[c] = p
                depth[c] = depth[p] + 1
                stack.append((p, []))
                stack.append((c, adj[c]))
    return euler, eulerfirst, parent, depth


class Lca:
    # must form a tree
    def __init__(self, adj):
        self.adj = adj
        self.euler, self.eulerfirst, self.parent, self.depth = dfs(adj)

        def f(l, r):
            if self.depth[l] < self.depth[r]:
                return l
            else:
                return r

        self.stree = Stree(f, len(self.euler), 0, dict(enumerate(self.euler)))

    def lca(self, a, b):
        if a == b:
            return a
        fa = self.eulerfirst[a]
        fb = self.eulerfirst[b]
        if fb < fa:
            fa, fb = fb, fa
        return self.stree.get(fa, fb)

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


from sys import stdin, gettrace

if not gettrace():
    def input():
        return next(stdin)[:-1]


def main():
    n = int(input())
    adj= [[] for _ in range(n)]
    for _ in range(n-1):
        x, y = map(int, input().split())
        adj[x-1].append(y-1)
        adj[y-1].append(x-1)
    lca = Lca(adj)

    def solve():

        x, y, a, b, k = map(int, input().split())
        x -=1
        y -=1
        a -=1
        b -=1
        dab= lca.dist(a, b)
        if dab <= k and (k - dab)%2 == 0:
            print("YES")
            return
        dxa = lca.dist(x, a)
        dyb = lca.dist(y, b)
        if dxa + dyb + 1 <= k and (k - dxa - dyb -1) % 2 == 0:
            print("YES")
            return
        dya = lca.dist(y, a)
        dxb = lca.dist(x, b)
        if dya + dxb + 1 <= k and (k - dya - dxb -1) % 2 == 0:
            print("YES")
            return
        print("NO")

    q = int(input())
    for _ in range(q):
        solve()


if __name__ == "__main__":
    main()