#![allow(unused)]

use itertools::Itertools;
use std::cmp::{min, max};
use std::io::Write;

macro_rules! debug {
    ($($a:expr),*) => {
        eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

//
// Based on EbTech's Scanner https://stackoverflow.com/q/56449027
//
struct Scanner<'a, R: std::io::BufRead> {
    reader: R,
    buf: String,
    iter: std::str::SplitWhitespace<'a>,
}

impl<'a, R: std::io::BufRead> Scanner<'a, R> {
    fn new(reader: R) -> Self {
        Self { reader, buf: String::new(), iter: "".split_whitespace() }
    }

    fn get<T: std::str::FromStr>(&mut self) -> T {
        if let Some(t) = self.iter.next() {
            return t.parse().ok().expect("Parse error")
        }
        self.buf.clear();
        self.reader.read_line(&mut self.buf).expect("I/O error");
        self.iter = unsafe { std::mem::transmute(self.buf.split_whitespace()) };
        self.get()
    }
}

//==============================================================================
//
// Problem specific code
//
//==============================================================================

fn verify(
    ans: &Vec<Vec<u64>>,
    n: usize,
    ss: &Vec<i32>,
    ts: &Vec<i32>,
    us: &Vec<u64>,
    vs: &Vec<u64>,
) {
    for i in 0..n {
        if ss[i] == 0 {
            if ans[i].iter().fold(!0, |a, &x| a & x) != us[i] {
                panic!();
            }
        } else {
            if ans[i].iter().fold(0, |a, &x| a | x) != us[i] {
                panic!();
            }
        }
    }
    for j in 0..n {
        if ts[j] == 0 {
            if (0..n).map(|i| ans[i][j]).fold(!0, |a, x| a & x) != vs[j] {
                panic!();
            }
        } else {
            if (0..n).map(|i| ans[i][j]).fold(0, |a, x| a | x) != vs[j] {
                panic!();
            }
        }
    }
}

fn solve(
    n: usize, ss: &Vec<i32>, ts: &Vec<i32>, us: &Vec<u64>, vs: &Vec<u64>
) -> Option<Vec<Vec<u64>>> {
    // Start from zeros and set some of them one.
    let mut ans = vec![vec![0; n]; n];

    let mut ras = vec![!0; n]; // Row AND
    let mut ros = vec![0; n]; // Row OR
    let mut cas = vec![!0; n]; // Column AND
    let mut cos = vec![0; n]; // Column OR

    // Set bits that must be one because of the AND conditions.
    for i in 0..n { for j in 0..n {
        ans[i][j] = match (ss[i], ts[j]) {
            (0, 0) => us[i] | vs[j],
            (0, _) => us[i],
            (_, 0) => vs[j],
            _      => 0,
        };
        ras[i] &= ans[i][j];
        ros[i] |= ans[i][j];
        cas[j] &= ans[i][j];
        cos[j] |= ans[i][j];
    }}

    // Unsatisfiable if the previous step fails to satisfy the AND
    // condition, or the row/column-wise OR have extra '1' bits.
    if (0..n).any(|i|
        (ss[i] == 0 && ras[i] != us[i])
        || (ss[i] != 0 && ros[i] | us[i] != us[i])
        || (ts[i] == 0 && cas[i] != vs[i])
        || (ts[i] != 0 && cos[i] | vs[i] != vs[i]))
    {
        return None;
    }

    for i in 0..n {
        // The AND condition is already satisfied
        if ss[i] == 0 {
            continue
        }

        // Bits that need to be set to satisfy the OR condition
        let mut b = us[i] & !ros[i];

        for j in 0..n {
            if b == 0 {
                break;
            }
            if ts[j] == 0 {
                // Calculate the column-wise AND assuming that `ans[i][j] |= b`.
                // If it has extra '1's, set them in `b` and go to next `j`.
                let and = (0..n).fold(!0, |a, i_| {
                    a & (ans[i_][j] | (if i_ == i { b } else { 0 }))
                });
                let extrabits = and & !vs[j];
                ans[i][j] |= b & !extrabits;
                b = extrabits;
            } else {
                // Set bits that does not changes the column-wise OR
                ans[i][j] |= b & vs[j];
                b &= !vs[j];
            }
        }

        // Unsatisfiable if '1' bits remain in `b`
        if b != 0 {
            return None;
        }
    }

    for j in 0..n {
        if ts[j] == 0 {
            continue
        }

        let mut b = vs[j] & !cos[j];

        for i in 0..n {
            if b == 0 {
                break;
            }
            if ss[i] == 0 {
                let and = (0..n).fold(!0, |a, j_| {
                    a & (ans[i][j_] | (if j_ == j { b } else { 0 }))
                });
                let extrabits = and & !us[i];
                ans[i][j] |= b & !extrabits;
                b = extrabits;
            } else {
                ans[i][j] |= b & us[i];
                b &= !us[i];
            }
        }

        if b != 0 {
            return None;
        }
    }

    //verify(&ans, n, &ss, &ts, &us, &vs);
    Some(ans)
}

fn main() -> std::io::Result<()> {
    let sin = std::io::stdin();
    let mut sc = Scanner::new(sin.lock());

    let n = sc.get();
    let ss: Vec<i32> = (0..n).map(|_| sc.get()).collect();
    let ts: Vec<i32> = (0..n).map(|_| sc.get()).collect();
    let us: Vec<u64> = (0..n).map(|_| sc.get()).collect();
    let vs: Vec<u64> = (0..n).map(|_| sc.get()).collect();

    if let Some(ans) = solve(n, &ss, &ts, &us, &vs) {
        let sout = std::io::stdout();
        let mut sout = sout.lock();
        for i in 0..n {
            for j in 0..(n - 1) {
                write!(sout, "{} ", ans[i][j])?;
            }
            write!(sout, "{}\n", ans[i][n - 1])?;
        }
    } else {
        println!("-1");
    }

    Ok(())
}


Measured memory_bytes: 7296