#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

const int MAXN = 300300;
const int K1 = 20;
const int K2 = 11;
const int M = (1 << (K1 - K2));

vector<int> G[MAXN];
int sz[MAXN];
int depth[MAXN];

void dfs_sz(int v, int p, int w) {
  sz[v] = 1;
  depth[v] = w;
  for (int i = 0; i < G[v].size(); ++i) {
    if (G[v][i] == p) {
      swap(G[v][i], G[v].back());
      G[v].pop_back();
      --i;
      continue;
    }
    dfs_sz(G[v][i], v, w + 1);
    sz[v] += sz[G[v][i]];
    if (sz[G[v][i]] > sz[G[v][0]])
      swap(G[v][i], G[v][0]);
  }
}

int A[MAXN];
int B[MAXN];
bool can[MAXN];

int dp[K1][M];
int temp_dp[M];

const int INF = 1 << 22;

void dfs_dp(int v, int w) {
  for (int i = 0; i < M; ++i) {
    temp_dp[i] = dp[w][i];
  }
  for (int i = 0; i < M; ++i) {
    temp_dp[(i + A[v]) % M] = min(temp_dp[(i + A[v]) % M], dp[w][i] + A[v]);
  }
  for (int i = 0; i < M; ++i)
    dp[w][i] = temp_dp[i];
  if (depth[v] <= K2) {
    can[v] = B[v] % A[v] == 0;
  } else {
    can[v] = temp_dp[B[v] % M] <= B[v];
  }
  if (G[v].empty())
    return;
  for (int j = 1; j < G[v].size(); ++j) {
    for (int i = 0; i < M; ++i)
      dp[w + 1][i] = dp[w][i];
    dfs_dp(G[v][j], w + 1);
  }
  dfs_dp(G[v][0], w);
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  
  int n;
  cin >> n;
  for (int i = 1; i < n; ++i) {
    int a, b;
    cin >> a >> b;
    --a;
    --b;
    G[a].emplace_back(b);
    G[b].emplace_back(a);
  }
  for (int i = 0; i < n; ++i)
    cin >> A[i];
  for (int i = 0; i < n; ++i)
    cin >> B[i];
  dfs_sz(0, -1, 0);
  for (int i = 0; i < n; ++i) {
    if (depth[i] <= K2)
      A[i] = (1 << (K1 - depth[i]));
  }
  for (int i = 0; i < M; ++i)
    dp[0][i] = INF;
  dp[0][0] = 0;
  dfs_dp(0, 0);
  for (int i = 0; i < n; ++i)
    cout << A[i] << ' ';
  cout << '\n';
  for (int i = 0; i < n; ++i)
    cout << can[i];
  cout << '\n';
  return 0;
}