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: Wrong Answer)



@OptIn(kotlin.ExperimentalUnsignedTypes::class)
fun verify(suspect: Array<ULongArray>, s: IntArray, t: IntArray, u: ULongArray, v: ULongArray): Boolean {
    for (i in s.indices) {
        val result = if (s[i] == 0) {
            t.indices.fold(0UL.inv()){acc, j -> acc and suspect[i][j]}
        }else {
            t.indices.fold(0UL){acc, j -> acc or suspect[i][j]}
        }
        if (result != u[i])
            return false
    }
    for (j in t.indices) {
        val result = if (t[j] == 0) {
            s.indices.fold(0UL.inv()){acc, i -> acc and suspect[i][j]}
        }else {
            s.indices.fold(0UL){acc, i -> acc or suspect[i][j]}
        }
        if (result != v[j])
            return false
    }
    return true
}
@OptIn(kotlin.ExperimentalUnsignedTypes::class)
fun ULong.nthBit(n: Int): ULong {
    return (this and (1UL shl n))
}
fun main2() {
    println(9727915932813629704UL)
    println("9727915932813629704".toULong())
    println(ULong.MAX_VALUE)
    val list = readLine()!!.trim().split(' ')
    val ulong = list.map(String::toULong).toULongArray()
    println(ulong.joinToString(","))
}
@OptIn(kotlin.ExperimentalUnsignedTypes::class)
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::toULong).toULongArray()
    val v = readLine()!!.trim().split(' ').map(String::toULong).toULongArray()
    val result = Array(n){ULongArray(n){0UL} }
    val (andS, orS) = s.indices.partition{s[it] == 0}
    val (andT, orT) = t.indices.partition{t[it] == 0}
    for (d in 0 until 64) {
        val oneRow = BooleanArray(n){false}
        val zeroRow = BooleanArray(n){false}
        val oneColumn = BooleanArray(n){false}
        val zeroColumn = BooleanArray(n){false}
        val (andOneS, andZeroS) = andS.partition { u[it].nthBit(d) != 0UL }
        val (orOneS, orZeroS) = orS.partition { u[it].nthBit(d) != 0UL }
        val (andOneT, andZeroT) = andT.partition { v[it].nthBit(d) != 0UL }
        val (orOneT, orZeroT) = orT.partition { v[it].nthBit(d) != 0UL }
        for (i in andOneS) {
            for (j in 0 until n) {
                result[i][j] = result[i][j] or (1UL shl d)
                oneColumn[j] = true
                oneRow[i] = true
            }
        }
        for (j in andOneT) {
            for (i in 0 until n) {
                result[i][j] = result[i][j] or (1UL shl d)
                oneColumn[j] = true
                oneRow[i] = true
            }
        }
        for (i in orZeroS) {
            for (j in 0 until n) {
                zeroRow[i] = true
                zeroColumn[j] = true
            }
        }
        for (j in orZeroT) {
            for (i in 0 until n) {
                zeroRow[i] = true
                zeroColumn[j] = true
            }
        }
        //TODO()
        if (orOneS.size + andZeroS.size >= 2 && orOneT.size + andZeroT.size >= 2) {
            var start = 1
            for (i in orOneS + andZeroS) {
                var digit = start
                start = 1 - start
                for (j in orOneT + andZeroT) {
                    result[i][j] = result[i][j] or (digit.toULong() shl d)
                    digit = 1 - digit
                }
            }
        }else if (orOneS.size + andZeroS.size == 1){
            for (i in orOneS) {
                for (j in orOneT) {
                    result[i][j] = result[i][j] or (1UL shl d)
                }
                for (j in andZeroT) {
                    if (zeroColumn[j]) {
                        result[i][j] = result[i][j] or (1UL shl d)
                    }
                }
            }
            for (i in andZeroS) {
                for (j in orOneT) {
                    if (!oneColumn[j]) {
                        result[i][j] = result[i][j] or (1UL shl d)
                    }
                }
            }
        }else {
            for (j in orOneT) {
                for (i in orOneS) {
                    result[i][j] = result[i][j] or (1UL shl d)
                }
                for (i in andZeroT) {
                    if (zeroRow[i]) {
                        result[i][j] = result[i][j] or (1UL shl d)
                    }
                }
            }
            for (j in andZeroT) {
                for (i in orOneS) {
                    if (!oneRow[i]) {
                        result[i][j] = result[i][j] or (1UL shl d)
                    }
                }
            }
        }
    }
    if (verify(result, s, t, u, v)) {
        println(result.joinToString("\n"){it.joinToString(" ")})
    }else {
        println(-1)
    }
}