5
27468 7465 74275 40573 40155
112071 76270 244461 264202 132397
1 777133331
2 107454154
3 652330694
4 792720519
 5
78188 56310 79021 70050 65217
115040 5149 128449 98357 36580
1 451393770
2 574046602
3 590130784
4 112514248
 7
1 1 1 1 1 1 1
1 3000000000 3000000000 3000000000 1000000000 1000000000 1000000000
1 1000000000
1 1000000000
1 1000000000
1 1000000000
1 1000000000
1 1000000000
 10
2 8 6 1 2 7 6 9 2 8
4 9 4 3 5 2 9 3 7 3
1 8
2 8
3 8
4 10
5 1
6 4
7 3
8 10
9 2
 11
1 1 1 1 1 1 1 1 1 1 1
1 1000000001 1000000001 1000000001 1000000001 1000000001 1000000001 1000000001 1000000001 1000000001 1000000001
1 1000000000
1 1000000000
1 1000000000
1 1000000000
1 1000000000
1 1000000000
1 1000000000
1 1000000000
1 1000000000
1 1000000000
 5
2 1 1 2 3
1 2 2 2 1
1 2
1 3
2 4
1 4

NO
 NO
 NO
 YES
 NO
 NO

#include <bits/stdc++.h>
using namespace std;
const double INF = 1e18;
struct Tree {
  int n;
  vector<vector<int>> g;
  vector<int> parent;
  vector<long long> target;
  vector<long long> current;
  vector<long long> rate;
  Tree(int n) : n(n) {
    g.assign(n, vector<int>());
    parent.assign(n, -1);
    current.assign(n, 0);
    target.assign(n, 0);
    rate.assign(n, 0);
  }
  void addNodeCurrent(int i, long long v) { current[i] = v; }
  void addNodeTarget(int i, long long v) { target[i] = v; }
  void addEdge(int u, int v, int k) {
    g[u].push_back(v);
    g[v].push_back(u);
    rate[u] = k;
  }
  bool solve(int root) {
    vector<int> order;
    deque<int> queue;
    queue.push_back(root);
    parent[root] = -2;
    while (!queue.empty()) {
      int u = queue.front();
      queue.pop_front();
      order.push_back(u);
      for (int v : g[u]) {
        if (parent[v] == -1) {
          parent[v] = u;
          queue.push_back(v);
        }
      }
    }
    bool success = true;
    for (int i = order.size() - 1; i >= 1; i--) {
      int u = order[i];
      int p = parent[u];
      if (current[u] >= target[u]) {
        current[p] += (current[u] - target[u]);
        current[u] = target[u];
      } else if (current[u] < target[u]) {
        if (INF / rate[u] > (target[u] - current[u])) {
          current[p] -= (target[u] - current[u]) * rate[u];
          current[u] = target[u];
          if (current[p] < -INF) {
            success = false;
            break;
          }
        } else {
          success = false;
          break;
        }
      }
    }
    return success && (current[0] >= target[0]);
  }
};
int main() {
  int n;
  cin >> n;
  Tree tree(n);
  for (int i = 0; i < n; i++) {
    long long w;
    cin >> w;
    tree.addNodeCurrent(i, w);
  }
  for (int i = 0; i < n; i++) {
    long long w;
    cin >> w;
    tree.addNodeTarget(i, w);
  }
  for (int i = 1; i < n; i++) {
    int v, k;
    cin >> v >> k;
    v--;
    tree.addEdge(i, v, k);
  }
  bool ans = tree.solve(0);
  cout << (ans ? "YES" : "NO") << endl;
  return 0;
}
