#include <bits/stdc++.h>
template <typename T>
using V = std::vector<T>;
template <typename T>
using VV = std::vector<std::vector<T>>;
template <typename T>
using VVV = std::vector<std::vector<std::vector<T>>>;
template <class T>
inline T ceil(T a, T b) {
  return (a + b - 1) / b;
}
template <class T>
inline void print(T x) {
  std::cout << x << std::endl;
}
template <class T>
inline void print_vec(const std::vector<T> &v) {
  for (int i = 0; i < v.size(); ++i) {
    if (i != 0) {
      std::cout << " ";
    }
    std::cout << v[i];
  }
  std::cout << "\n";
}
template <class T>
inline bool inside(T y, T x, T H, T W) {
  return 0 <= y and y < H and 0 <= x and x < W;
}
template <class T>
inline double euclidean_distance(T y1, T x1, T y2, T x2) {
  return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
template <class T>
inline double manhattan_distance(T y1, T x1, T y2, T x2) {
  return abs(x1 - x2) + abs(y1 - y2);
}
const int INF = 1L << 30;
const double EPS = 1e-9;
const std::string YES = "YES", Yes = "Yes", NO = "NO", No = "No";
const std::vector<int> dy4 = {0, 1, 0, -1}, dx4 = {1, 0, -1, 0};
const std::vector<int> dy8 = {0, -1, 0, 1, 1, -1, -1, 1},
                       dx8 = {1, 0, -1, 0, 1, 1, -1, -1};
using namespace std;
pair<long long, long long> dfs(long long node, vector<vector<long long>> &tree,
                               vector<long long> &X) {
  if (tree[node].size() == 0) {
    return {X[node], 0};
  }
  vector<pair<long long, long long>> v;
  for (auto n : tree[node]) {
    auto p = dfs(n, tree, X);
    if (p.first == -1 or p.second == -1) {
      return make_pair(-1, -1);
    }
    v.emplace_back(p);
  }
  set<pair<long long, long long>> s1;
  s1.insert({0, 0});
  for (auto p1 : v) {
    set<pair<long long, long long>> s2;
    for (auto p2 : s1) {
      s2.insert({p2.first + p1.first, p2.second + p1.second});
      s2.insert({p2.first + p1.second, p2.second + p1.first});
    }
    s1 = s2;
  }
  pair<long long, long long> best = make_pair(LONG_LONG_MAX, LONG_LONG_MAX);
  for (auto p : s1) {
    if (p.first <= X[node] and p.second < best.second) {
      best = {X[node] - p.first, p.second};
    }
    if (p.second <= X[node] and p.first < best.second) {
      best = {X[node] - p.second, p.first};
    }
  }
  if (best.first == LONG_LONG_MAX or best.second == LONG_LONG_MAX) {
    return {-1, -1};
  }
  return best;
};
int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  long long N;
  cin >> N;
  vector<vector<long long>> tree(N);
  vector<long long> X(N);
  for (int i = (0); i < ((int)N - 1); ++i) {
    int p;
    cin >> p;
    p--;
    tree[p].emplace_back(i + 1);
  }
  for (int i = (0); i < ((int)N); ++i) {
    cin >> X[i];
  }
  auto ans = dfs(0, tree, X);
  if (ans.first == -1 or ans.second == -1 or
      (ans.first > X[0] and ans.second > X[1])) {
    print("IMPOSSIBLE");
  } else {
    print("POSSIBLE");
  }
  return 0;
}
