#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<tuple>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = (ll)1000000007 * 1000000007;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define Per(i,sta,n) for(int i=n-1;i>=sta;i--)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef long double ld;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<ll, ll> LP;
int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};

struct SCC{
  vector<vector<int> > G,R,T,C;//T:強連結分解後のグラフ
  vector<int> vs,used,blg;
  SCC(int n):G(n),R(n),used(n),blg(n){}

  void add_edge(int u,int v){
    G[u].emplace_back(v);
    R[v].emplace_back(u);
  }

  int size(){
    return T.size();
  }

  void dfs(int v){
    used[v]=1;
    for(int u:G[v])
      if(!used[u]) dfs(u);
    vs.emplace_back(v);
  }

  void rdfs(int v,int k){
    used[v]=1;
    blg[v]=k;
    C[k].emplace_back(v);
    for(int u:R[v])
      if(!used[u]) rdfs(u,k);
  }

  int build(){
    int n=G.size();
    for(int v=0;v<n;v++)
      if(!used[v]) dfs(v);

    fill(used.begin(),used.end(),0);
    int k=0;
    for(int i=n-1;i>=0;i--){
      if(!used[vs[i]]){
        T.emplace_back();
        C.emplace_back();
        rdfs(vs[i],k++);
      }
    }
    for(int v=0;v<n;v++)
      for(int u:G[v])
        if(blg[v]!=blg[u])
          T[blg[v]].push_back(blg[u]);

    for(int i=0;i<k;i++){
      sort(T[i].begin(),T[i].end());
      T[i].erase(unique(T[i].begin(),T[i].end()),T[i].end());
    }
    return k;
  }
  int operator[](int k) const{return blg[k];};//頂点kの属する強連結成分
};


int n;
int s[510],t[510],u[510];

void solve(){
  cin >> n;
  rep(i,n) {
    cin >> s[i];
    s[i]-=1;
  }
  rep(i,n) {
    cin >> t[i];
    t[i]-=1;
  }
  rep(i,n) cin >> u[i];
  SCC scc(2*n*n);
  rep(i,n){
    rep(j,n){
      int p=u[i]%2,q=u[i]/2;
      int a=s[i]*n+j,b=j*n+t[i];
      scc.add_edge(2*a+p,2*b+1-q);
      scc.add_edge(2*b+q,2*a+1-p);
    }
  }
  scc.build();
  rep(i,n){
    if(scc[2*i]==scc[2*i+1]){
      cout << -1 << endl;
      return;
    }
  }
  int m=scc.size();
  vector<vector<int>> v(m,vector<int>());
  rep(i,2*n*n){
    v[scc.blg[i]].push_back(i);
  }
  vector<bool> ban(m);
  vector<int> ans(n*n);
  rep(i,m){
    if(ban[i]) continue;
    for(int s:v[i]){
      ans[s/2]=s%2;
      ban[scc.blg[2*(s/2)+1-s%2]]=true;
    }
  }
  rep(i,n){
    rep(j,n){
      cout << ans[i*n+j] << " ";
    }
    cout << "" << endl;
  }
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout << fixed << setprecision(50);
    solve();
}