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 
#include <bits/stdc++.h>
using namespace std;
vector<int> g;
class segment_tree_max {
 private:
  vector<int> m;
  vector<int> delta;
  int n;
  bool is_bulk;
  int get_val(int i) {
    if (!is_bulk) {
      return m[i];
    }
    int ans = m[i] + delta[i];
    i /= 2;
    while (i >= 1) {
      ans += delta[i];
      i /= 2;
    }
    return ans;
  }
  void inc(int i, int val) {
    delta[i] += val;
    i /= 2;
    while (i >= 1) {
      m[i] = max(m[2 * i] + delta[2 * i], m[2 * i + 1] + delta[2 * i + 1]);
      i /= 2;
    }
  }

 public:
  segment_tree_max() {}
  segment_tree_max(int nn, int def, bool bulk = false) {
    is_bulk = bulk;
    n = 1;
    while (n < nn) {
      n *= 2;
    }
    m.assign(2 * n, def);
    if (is_bulk) {
      delta.assign(2 * n, 0);
    }
  }
  segment_tree_max(const vector<int>& d, int def = 0, bool bulk = false,
                   int mult = 1) {
    is_bulk = bulk;
    n = 1;
    while (n < d.size()) {
      n *= 2;
    }
    m.assign(2 * n, def);
    if (is_bulk) {
      delta.assign(2 * n, 0);
    }
    for (int i = 0; i < d.size(); i++) {
      m[i + n] = d[i] * mult;
    }
    for (int i = n - 1; i >= 1; i--) {
      m[i] = max(m[2 * i], m[2 * i + 1]);
    }
  }
  int get_max(int l, int r) {
    if (l > r) {
      swap(l, r);
    }
    l += n;
    r += n;
    int ans = -1e9;
    while (l <= r) {
      if (l % 2 == 1) {
        ans = max(ans, get_val(l));
        l++;
      }
      if (r % 2 == 0) {
        ans = max(ans, get_val(r));
        r--;
      }
      l /= 2;
      r /= 2;
    }
    return ans;
  }
  void inc_bulk(int l, int r, int val) {
    if (!is_bulk) {
      cout << "cant inc_bulk in not bulk mode" << endl;
      exit(1);
    }
    if (l > r) {
      swap(l, r);
    }
    l += n;
    r += n;
    while (l <= r) {
      if (l % 2 == 1) {
        inc(l, val);
        l++;
      }
      if (r % 2 == 0) {
        inc(r, val);
        r--;
      }
      l /= 2;
      r /= 2;
    }
  }
  void update(int i, int val) {
    i += n;
    m[i] = val;
    i /= 2;
    while (i >= 1) {
      if (is_bulk) {
        m[i] = max(m[2 * i] + delta[2 * i], m[2 * i + 1] + delta[2 * i + 1]);
      } else {
        m[i] = max(m[2 * i], m[2 * i + 1]);
      }
      i /= 2;
    }
  }
};
class segment_tree_min {
 private:
  segment_tree_max max_tree;

 public:
  segment_tree_min() {}
  segment_tree_min(int nn, int def, bool bulk = false) {
    max_tree = segment_tree_max(nn, def, bulk);
  }
  segment_tree_min(const vector<int>& d, int def = -1e9, bool bulk = false) {
    max_tree = segment_tree_max(d, def, bulk, -1);
  }
  int get_min(int l, int r) { return -max_tree.get_max(l, r); }
  void inc_bulk(int l, int r, int val) { max_tree.inc_bulk(l, r, -val); }
  void update(int i, int val) { max_tree.update(i, -val); }
};
class lca {
 private:
  segment_tree_min min_tree;
  vector<int> h;
  vector<int> d;
  vector<int> di;
  int n;
  void dfs(const vector<vector<int> >& g, int x, int l, int p) {
    di[x] = d.size();
    h[x] = l;
    d.push_back(l);
    for (int y : g[x]) {
      if (y != p) {
        dfs(g, y, l + 1, x);
        d.push_back(l);
      }
    }
  }

 public:
  lca(const vector<vector<int> >& g) {
    int n = g.size();
    h.assign(n, 0);
    di.assign(n, 0);
    dfs(g, 0, 0, -1);
    min_tree = segment_tree_min(d);
  }
  int get_dist(int x, int y) {
    int parent_h = min_tree.get_min(di[x], di[y]);
    return h[x] - parent_h + h[y] - parent_h;
  }
};
bool check(int l, int k) {
  if (l <= k && ((k - l) % 2 == 0)) {
    return true;
  } else {
    return false;
  }
}
void solve() {
  int n;
  cin >> n;
  vector<vector<int> > g(n);
  for (int i = 0; i < n - 1; i++) {
    int x, y;
    cin >> x >> y;
    g[x - 1].push_back(y - 1);
    g[y - 1].push_back(x - 1);
  }
  lca r(g);
  int m;
  cin >> m;
  for (int i = 0; i < m; i++) {
    int x, y, a, b, k;
    cin >> x >> y >> a >> b >> k;
    int ab = r.get_dist(a - 1, b - 1);
    int ax = r.get_dist(a - 1, x - 1);
    int ay = r.get_dist(a - 1, y - 1);
    int bx = r.get_dist(b - 1, x - 1);
    int by = r.get_dist(b - 1, y - 1);
    int xy = 1;
    if (check(ab, k) || check(ax + xy + by, k) || check(ay + xy + bx, k) ||
        check(ax + xy + ay + ab, k)) {
      cout << "YES";
    } else {
      cout << "NO";
    }
    cout << endl;
  }
}
int main() {
  ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
  solve();
  cout << endl;
  return 0;
}
