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 Rust (1.42.0) (judge verdict: Accepted)

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!();
    }
}