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

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;

/**
 * @author sguar <shugangcao@gmail.com>
 * welcome to kuaishou
 * Created on 2020-02-17
 */
public class E {
    ArrayList<Integer>[] path;
    int[][] familyTree;
    int[] deep;

    void build(int son, int fa) {
        deep[son] = deep[fa] + 1;
        familyTree[son][0] = fa;
        for (int i = 1; i < 20; i++) {
            familyTree[son][i] = familyTree[familyTree[son][i - 1]][i - 1];
        }

        for (int next : path[son]) {
            if (next != fa) {
                build(next, son);
            }
        }
    }

    int lca(int v, int u) {
        for (int k = 19; k >= 0; k--) {
            if (deep[v] - (1 << k) >= deep[u]) v = familyTree[v][k];
            if (deep[u] - (1 << k) >= deep[v]) u = familyTree[u][k];
        }

        for (int k = 19; k >= 0; k--) {
            if (familyTree[v][k] != familyTree[u][k]) {
                v = familyTree[v][k];
                u = familyTree[u][k];
            }
        }
        if (v == u) return v;
        return familyTree[v][0];
    }

    int dist(int v, int u) {
        int lca = lca(v, u);
        return deep[v] + deep[u] - 2 * deep[lca];
    }

    public static void main(String[] args) {
        new E().run();
    }

    Scanner cin = new Scanner(System.in);
    PrintWriter out = new PrintWriter(System.out);

    private void run() {
        int n = cin.nextInt();

        path = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) path[i] = new ArrayList<>();
        deep = new int[n + 1];
        familyTree = new int[n + 1][20];

        for (int i = 1; i <= n - 1; i++) {
            int w = cin.nextInt();
            int v = cin.nextInt();
            path[w].add(v);
            path[v].add(w);
        }

        deep[1] = -1;
        build(1, 1);

        int q = cin.nextInt();
        for (int i = 1; i <= q; i++) {
            int x = cin.nextInt();
            int y = cin.nextInt();
            int a = cin.nextInt();
            int b = cin.nextInt();
            int k = cin.nextInt();

            int lenAB = dist(a, b);
            if (k >= lenAB && (k - lenAB) % 2 == 0) {
                out.println("YES");
                continue;
            }
            int lenAX = dist(a, x);
            int lenXB = dist(x, b);
            int lenAY = dist(a, y);
            int lenYB = dist(y, b);

            if ((k - lenAX - lenYB >= 1 && (k - lenAX - lenYB - 1) % 2 == 0)) {
                out.println("YES");
                continue;
            }

            if ((k - lenAY - lenXB >= 1 &&  (k - lenAY - lenXB - 1) % 2 == 0)) {
                out.println("YES");
                continue;
            }

            out.println("NO");
        }
        out.close();
    }
}
