import sys

small = [None] * 4
for n in range(1, 4):
    table = {}
    for mask in range(1 << (n * n)):
        xm = ym = zm = 0
        for r in range(n):
            bit = 1
            for c in range(n): bit &= mask >> (r * n + c) & 1
            xm |= bit << r
        for c in range(n):
            bit = 0
            for r in range(n): bit |= mask >> (r * n + c) & 1
            ym |= bit << c
        for r in range(n):
            for c in range(n):
                if mask >> (r * n + c) & 1: zm ^= 1 << (r + c)
        table[xm | ym << n | zm << (2 * n)] = mask
    small[n] = table

def build_columns(n, active, target):
    center = n - 1
    a = bytearray(n * n)
    covered = bytearray(n)
    for d in range(2 * n - 1):
        if d == center: continue
        cols = [c for c in range(max(0, d - n + 1), min(n - 1, d) + 1) if active[c]]
        if (len(cols) & 1) != target[d]:
            if not cols: return None
            cols.pop()
        for c in cols:
            a[(d - c) * n + c] = 1
            covered[c] = 1
    parity = 0
    optional = -1
    for c in range(n):
        if not active[c]: continue
        if covered[c]: optional = c
        else: a[(center - c) * n + c] = 1; parity ^= 1
    if parity != target[center]:
        if optional < 0: return None
        a[(center - optional) * n + optional] = 1
    return a

it = iter(map(int, sys.stdin.buffer.read().split()))
out = []
for _ in range(next(it)):
    n = next(it)
    x = [next(it) for _ in range(n)]
    y = [next(it) for _ in range(n)]
    z = [next(it) for _ in range(2 * n - 1)]
    answer = [0] * (n * n)
    possible = True
    for bit in range(30):
        xb = [(v >> bit) & 1 for v in x]
        yb = [(v >> bit) & 1 for v in y]
        zb = [(v >> bit) & 1 for v in z]
        if n <= 3:
            key = sum(v << i for i, v in enumerate(xb)) | sum(v << (n + i) for i, v in enumerate(yb)) | sum(v << (2 * n + i) for i, v in enumerate(zb))
            mask = small[n].get(key)
            if mask is None: possible = False; break
            for p in range(n * n):
                if mask >> p & 1: answer[p] |= 1 << bit
            continue
        has_x_one, has_y_zero = any(xb), not all(yb)
        if has_x_one and has_y_zero:
            possible = False; break
        if has_y_zero:
            matrix = build_columns(n, yb, zb)
            if matrix is None: possible = False; break
            for p, value in enumerate(matrix):
                if value: answer[p] |= 1 << bit
        elif has_x_one:
            active = [not value for value in xb]
            target = [zb[d] ^ ((d + 1 if d < n else 2 * n - 1 - d) & 1) for d in range(2 * n - 1)]
            matrix = build_columns(n, active, target)
            if matrix is None: possible = False; break
            for r in range(n):
                for c in range(n):
                    if not matrix[c * n + r]: answer[r * n + c] |= 1 << bit
        else:
            parity = bytearray(2 * n - 1)
            for r in range(n):
                c = (r + 2) % n
                answer[r * n + c] |= 1 << bit; parity[r + c] ^= 1
            for d in range(2 * n - 1):
                r, c = d // 2, d - d // 2
                if zb[d] ^ parity[d]: answer[r * n + c] |= 1 << bit
    if not possible: out.append("-1")
    else: out.extend(" ".join(map(str, answer[r * n:(r + 1) * n])) for r in range(n))
print("\n".join(out))