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;
template <typename T>
struct LimitInt {
  T x;
  const T low, high;
  LimitInt()
      : x(0),
        low(numeric_limits<T>::min() + 10),
        high(numeric_limits<T>::max() - 10) {}
  LimitInt(T x)
      : x(x),
        low(numeric_limits<T>::min() + 10),
        high(numeric_limits<T>::max() - 10) {}
  LimitInt &operator+=(const LimitInt &y) {
    x = (double)x + y.x > high ? high : x + y.x;
    return (*this);
  }
  LimitInt &operator-=(const LimitInt &y) {
    x = (double)x - y.x < low ? low : x - y.x;
    return (*this);
  }
  LimitInt &operator*=(const LimitInt &y) {
    x = (double)x * y.x > high ? high : x * y.x;
    return (*this);
  }
  LimitInt &operator/=(const LimitInt &y) {
    x /= y.x;
    return (*this);
  }
  LimitInt operator-() const { return -x; }
  LimitInt operator+(const LimitInt &y) const {
    LimitInt ret(x);
    ret += y;
    return ret;
  }
  LimitInt operator-(const LimitInt &y) const {
    LimitInt ret(x);
    ret -= y;
    return ret;
  }
  LimitInt operator*(const LimitInt &y) const {
    LimitInt ret(x);
    ret *= y;
    return ret;
  }
  LimitInt operator/(const LimitInt &y) const {
    LimitInt ret(*this);
    ret /= y;
    return ret;
  }
  LimitInt operator==(const LimitInt &y) const { return (x == y.x); }
  LimitInt operator!=(const LimitInt &y) const { return (x != y.x); }
  LimitInt operator<(const LimitInt &y) const { return (x < y.x); }
  LimitInt operator>(const LimitInt &y) const { return (x > y.x); }
  LimitInt operator<=(const LimitInt &y) const { return (x <= y.x); }
  LimitInt operator>=(const LimitInt &y) const { return (x >= y.x); }
  T get() const { return (x); }
};
int N;
LimitInt<long long> A[100000], B[100000];
int par[100000], k[100000];
int main() {
  scanf("%d", &N);
  for (int i = 0; i < N; i++) {
    long long x;
    scanf("%lld", &x);
    A[i].x = x;
  }
  for (int i = 0; i < N; i++) {
    long long x;
    scanf("%lld", &x);
    B[i].x = x;
  }
  for (int i = 1; i < N; i++) {
    scanf("%d %d", &par[i], &k[i]);
    --par[i];
  }
  for (int i = N - 1; i > 0; i--) {
    LimitInt<long long> need = B[i] - A[i];
    if (need.get() < 0)
      A[par[i]] -= need;
    else if (need.get() > 0)
      A[par[i]] -= need * LimitInt<long long>(k[i]);
  }
  puts(A[0].get() >= B[0].get() ? "YES" : "NO");
}
