#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx2")

// 数値型
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using P = pair<int,int>;
using Pll = pair<ll, ll>;
using Pli = pair<ll, int>;
using Pil = pair<int, ll>;

// vector関連
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
template<typename T>
using vc = vector<T>;
template<typename T>
using vvc = vector<vc<T>>;
template<typename T>
using vvvc = vector<vvc<T>>;
template<typename T>
using vvvvc = vector<vvvc<T>>;

// priority_queue
template<typename T>
using pq = priority_queue<T>;
template<typename T>
using pqg = priority_queue<T, vc<T>, greater<T>>;

#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define FOR(i, a, b) for(int i = a; i < (int)(b); i++)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define MIN(vec) *min_element(vec)
#define MAX(vec) *max_element(vec)
#define next_perm(vec) next_permutation((vec).begin(), (vec).end())
#define UNIQUE(vec) vec.erase(unique(vec.begin(), vec.end()), vec.end())
#define el "\n"
#define Yes cout << "Yes" << el
#define No cout << "No" << el
#define YES cout << "YES" << el
#define NO cout << "NO" << el
#define EPS 1e-8
#define Equal(a, b) (fabs((a)-(b)) < EPS) 
#define dbg(x) cerr << #x << "=" << x << el 

// 定数
const string abc = "abcdefghijklmnopqrstuvwxyz";
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
constexpr int INF = 1001001001;
constexpr ll LINF = 1001001001001001001ll;
constexpr int DX[] = {1, 0, -1, 0};
constexpr int DY[] = {0, 1, 0, -1};
constexpr int DX8[] = {1, 0, -1, 0, 1, 1, -1, -1};
constexpr int DY8[] = {0, 1, 0, -1, 1, -1, 1, -1};

template<typename T1, typename T2>
ostream &operator<< (ostream &os, pair<T1, T2> p) {
    os << "{" << p.first << "," << p.second << "}";
    return os;
}
template<typename T>
ostream &operator<< (ostream &os, vc<T> &vec) {
    int sz = vec.size();
    rep(i, sz){
        os << vec[i] << (i==sz-1?"":" ");
    }
    return os;
}

template<typename T1, typename T2>
istream &operator>> (istream &is, pair<T1, T2> &p) {
    is >> p.first >> p.second;
    return is;
}
template<typename T>
istream &operator>> (istream &is, vc<T> &vec) {
    int sz = vec.size();
    rep(i, sz) { is >> vec[i]; }
    return is;
}
/// @brief aとｂの最大値をaに格納。更新があったかbool値を返す
/// @tparam T1 
/// @tparam T2 
/// @param a 
/// @param b 
/// @return bool
template<typename T1, typename T2>
inline bool chmax(T1 &a, T2 b){
    bool ret = a<b;
    if(ret) a = b;
    return ret;
}

/// @brief aとｂの最小値をaに格納。更新があったかbool値を返す
/// @tparam T1 
/// @tparam T2 
/// @param a 
/// @param b 
/// @return bool
template<typename T1, typename T2>
inline bool chmin(T1 &a, T2 b){
    bool ret = a>b;
    if(ret) {a = b;}
    return ret;
}

inline void YesNo(bool flag){
    if(flag) {Yes;}
    else {No;}
    return;
}

inline void YESNO(bool flag){
    if(flag) {YES;}
    else {NO;}
    return;
}

inline bool outof(ll x, ll xlim){
    return (x<0 || x>=xlim);
}

template<typename T>
inline T sqnorm(T x, T y){
    return x*x+y*y;
}

/// @brief char->int
/// @param c 
/// @return int
inline int ctoi(char c){
    return c-'0';
}

/// @brief xを素因数分解
/// @param x 
/// @return vector<Pli>, 素因数の昇順に {p, cnt}
vector<Pli> prime_fact(ll x){
    vector<Pli> ret;
    for(ll i=2; i*i<=x; i++){
        if(x%i == 0){
            ret.emplace_back(i, 0);
            while(x%i == 0){
                ret.back().second++;
                x /= i;
            }
        }
    }
    if(x != 1) ret.emplace_back(x, 1);
    return ret;
}

