#include <bits/stdc++.h>
using namespace std;
using int64 = long long;

// Fenwick (BIT) for prefix sums + finding k-th “1”
struct Fenwick {
    int n;
    vector<int> f;
    Fenwick(int _n): n(_n), f(n+1, 0) {}
    void update(int i, int v){
        for(; i<=n; i += i&-i) f[i] += v;
    }
    int query(int i) const {
        int s = 0;
        for(; i>0; i -= i&-i) s += f[i];
        return s;
    }
    // find smallest pos such that prefix sum >= k (1 ≤ k ≤ total)
    int find_kth(int k) const {
        int pos = 0;
        int bit = 1 << (31 - __builtin_clz(n));
        for(; bit; bit >>= 1) {
            int nxt = pos + bit;
            if(nxt <= n && f[nxt] < k){
                k -= f[nxt];
                pos = nxt;
            }
        }
        return pos + 1;
    }
};

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

    // Precompute SPF up to max N = 5e5
    const int MAXN = 500000;
    vector<int> spf(MAXN+1);
    for(int i=1;i<=MAXN;i++) spf[i] = i;
    for(int p=2; p*p<=MAXN; p++){
        if(spf[p]==p){
            for(int q=p*p; q<=MAXN; q+=p){
                if(spf[q]==q) spf[q] = p;
            }
        }
    }
    spf[1] = 1;  // define SPF(1)=1

    int T; 
    cin >> T;
    while(T--){
        int n;
        cin >> n;
        vector<int> C(n+1);
        for(int i=1;i<=n;i++) cin >> C[i];

        // Group positions by SPF(i)
        unordered_map<int, vector<int>> groups;
        groups.reserve(n*2);
        for(int i=1;i<=n;i++){
            groups[spf[i]].push_back(i);
        }

        vector<int64> A(n+1, 0);
        bool ok = true;

        // Process each group independently
        for(auto &kv : groups){
            auto &pos = kv.second;
            int m = pos.size();

            // Build the inversion-vector c[k] for k=0..m-1
            vector<int> inv(m);
            for(int k=0;k<m;k++){
                int idx = pos[k];
                inv[k] = C[idx];
                // must satisfy 0 ≤ inv[k] ≤ (m-k-1)
                if(inv[k] < 0 || inv[k] > m-k-1){
                    ok = false;
                    break;
                }
            }
            if(!ok) break;

            // Fenwick over 1..m initially all 1's
            Fenwick fw(m);
            for(int i=1;i<=m;i++) fw.update(i,1);

            // Reconstruct values 1..m per group
            // For each k, pick the (inv[k]+1)-th smallest remaining
            for(int k=0;k<m;k++){
                int pick = fw.find_kth(inv[k] + 1);
                // assign that as A at position pos[k]
                A[ pos[k] ] = pick;
                // remove from Fenwick
                fw.update(pick, -1);
            }
        }

        if(!ok){
            cout << "NO\n";
        } else {
            cout << "YES\n";
            // values are between 1..m ≤ n ≤ 5e5; all ≤ 1e9
            // If you prefer to stretch them, you can scale/mix, but not necessary
            for(int i=1;i<=n;i++){
                cout << A[i] << (i<n?' ':'\n');
            }
        }
    }

    return 0;
}