import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class E_Trees_and_Queries {
 
	static int[][] dp;
	static int[] parents;
	static int[] levels;
	static ArrayList<ArrayList<Integer>> adjList;
	
	public static void main(String[] args) {
		MyScanner sc = new MyScanner();
	    PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
	    int N = sc.nextInt();
	    
	    //Build adj list
	    adjList = new ArrayList<>();
	    for(int i = 0; i < N; i++) {
	    	adjList.add(new ArrayList<Integer>());
	    }
	    for(int i = 0; i < N - 1; i++) {
	    	int a = sc.nextInt() - 1;
	    	int b = sc.nextInt() - 1;
	    	
	    	adjList.get(a).add(b);
	    	adjList.get(b).add(a);
	    }
	    
	    //Build Tree (Node, Parent) and levels array
	    parents = new int[N];  
	    levels = new int[N];
	    populateTree(0, 0);
	    
	    //Build an O(nlogn) dp table - pick node 0 as arbitary root
	    dp = new int[N][(int) Math.ceil(Math.log(N)/Math.log(2)) + 1];
	    populateDP(0, 0);

	    //Compute queries (subtract 1 from each node)
	    int queryCount = sc.nextInt();
	    while(queryCount-- > 0) {
	    	//Add edge from X to Y
	    	int X = sc.nextInt() - 1;
	    	int Y = sc.nextInt() - 1;
	    	//Check distance between A and B
	    	int A = sc.nextInt() - 1;
	    	int B = sc.nextInt() - 1;
	    	//Distance to travel
	    	int K = sc.nextInt();
	    		    	
	    	boolean success = false;
	    	//If path is <= K and has the same parity
	    	if(dist(A, B)%2 == K%2 && dist(A, B) <= K) {
	    		success = true;
	    	}else if((dist(A, X) + 1 + dist(Y, B))%2 == K%2 
	    			&& dist(A, X) + 1 + dist(Y, B) <= K) {
	    		success = true;
	    	}else if((dist(A, Y) + 1 + dist(X, B))%2 == K%2 
	    			&& dist(A, Y) + 1 + dist(X, B) <= K) {
	    		success = true;
	    	}
	    	
	    	if(success)
	    		out.println("YES");
	    	else
	    		out.println("NO");
	    }
	    
	    out.close();
	}
	
	public static int dist(int a, int b) {
		return Math.abs(2*levels[LCA(a, b)] - levels[a] - levels[b]);
	}
	
	public static int LCA(int u, int v) {		
		//Find ancestor of u at same level of v
		if(levels[v] != levels[u]) {
			if(levels[v] > levels[u]) {
				int temp = u;
				u = v;
				v = temp;
			}
			
			int k = (int) Math.ceil(Math.log(levels[u])/Math.log(2));
			while(k >= 0) {	
				//if it's still lower
				//assert k <= dp[u].length
				if(levels[dp[u][k]] >= levels[v])
					u = dp[u][k];
			
				k--;
			}
		}
		
		if(u == v) return u;
		
		//u and v are at same level - employ meta binary search to find their lca
		int k = (int) Math.ceil(Math.log(levels[u])/Math.log(2));
		while(k >= 0) {
			if(dp[u][k] == dp[v][k])
				k--;
			else {
				u = dp[u][k];
				v = dp[v][k];
			}
		}
		
		return parents[u];
	}
	
	
	public static void populateDP(int curr, int parent) {
		//Populate dp row
		dp[curr][0] = parent;
		for(int k = 1; k < dp[curr].length; k++) {
			if(Math.pow(2, k) <= levels[curr])
				dp[curr][k] = dp[dp[curr][k - 1]][k - 1];
			else
				dp[curr][k] = 0;
		}

		//Populate children
		for(int i = 0; i < adjList.get(curr).size(); i++) {
			int child = adjList.get(curr).get(i);
			if(child == parent) continue;
			
			populateDP(child, curr);
		}
	}
	
	public static void populateTree(int curr, int parent) {
		for(int i = 0; i < adjList.get(curr).size(); i++) {
			int child = adjList.get(curr).get(i);
			if(child != parent) {
				parents[child] = curr;
				levels[child] = levels[curr] + 1;
				populateTree(child, curr);
			}
		}
	}
	
	public static class MyScanner {
		BufferedReader br;
	    StringTokenizer st;
	 
	    public MyScanner() {
	       br = new BufferedReader(new InputStreamReader(System.in));
	    }
	 
	    String next() {
	    	while (st == null || !st.hasMoreElements()) {
	    		try {
	    			st = new StringTokenizer(br.readLine());
	            	
	    		} catch (IOException e) {
	    			e.printStackTrace();
	            }
	          }
	    	return st.nextToken();
	   }
	 
	   int nextInt() {
		   return Integer.parseInt(next());
	   }
	 
	   long nextLong() {
		   return Long.parseLong(next());
	   }
	 
	   double nextDouble() {
		   return Double.parseDouble(next());
	   }
	 
	   String nextLine(){
		   String str = "";
		   try {
			   str = br.readLine();
		   } catch (IOException e) {
			   e.printStackTrace();
		   }
		   return str;
	   }
	}
}