Problem:
Score : 600 points

Problem Statement

Given are an integer N and arrays S, T, U, and V, each of length N.
Construct an N×N matrix a that satisfy the following conditions:

a_{i,j} is an integer.

0 \leq a_{i,j} \lt 2^{64}.

If S_{i} = 0, the bitwise AND of the elements in the i-th row is U_{i}.

If S_{i} = 1, the bitwise OR of the elements in the i-th row is U_{i}.

If T_{i} = 0, the bitwise AND of the elements in the i-th column is V_{i}.

If T_{i} = 1, the bitwise OR of the elements in the i-th column is V_{i}.

However, there may be cases where no matrix satisfies the conditions.

Constraints

All values in input are integers.

1 \leq N \leq 500

0 \leq S_{i} \leq 1

0 \leq T_{i} \leq 1

0 \leq U_{i} \lt 2^{64}

0 \leq V_{i} \lt 2^{64}

Input

Input is given from Standard Input in the following format:

N
S_{1} S_{2} ... S_{N}
T_{1} T_{2} ... T_{N}
U_{1} U_{2} ... U_{N}
V_{1} V_{2} ... V_{N}

Output

If there exists a matrix that satisfies the conditions, print one such matrix in the following format:

a_{1,1} ... a_{1,N}
:
a_{N,1} ... a_{N,N}

Note that any matrix satisfying the conditions is accepted.

If no matrix satisfies the conditions, print -1.

Sample Input 1

2
0 1
1 0
1 1
1 0

Sample Output 1

1 1
1 0

In Sample Input 1, we need to find a matrix such that:

the bitwise AND of the elements in the 1-st row is 1;

the bitwise OR of the elements in the 2-nd row is 1;

the bitwise OR of the elements in the 1-st column is 1;

the bitwise AND of the elements in the 2-nd column is 0.

Sample Input 2

2
1 1
1 0
15 15
15 11

Sample Output 2

15 11
15 11

Solution in C++ (GCC 9.2.1) (judge verdict: Wrong Answer)

#include <iostream>
#include <vector>
#include <utility>

#define rep(i) for (int i = 0; i != n; i += 1)

using std::cin;
using std::cout;
using std::vector;
using std::swap;
using vi = vector<int>;

template<class T>
void transpose(int n, vector<vector<T>>& a) {
  rep(i) {
    for (int j = 0; j != i; j += 1) {
      swap(a[i][j], a[j][i]);
    }
  }
}

vector<vi> solve(int n, vi s, vi t, vi u, vi v) {
  vector<vi> a(n, vi(n, 0));
  rep(i) {
    rep(j) {
      if (s[i] == 1) {
        if (t[i] == 1) {
          if (u[i] != v[i]) {
            return a;
          }
        }
        else {
          if (u[i] == v[i]) {
            v[i] = 2;
          }
        }
        a[i][j] = u[i];
      }
      else {
        if (t[i] == 1) {
          if (u[i] == v[i]) {
            u[i] = 2;
          }
          a[i][j] = v[i];
        }
      }
    }
  }
  vi fs, ft;
  rep(i) {
    if (s[i] == 0) {
      fs.push_back(i);
    }
    if (t[i] == 0) {
      ft.push_back(i);
    }
  }
  bool td = false;
  if (fs.size() > ft.size()) {
    td = true;
    swap(s, t);
    swap(u, v);
    swap(fs, ft);
    transpose(n, a);
  }

  if (fs.size() == 1) {
    int i = fs[0];
    for (int j : ft) {
      if (v[j] == 2) {
        a[i][j] = u[i];
      }
      else {
        a[i][j] = v[j];
      }
    }
  }
  if (fs.size() >= 2) {
    int cs = 0;
    rep(i) {
      if (s[i] == 0) continue;
      int ct = 0;
      rep(j) {
        if (t[j] == 0) continue;
        a[i][j] = cs ^ ct;
        ct ^= 1;
      }
      ct ^= 1;
    }
  }

  if (td) {
    transpose(n, a);
  }
  return a;
}

int main() {
  using u64 = unsigned long long;

  int n;
  cin >> n;
  vi s(n), t(n);
  vector<u64> u(n), v(n);
  for (auto& e : s) cin >> e;
  for (auto& e : t) cin >> e;
  for (auto& e : u) cin >> e;
  for (auto& e : v) cin >> e;

  vector<vector<u64>> ans(n, vector<u64>(n, 0));
  for (int i = 0; i != 64; i += 1) {
    vi s_ = s, t_ = t;
    vi u_(n), v_(n);
    rep(j) {
      u_[j] = u[j] >> i & 1;
      v_[j] = v[j] >> i & 1;
      s_[j] ^= u_[j];
      t_[j] ^= v_[j];
    }
    auto ans_ = solve(n, s_, t_, u_, v_);
    rep(j) {
      rep(k) {
        ans[j][k] |= u64(ans_[j][k]) << i;
      }
    }
  }
  bool f = true;
  const auto ch = [&]() {
    rep(i) {
      if (s[i] == 0) {
        u64 a = ~u64(0);
        rep(j) {
          a &= ans[i][j];
        }
        f &= a == u[i];
      }
      else {
        u64 a = 0;
        rep(j) {
          a |= ans[i][j];
        }
        f &= a == u[i];
      }
    }
  };
  ch();
  transpose(n, ans);
  swap(s, t);
  swap(u, v);
  ch();
  transpose(n, ans);
  if (not f) {
    std::cout << "-1\n";
    return 0;
  }
  rep(i) {
    rep(j) {
      cout << ans[i][j] << " ";
    }
    cout << "\n";
  }
  return 0;
}