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-----
2
0 1
1 0
1 1
1 0

-----Sample Output-----
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.

Difficulty: interview

Starter code:

Solutions:
def main():
    import sys
    sys.setrecursionlimit(10**9)
    input = sys.stdin.readline

    N = int(input())
    S = list(map(int, input().split()))
    T = list(map(int, input().split()))
    U = list(map(int, input().split()))
    V = list(map(int, input().split()))

    range_N = list(range(N))
    ans = [[0]*N for _ in range_N]
    # 論理積
    for i in range_N:
        if S[i] == 0:
            for j in range_N:
                ans[i][j] = ans[i][j] | U[i]
        if T[i] == 0:   
            for j in range_N:
                ans[j][i] = ans[j][i] | V[i]
    for i in range_N:
        for j in range_N:
            if (U[i] & V[j]):
                ans[i][j] = ans[i][j] | (U[i] & V[j])

    # 論理和
    for x in range_N:
        if S[x] == 0:
            continue
        x_sum = ans[x][0]
        for y in range_N:
            x_sum = x_sum | ans[x][y]
        if x_sum == U[x]:
            continue
        up = U[x] - x_sum
        for y in range_N:
            if T[y]:
                continue
            y_mul = ans[0][y]
            for i in range_N:
                if i == x:
                    continue
                y_mul = y_mul & ans[i][y]
            up_y = (~y_mul) & up
            ans[x][y] += up_y
            up -= up_y
            if up == 0:
                break

    for y in range_N:
        if T[y] == 0:
            continue
        y_sum = ans[0][y]
        for x in range_N:
            y_sum = y_sum | ans[x][y]
        if y_sum == V[y]: 
            continue
        up = V[y] - y_sum
        for x in range_N:
            if S[x]:
                continue
            x_mul = ans[x][0]
            for j in range_N:
                if y == j:
                    continue
                x_mul = x_mul & ans[x][j]
            up_x = (~x_mul) & up
            ans[x][y] += up_x
            up -= up_x
            if up == 0:
                break

    # チェック
    for i in range_N:
        check_xs = ans[i][0]
        check_ys = ans[0][i]
        check_xm = ans[i][0]
        check_ym = ans[0][i]
        for j in range_N:
            check_xs = check_xs | ans[i][j]
            check_ys = check_ys | ans[j][i]
            check_xm = check_xm & ans[i][j]
            check_ym = check_ym & ans[j][i]
        if (S[i] and U[i] != check_xs) \
        or (T[i] and V[i] != check_ys) \
        or (S[i] == 0 and U[i] != check_xm) \
        or (T[i] == 0 and V[i] != check_ym) :
            print((-1))
            return       

    for i in range_N:
        print((*ans[i]))

main()


import numpy as np

N = int(input())

S = list(map(int,input().split()))
T = list(map(int,input().split()))
U = np.array(list(map(int,input().split())),dtype = np.uint64)
V = np.array(list(map(int,input().split())),dtype = np.uint64)

ans = np.zeros((N,N),dtype = np.uint64)

for n in range(64):
  u = (U>>n)&1
  v = (V>>n)&1
  su = [int(S[i]*2+u[i]) for i in range(N)]
  tv = [int(T[i]*2+v[i]) for i in range(N)]
  suzerozero = []
  suoneone = []
  tvzerozero = []
  tvoneone = []
  for i in range(N):
    if su[i] == 0:
      suzerozero.append(i)
    if su[i] == 3:
      suoneone.append(i)
  for i in range(N):
    if tv[i] == 0:
      tvzerozero.append(i)
    if tv[i] == 3:
      tvoneone.append(i)
  
  b = np.zeros((N,N),dtype = np.uint64)
  ###行のAND=1とOR=0を埋める###
  for i in range(N):
    if su[i] == 1:
      b[i] = np.ones(N,int)
  ###列のAND=1とOR=0を埋める###
  for i in range(N):
    if tv[i] == 1:
      b[:,i] = np.ones(N,int)
  ###行と列の値が一致するところを埋める###  
  b |= np.dot(np.array([u]).T,np.ones((1,N),dtype = np.uint64)) & np.dot(np.array([v]).T,np.ones((1,N),dtype = np.uint64)).T
  ###行のOR=1を満たしていく### 
  if 1 not in tv and 3 not in tv:
    m = len(tvzerozero)
    now = 0
    for i in suoneone:
      b[i][tvzerozero[now%m]] += 1
      now += 1
  ###列のOR=1を満たしていく### 
  if 1 not in su and 3 not in su:
    m = len(suzerozero)
    now = 0
    for i in tvoneone:
      b[suzerozero[now%m]][i] += 1
      now += 1
  ans += b<<n

