use proconio::{fastout, input};

fn solve(y: &mut Vec<Vec<u64>>, n: usize, s: &[usize], t: &[usize], u: &[u64], v: &[u64]) -> bool {
    for i in 0..n {
        if s[i] == 0 && u[i] == 1 {
            for j in 0..n {
                if y[i][j] == 0 {
                    return false;
                }

                y[i][j] = 1;
            }
        } else if s[i] == 1 && u[i] == 0 {
            for j in 0..n {
                if y[i][j] == 1 {
                    return false;
                }

                y[i][j] = 0;
            }
        }

        if t[i] == 0 && v[i] == 1 {
            for j in 0..n {
                if y[j][i] == 0 {
                    return false;
                }

                y[j][i] = 1;
            }
        } else if t[i] == 1 && v[i] == 0 {
            for j in 0..n {
                if y[j][i] == 1 {
                    return false;
                }

                y[j][i] = 0;
            }
        }
    }

    loop {
        let mut updated = false;

        for i in 0..n {
            let mut rc = [0; 3];
            let mut rj = 0;

            for j in 0..n {
                rc[y[i][j] as usize] += 1;

                if y[i][j] == 2 {
                    rj = j;
                }
            }

            if s[i] == 0 && u[i] == 0 {
                if rc[2] == 0 && rc[0] == 0 {
                    return false;
                } else if rc[2] == 1 && rc[0] == 0 {
                    y[i][rj] = 0;
                    updated = true;
                }
            } else if s[i] == 1 && u[i] == 1 {
                if rc[2] == 0 && rc[1] == 0 {
                    return false;
                } else if rc[2] == 1 && rc[1] == 0 {
                    y[i][rj] = 1;
                    updated = true;
                }
            }

            let mut cc = [0; 3];
            let mut cj = 0;

            for j in 0..n {
                cc[y[j][i] as usize] += 1;

                if y[j][i] == 2 {
                    cj = j;
                }
            }

            if t[i] == 0 && v[i] == 0 {
                if cc[2] == 0 && cc[0] == 0 {
                    return false;
                } else if cc[2] == 1 && cc[0] == 0 {
                    y[cj][i] = 0;
                    updated = true;
                }
            } else if t[i] == 1 && v[i] == 1 {
                if cc[2] == 0 && cc[1] == 0 {
                    return false;
                } else if cc[2] == 1 && cc[1] == 0 {
                    y[cj][i] = 1;
                    updated = true;
                }
            }
        }

        if !updated {
            break;
        }
    }

    let mut ris = Vec::new();
    let mut cis = Vec::new();

    for i in 0..n {
        let mut rc = 0;

        for j in 0..n {
            if y[i][j] == 2 {
                rc += 1;
            }
        }

        if rc != 0 {
            ris.push(i);
        }

        let mut cc = 0;

        for j in 0..n {
            if y[j][i] == 2 {
                cc += 1;
            }
        }

        if cc != 0 {
            cis.push(i);
        }
    }

    for i in 0..ris.len() {
        for j in 0..cis.len() {
            y[ris[i]][cis[j]] = ((i + j) % 2) as u64;
        }
    }

    for i in 0..n {
        for j in 0..n {
            if y[i][j] == 2 {
                y[i][j] = 0;
            }
        }
    }

    return true;
}

#[fastout]
fn main() {
    input! {in_n: usize, in_s: [usize; in_n], in_t: [usize; in_n], in_u: [u64; in_n], in_v: [u64; in_n]};
    let mut out = Vec::new();

    for _ in 0..in_n {
        out.push(vec![0; in_n]);
    }

    for i in 0..64 {
        let mut y = Vec::new();
        let mut u = Vec::new();
        let mut v = Vec::new();

        for j in 0..in_n {
            y.push(vec![2 as u64; in_n]);
            u.push(in_u[j] >> (63 - i) & 0x01);
            v.push(in_v[j] >> (63 - i) & 0x01);
        }

        if !solve(&mut y, in_n, &in_s, &in_t, &u, &v) {
            println!("-1");
            return;
        }

        for j in 0..in_n {
            for k in 0..in_n {
                out[j][k] = (out[j][k] << 1) | y[j][k];
            }
        }
    }

    for r in &out {
        for v in r.iter() {
            print!("{} ", v);
        }
        println!();
    }
}


Measured memory_bytes: 9484