#include "bits/stdc++.h"

using namespace std;

using ll = long long;
using ld = long double;

#define all(x) (x).begin(), (x).end()

const int ksize = 300 * 1000 + 1;
const int size_lim = 10 * 1000;
const int size_rem = 512;
const int kinf = 1000 * 1000 * 1000;
const int dlim1 = 11;
const int dlim2 = 20;

int n;
int dp[size_lim + 1][size_rem];
int depth[ksize], tsize[ksize];
int par[ksize];
bool good[ksize];
vector <int> vertex[ksize];
int ans[ksize];
int a[ksize], b[ksize];

void dfs1(int v, int p) {
  tsize[v] = 1;
  par[v] = p;
  for (auto u : vertex[v]) {
    if (u != p) {
      depth[u] = depth[v] + 1;
      dfs1(u, v);
      tsize[v] += tsize[u];
    }
  }
}

void dfs2(int v, bool isgood) {
  isgood = isgood || good[v];

  if (isgood) {
    ans[v] = 1;
    for (auto u : vertex[v]) {
      if (u != par[v]) {
        dfs2(u, isgood);
      }
    }

    return;
  }


  int lvl = depth[v] + 1;
  for (int i = 0; i < size_rem; i++) {
    dp[lvl][i] = dp[lvl - 1][i];
  }
  for (int i = 0; i < size_rem; i++) {
    dp[lvl][(i + a[v]) % size_rem] = min(dp[lvl][(i + a[v]) % size_rem], dp[lvl - 1][i] + a[v]);
  }

  if (depth[v] <= dlim1) {
    if (b[v] % a[v] == 0) {
      ans[v] = 1;
    } else {
      ans[v] = 0;
    }
  } else {
    if (dp[lvl][b[v] % size_rem] <= b[v]) {
      ans[v] = 1;
    } else {
      ans[v] = 0;
    }
  }

  for (auto u : vertex[v]) {
    if (u != par[v]) {
      dfs2(u, isgood);
    }
  }
}

int main() {
  ios_base::sync_with_stdio(false);

  cin >> n;
  for (int i = 0; i < n - 1; i++) {
    int u, v;
    cin >> u >> v;
    u--, v--;

    vertex[u].push_back(v);
    vertex[v].push_back(u);
  }
  for (int i = 0; i < n; i++) {
    cin >> a[i];
  }
  for (int i = 0; i < n; i++) {
    cin >> b[i];
  }

  depth[0] = 0;
  dfs1(0, -1);

  for (int i = 0; i < n; i++) {
    //cerr << "d: " << i << ' ' << depth[i] << endl;
    if (depth[i] <= dlim1) {
      a[i] = 1 << (20 - depth[i]);
    }
    if (depth[i] == dlim2 && tsize[i] >= size_lim) {
      good[i] = true;
      int cur = i;
      while (depth[cur] > dlim1) {
        a[cur] = 1 << (20 - depth[cur]);
        cur = par[cur];
      }
    }
  }

  for (int i = 0; i <= size_lim; i++) {
    for (int j = 0; j < size_rem; j++) {
      dp[i][j] = kinf;
    }
  }
  dp[0][0] = 0;

  dfs2(0, false);

  for (int i = 0; i < n; i++) {
    cout << a[i] << ' ';
  }
  cout << '\n';
  for (int i = 0; i < n; i++) {
    cout << ans[i];
  }
  cout << '\n';

  return 0;
}