def end():
  print((-1))
  return
for i in range(N):
  if S[i] == 0:
    now = ans[i][0]
    for j in range(1,N):
      now &= ans[i][j]
  if S[i] == 1:
    now = ans[i][0]
    for j in range(1,N):
      now |= ans[i][j]
  if now != U[i]:
    end()
for i in range(N):
  if T[i] == 0:
    now = ans[0][i]
    for j in range(1,N):
      now &= ans[j][i]
  if T[i] == 1:
    now = ans[0][i]
    for j in range(1,N):
      now |= ans[j][i]
  if now != V[i]:
    end()

for item in ans:
  print((*list(item)))


import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7

def main():
    n = int(input())
    ans = [[0 for _ in range(n)] for _ in range(n)]
    s = list(map(int, input().split()))
    t = list(map(int, input().split()))
    u = list(map(int, input().split()))
    v = list(map(int, input().split()))
    for i in range(n):
        if not s[i]:
            for j in range(n):
                ans[i][j] = ans[i][j]|u[i]
        if not t[i]:   
            for j in range(n):
                ans[j][i] = ans[j][i]|v[i]
    for i in range(n):
        for j in range(n):
            if (u[i] & v[j]):
                ans[i][j] = ans[i][j]|(u[i]&v[j])
    for x in range(n):
        if not s[x]:
            continue
        x_sum = ans[x][0]
        for y in range(n):
            x_sum = x_sum|ans[x][y]
        if x_sum == u[x]: 
            continue
        up = u[x] - x_sum
        for y in range(n):
            if t[y]:
                continue
            y_mul = ans[0][y]
            for i in range(n):
                if i == x:
                    continue
                y_mul = y_mul&ans[i][y]
            up_y = (~y_mul)&up
            ans[x][y] += up_y
            up -= up_y
            if not up:
                break
    for y in range(n):
        if not t[y]:
            continue
        y_sum = ans[0][y]
        for x in range(n):
            y_sum = y_sum|ans[x][y]
        if y_sum == v[y]: 
            continue
        up = v[y] - y_sum
        for x in range(n):
            if s[x]:
                continue
            x_mul = ans[x][0]
            for j in range(n):
                if y == j:
                    continue
                x_mul = x_mul&ans[x][j]
            up_x = (~x_mul)&up
            ans[x][y] += up_x
            up -= up_x
            if not up:
                break
    for i in range(n):
        check_xs = ans[i][0]
        check_ys = ans[0][i]
        check_xm = ans[i][0]
        check_ym = ans[0][i]
        for j in range(n):
            check_xs = check_xs|ans[i][j]
            check_ys = check_ys|ans[j][i]
            check_xm = check_xm&ans[i][j]
            check_ym = check_ym&ans[j][i]
        if s[i] and u[i] != check_xs:
            print(-1)
            return       
        if t[i] and v[i] != check_ys:
            print(-1)
            return       
        if not s[i] and u[i] != check_xm:
            print(-1)
            return       
        if not t[i] and v[i] != check_ym:
            print(-1)
            return
    for i in range(n):
        print(*ans[i])

def __starting_point():
    main()
__starting_point()