/// @brief xの約数列挙
/// @param x 
/// @return vll, 約数の昇順
vll divisor_enum(ll x){
    vector<ll> ret;
    for(ll i=1; i*i<=x; i++){
        if(x%i == 0){
            ret.push_back(x/i);
            ret.push_back(i);
        }
    }
    sort(all(ret));
    UNIQUE(ret);
    return ret;
}

/// @brief 繰り返し二乗法。
/// @tparam T 
/// @param x 
/// @param k 
/// @param op 
/// @param e 
/// @return 
template<typename T>
T pow_t(T x, ll k, T (*op)(T, T), T (*e)()){
    T ret = e();
    while(k){
        if(k&1) ret = op(ret, x);
        x = op(x, x);
        k >>= 1;
    }
    return ret;
}

ll powll(ll x, ll k){
    return pow_t<ll>(x, k, [](ll a, ll b) -> ll{return a*b;}, []() -> ll{return 1;});
}

inline int pop_cnt(ll x) { return __builtin_popcountll(x); }
inline int top_bit(ll x) { return (x==0?-1:63-__builtin_clzll(x));}

void main2();

int main(){
    ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    main2();
}

map<pair<vi, vi>, vvi> mp;


void rot(int n, vvi &a) {
    vvi b(n, vi(n));
    rep(i, n) rep(j, n) b[i][j] = a[j][i];
    swap(a, b);
}

pair<vi, vi> calc(int n, vvi a) {
    vi r(n, -1), c(n, -1);
    rep(_, 2) {
        rep(i, n) {
            vi cnt(n+1, 0);
            rep(j, n) {
                cnt[a[i][j]]++;
            }
            int ma = MAX(all(cnt));
            int id = -1;
            rep(j, n+1) {
                if(ma == cnt[j]) {
                    if(id == -1) id = j;
                    else return {r, c};
                }
            }
            r[i] = id; 
        }
        rot(n, a);
        swap(r, c);
    }

    return {r, c};
}

void embed(int ub) {
    FOR(n, 1, ub+1) {
        queue<vvi> que;
        que.push(vvi(n, vi(n)));
        rep(i, n) {
            rep(j, n) {
                queue<vvi> nque;
                while(!que.empty()) {
                    auto vv = que.front();
                    que.pop();
                    FOR(k, 1, n+1) {
                        vv[i][j] = k;
                        nque.push(vv);
                    }
                }
                swap(que, nque);
            }
        }

        while(!que.empty()) {
            auto [r, c] = calc(n, que.front());
            mp[{r, c}] = que.front();
            que.pop();
        }
    }
    return;
}

void solve() {
    int n;
    cin >> n;
    vi r(n), c(n);
    cin >> r >> c;
    if(n < 4) {
        if(mp.count({r, c}) == 0) {
            cout << -1 << el;
        }
        else {
            auto vec = mp[{r, c}];
            rep(i, n) {
                cout << vec[i] << el;
            }
        }
        return;
    }

    vvi ans(n);
    rep(i, n) {
        ans[i] = vi(n, r[i]);
    }

    if(n == 4) {
        bool ok = false;
        rep(i1, n) {
            if(r[i1] == c[0]) continue;
            rep(i2, n) {
                if(r[i2] == c[1] || i2 == i1) continue;
                rep(i3, n) {
                    if(r[i3] == c[2] || i3 == i2 || i3 == i1) continue;
                    rep(i4, n) {
                        if(r[i4] == c[3] || i4 == i3 || i4 == i2 || i4 == i1) continue;
                        vvi copy = ans;
                        copy[i1][0] = c[0];
                        copy[i2][1] = c[1];
                        copy[i3][2] = c[2];
                        copy[i4][3] = c[3];
                        auto [rr, cc] = calc(n, copy);
                        if(rr == r && cc == c) {
                            ok = true;
                            ans = copy;
                        }
                        if(ok) break;
                    }
                    if(ok) break;
                }
                if(ok) break;
            }
            if(ok) break;
        }
        if(ok) {
            rep(i, n) cout << ans[i] << el;
        }
        else cout << -1 << el;
        return;
    }

    rep(j, n) {
        if(ans[j][j] != c[j]) ans[j][j] = c[j];
        else ans[(j+1)%n][j] = c[j];
    }

    rep(i, n) cout << ans[i] << el;
}
void main2(){
    embed(3);
    int t;
    cin >> t;
    while(t--) {
        solve();
    }
}