#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i,n) for(ll i=0; i<(ll)(n); i++)
#define repi(i,a,b) for(ll i=(ll)(a); i<(ll)(b); i++)
using vi=vector<int>;
using vvi=vector<vi>;
using vll=vector<ll>;
using vvll=vector<vll>;
template<typename T,typename S> bool chmin(T&a,const S& b){
    return a>b?a=b,1:0;
}
template<typename T,typename S> bool chmax(T&a,const S& b){
    return a<b?a=b,1:0;
}
const ll inf=2e18;
#define all(a) (a).begin(),(a).end()
#define arr(a) (a).rbegin(),(a).rend()
using P=pair<ll,ll>;
using vp=vector<P>;
using vvp=vector<vp>;

struct UnionFind {
    vector<int> par,siz;
    UnionFind(int n) : par(n,-1),siz(n,1) {}
    int root(int x){
        if(par[x]==-1)return x;
        else return par[x]=root(par[x]);
    }
    bool issame(int x,int y){
        return root(x)==root(y);
    }
    bool unite(int x,int y){
        x=root(x),y=root(y);
        if(x==y)return false;
        if(siz[x]<siz[y])swap(x,y);
        par[y]=x;
        siz[x]+=siz[y];
        return true;
    }
    int size(int x){
        return siz[root(x)];
    }
};
constexpr int mod=998244353;
struct mint{
    int x;
    mint(ll x_=0) :x(x_%mod){
        if(x<0)x+=mod;
    }
    mint operator-(){
        auto res=*this;
        res.x=(x?mod-x:0);
        return res;
    }
    mint& operator+=(mint r){
        if((x+=r.x)>=mod)x-=mod;
        return *this;
    }
    mint& operator-=(mint r){
        if((x-=r.x)<0)x+=mod;
        return *this;
    }
    mint& operator*=(mint r){
        x=1LL*x*r.x%mod;
        return *this;
    }
    mint& operator/=(mint r){
        return *this*=r.inv();
    }
    friend mint operator+(mint a,mint b){
        return a+=b;
    }
    friend mint operator-(mint a,mint b){
        return a-=b;
    }
    friend mint operator*(mint a,mint b){
        return a*=b;
    }
    friend mint operator/(mint a,mint b){
        return a/=b;
    }
    mint inv() const{return pow(mod-2);}
    mint pow(ll b) const{
        mint a=*this,c=1;
        while(b){
            if(b&1)c*=a;
            a*=a;
            b>>=1;
        }
        return c;
    }
};
using vm=vector<mint>;
template<class S, S (*op)(S,S),S (*e)()> struct SegmentTree{
    private:
    int _n,size,log;
    vector<S> dat;
    void update(int k){
        dat[k]=op(dat[2*k],dat[2*k+1]);
    }
    public:
    SegmentTree():SegmentTree(0){}
    SegmentTree(int n):SegmentTree(vector<S>(n,e())){}
    SegmentTree(const vector<S>& v) : _n(int(v.size())){
        log=0;
        while((1<<log)<_n)log++;
        size=1<<log;
        dat=vector<S>(2*size,e());
        for(int i=0; i<_n; i++)dat[size+i]=v[i];
        for(int i=size-1; i>=1; i--){
            update(i);
        }
    }
    void set(int p,S x){
        p+=size;
        dat[p]=x;
        for(int i=1; i<=log; i++)update(p>>i);
    }
    S get(int p) const {return dat[p+size];}
    S prod(int l,int r) const{
        S sml=e(),smr=e();
        l+=size;
        r+=size;
        while(l<r){
            if(l&1)sml=op(sml,dat[l++]);
            if(r&1)smr=op(dat[--r],smr);
            l>>=1;
            r>>=1;
        }
    }
    S all_prod() const {return dat[1];}
};


void solve(int test){
    int n; cin >> n;
    vi r(n),c(n);
    rep(i,n)cin >> r[i],r[i]--;
    rep(i,n)cin >> c[i],c[i]--;
    vvi g(n);
    vi cols;
    rep(i,n){
        cols.push_back(c[i]);
        g[c[i]].push_back(i);
    }
    sort(all(cols));
    cols.erase(unique(all(cols)),cols.end());
    int si=cols.size();
    if(n==2){
        cout << -1 << endl;
        return;
    }
    if(si==1){
        cout << -1 << endl;
        return;
    }
    vvi ans(n,vi(n));
    vi invr(n);
    rep(i,n)invr[r[i]]=i;
    set<int> st;
    rep(i,n)st.insert(i);
    rep(x,cols.size()){
        int j=g[cols[x]].back();
        g[cols[x]].pop_back();
        st.erase(cols[(x+1)%si]);
        int i=invr[cols[(x+1)%si]];
        ans[i][j]=-1;
    }
    rep(x,cols.size()){
        int j=g[cols[x]].back();
        int i=invr[*st.begin()];
        st.erase(*st.begin());
        ans[i][j]=-1;
    }


    rep(i,n){
        rep(j,n)if(ans[i][j]!=-1){
            ans[i][j]=r[i];
        }
    }
    rep(j,n)rep(i,n){
        if(ans[i][j]==-1){
            ans[i][j]=c[j];
        }
    }
    rep(i,n){
        rep(j,n)cout << ans[i][j]+1 << " ";
        cout << endl;
    }



}
int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    int t=1; cin >> t;
    rep(test,t)solve(test);
}