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 Kotlin (1.3.71) (judge verdict: Runtime Error)




fun verify(suspect: Array<LongArray>, s: IntArray, t: IntArray, u: LongArray, v: LongArray): Boolean {
    for (i in s.indices) {
        val result = if (s[i] == 0) {
            t.indices.fold(0L.inv()){acc, j -> acc and suspect[i][j]}
        }else {
            t.indices.fold(0L){acc, j -> acc or suspect[i][j]}
        }
        if (result != u[i]) return false
    }
    for (i in t.indices) {
        val result = if (t[i] == 0) {
            s.indices.fold(0L.inv()){acc, j -> acc and suspect[j][i]}
        }else {
            s.indices.fold(0L){acc, j -> acc or suspect[j][i]}
        }
        if (result != v[i]) return false
    }
    return true
}
fun Long.nthBit(n: Int): Long {
    return this and (1L shl n)
}
fun main() {
    val n = readLine()!!.trim().toInt()
    val s = readLine()!!.trim().split(' ').map(String::toInt).toIntArray()
    val t = readLine()!!.trim().split(' ').map(String::toInt).toIntArray()
    val u = readLine()!!.trim().split(' ').map(String::toLong).toLongArray()
    val v = readLine()!!.trim().split(' ').map(String::toLong).toLongArray()
    val result = Array(n){LongArray(n){0} }
    val (andS, orS) = s.indices.partition{s[it] == 0}
    val (andT, orT) = t.indices.partition{t[it] == 0}
    for (d in 0 until 64) {
        var digit = 1L
        for (i in s.indices) if ((s[i] == 0 && u[i].nthBit(d) == 0L) || (s[i] == 1 && u[i].nthBit(d) != 0L)) {
            for (j in t.indices) if ((t[i] == 0 && v[i].nthBit(d) == 0L) || (t[i] == 1 && v[i].nthBit(d) != 0L)) {
                result[i][j] = result[i][j] or (digit shl d)
                digit = 1 - digit
            }
        }
        for (i in andS) if (u[i].nthBit(d) != 0L) {
            for (j in t.indices) result[i][j] = result[i][j] or (1L shl d)
        }
        for (j in andT) if (v[j].nthBit(d) != 0L) {
            for (i in s.indices) result[i][j] = result[i][j] or (1L shl d)
        }
        for (i in orS) if (u[i].nthBit(d) == 0L) {
            for (j in t.indices) result[i][j] = result[i][j] and (1L shl d).inv()
        }
        for (j in orT) if (v[j].nthBit(d) == 0L) {
            for (i in s.indices) result[i][j] = result[i][j] and (1L shl d).inv()
        }
    }
    if (verify(result, s, t, u, v)) {
        println(result.joinToString("\n"){it.joinToString(" ")})
    }else {
        println(-1)
    }
}