#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;
}
