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

/**
 * A simple template for competitive programming problems.
 */
public class Solution {
    //final InputReader in = new InputReader("input.txt");
    final InputReader in = new InputReader(System.in);

    final PrintWriter out = new PrintWriter(System.out);

    final int mod = 1000000007;
    final int MAX = 1000001;

    void solve() {
        int n = in.nextInt();
        Node[] nodes = new Node[n+1];

        for(int i=0; i<=n; i++) {
            nodes[i] = new Node();
        }

        for(int i=0; i<n-1; i++) {
            int u = in.nextInt(); int v = in.nextInt();
            nodes[u].ns.add(v);
            nodes[v].ns.add(u);
        }

        LCA lca = new LCA(nodes);

        int q = in.nextInt();
        while(q-->0) {
            int x = in.nextInt(); int y = in.nextInt();
            int a = in.nextInt(); int b = in.nextInt();
            int k = in.nextInt();

            int normalDist = lca.dist(a, b);
            int newPath1 = lca.dist(a, x) + lca.dist(y, b) + 1;
            int newPath2 = lca.dist(a, y) + lca.dist(x, b) + 1;

            if(xd(normalDist, k) || xd(newPath1, k) || xd(newPath2,k)) {
                out.println("YES");
            } else {
                out.println("NO");
            }
        }
    }

    boolean xd(int a, int b) {
        return a<=b && (b-a)%2==0;
    }

    class LCA {
        int[] euler;
        int[] levels;
        int[] levelEuler;
        int[] rev;
        int n;
        SparseTable rmq;

        LCA(Node[] nodes) {
            n = nodes.length;
            euler = new int[2*n-1];
            levels = new int[n];
            levelEuler = new int[2*n-1];
            rev = new int[n];
            findLevels(nodes, 1, -1);
            eulerTour(nodes, 1, 0, -1);

            for(int i=0; i<euler.length; i++) {
                levelEuler[i] = levels[euler[i]];
                rev[euler[i]] = i;
            }

            rmq = new SparseTable(levelEuler);
        }

        private void findLevels(Node[] nodes, int i, int p) {
            for(int ch : nodes[i].ns) {
                if (ch == p) continue;
                levels[ch] = levels[i] + 1;
                findLevels(nodes, ch, i);
            }
        }

        private int eulerTour(Node[] nodes, int nodeIndex, int arrIndex, int p) {
            euler[arrIndex++] = nodeIndex;
            for(int ch : nodes[nodeIndex].ns) {
                if (ch == p) continue;
                arrIndex = eulerTour(nodes, ch, arrIndex, nodeIndex);
                euler[arrIndex++] = nodeIndex;
            }
            return arrIndex;
        }

        int dist (int u, int v) {
            int s = Math.min(rev[u], rev[v]);
            int e = Math.max(rev[u], rev[v]);    
            int levelOfLca = rmq.query(s, e);
            return levels[u] + levels[v] - levelOfLca - levelOfLca;
        }

        // WRONG. Don't use it xd
        int lca (int u, int v) {
            int s = Math.min(rev[u], rev[v]);
            int e = Math.max(rev[u], rev[v]);
            return euler[rmq.query(s, e)];
        }
    }

    class SparseTable {
		int[][] M;
		int n;
		int k;
		SparseTable(int[] a) {
			n = a.length;
			k = 32- Integer.numberOfLeadingZeros(n);
			M = new int[k][n];
			for(int i=0; i<n; i++) {
				M[0][i] = a[i];
			}
			
			for(int j=1; j<k; j++) {
				for(int i=0; i+(1<<j)-1<n; i++) {
					M[j][i] = op(M[j-1][i], M[j-1][i+(1<<(j-1))]);
				}
			}
		}
		
		int query(int s, int e) {
			int log = 31 - Integer.numberOfLeadingZeros(e-s+1);
			return op(M[log][s], M[log][e-(1<<log)+1]);
		}
		
		int op(int x, int y) {
			return Math.min(x, y);
		}
	}

    class Node {
        List<Integer> ns = new ArrayList<>();
    }

    void printArray(int[] arr) {
        for(int k : arr) {
            out.print(k + " ");
        }
        out.println();
    }

    public static void main(String[] args) throws FileNotFoundException { Solution s = new Solution(); s.solve(); s.out.close(); }

    public Solution() throws FileNotFoundException { }

    private static class InputReader {
        private final InputStream stream;
        private final byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        InputReader(InputStream stream) {
            this.stream = stream;
        }

        InputReader(String fileName) {
            InputStream stream = null;
            try {
                stream = new FileInputStream(fileName);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            this.stream = stream;
        }

        int[] nextArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++)
                arr[i] = nextInt();
            return arr;
        }

        int[][] nextMatrix(int n, int m) {
            int[][] matrix = new int[n][m];
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    matrix[i][j] = nextInt();
            return matrix;
        }

        String nextLine() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndOfLine(c));
            return res.toString();
        }

        String nextString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9') throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        int nextInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        double nextDouble() {
            return Double.parseDouble(nextString());
        }

        private int read() {
            if (numChars == -1) throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try { numChars = stream.read(buf); }
                catch (IOException e) { throw new InputMismatchException(); }
                if (numChars <= 0) return -1;
            }
            return buf[curChar++];
        }

        private boolean isSpaceChar(int c) { return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1; }

        private boolean isEndOfLine(int c) { return c == '\n' || c == '\r' || c == -1; }
    }


}