import java.io.*;
import java.math.BigInteger;
import java.util.*;


public class Rough{
	public static class FastReader {
		BufferedReader br;
		StringTokenizer root;
		
 
		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}
 
		String next() {
			while (root == null || !root.hasMoreTokens()) {
				try {
					root = new StringTokenizer(br.readLine());
				} catch (Exception r) {
					r.printStackTrace();
				}
			}
			return root.nextToken();
		}
 
		int nextInt() {
			return Integer.parseInt(next());
		}
 
		double nextDouble() {
			return Double.parseDouble(next());
		}
 
		long nextLong() {
			return Long.parseLong(next());
		}
 
		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (Exception r) {
				r.printStackTrace();
			}
			return str;
		}
	}
	
	public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
	static int mod = (int) (1e9+7);
	static long cf = 998244353;
    static final int MAX = (int) (1e6+1);
    public static long[] Bit;
    public static List<Integer>[] edges;
	public static int[][] parent;
	public static int col = 20;
	public static FastReader sc = new FastReader();
	public static void main(String[] args) {
		int n = sc.nextInt();
		parent = new int[n+1][col];
		edges = new ArrayList[n+1];
		for(int i=0;i<=n;++i) {
			edges[i] = new ArrayList<>();
			Arrays.fill(parent[i],-1);
		}
		for(int i=1;i<n;++i) {
			int u = sc.nextInt();
			int v = sc.nextInt();
			edges[u].add(v);
			edges[v].add(u);
		}
		int[] level = new int[n+1];
		dfs(1,0,level);
		for(int j=1;j<col;++j) {
			for(int i=1;i<=n;++i) {
				if(parent[i][j-1] != -1)
				parent[i][j] = parent[parent[i][j-1]][j-1];
			}
		}
		
		int q = sc.nextInt();
		while(q-->0) {
			int x = sc.nextInt();
			int y = sc.nextInt();
			int a = sc.nextInt();
			int b = sc.nextInt();
			int k = sc.nextInt();
			int dis = dis(a,b,level);
			int len = Math.min(dis(a,x,level)+dis(y,b,level), dis(a,y,level)+dis(x,b,level))+1;
			int ans = Integer.MAX_VALUE;
			if(dis%2 == k%2) ans = dis;
			if(len%2 == k%2) ans = Math.min(ans, len);
			if(ans <= k) out.println("YES");
			else out.println("NO");
			
		}
		
		
		out.close();

	}
	private static int dis(int x, int y, int[] level) {
		return level[x] + level[y] - 2*level[LCA(x,y,level)];
	}
	private static int LCA(int u, int v, int[] level) {
		if(level[u] < level[v]) {
			u = u^v;
			v = u^v;
			u = u^v;
		}
		// now v is above u
		int diff = level[u] - level[v]; //  MOVING TO THE SAME LEVEL
		for(int i=0;i<col;++i) {
			if(((diff>>i)&1) == 1) {
				u = parent[u][i]; // move to its 2ei parent above
			}
		}
		
		if(u == v) return u; // case when one of them is LCA itself
		
		for(int i=col-1;i>=0;--i) {
			// move upward till their parent are not equal
			if(parent[u][i] != parent[v][i]) {
				u = parent[u][i];
				v = parent[v][i];
			}
		}
		// finally you reach the point where your direct parent is LCA
		return parent[u][0];
	}
	private static void dfs(int v, int par, int[] level) {
		level[v]=level[par]+1;
		 parent[v][0] = par;
		 for(int child : edges[v]) {
			 if(child != par) {
				 dfs(child,v,level);
			 }
		 }
		
	}
	
}