#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


template <class String>
vector<pair<int, int>> lyndonSuffix(const String &as) {
  const int n = as.size();
  vector<pair<int, int>> pqs(n + 1);
  pqs[0] = make_pair(0, 0);
  for (int u = 0; u < n; ) {
    for (int p = 1, q = 1, r = 0, v = u + 1; ; ++v) {
      // as[u, v) = as[u, u + p)^q as[u, u + r)
      // as[u, u + p): Lyndon
      pqs[v] = (r != 0) ? pqs[u + r] : make_pair(p, q);
      if (v == n || as[v - p] > as[v]) {
        u = v - r;
        break;
      } else if (as[v - p] < as[v]) {
        p = v + 1 - u; q = 1; r = 0;
      } else {
        if (++r == p) { ++q; r = 0; }
      }
    }
  }
  return pqs;
}


vector<int> solve(const vector<int> &fs) {
  const int n = (int)fs.size() - 1;
  vector<int> as(n, -1);
  int id = 0;
  vector<int> ids(n, -1), par(n, -1);
  vector<int> vals(n, -1);
  for (int RR = n, R = n, L; R > 0; RR = R, R = L) {
    L = fs[R];
    // as[L, R): Lyndon factor
    {
      const int u = L;
      ids[u] = id++;
      for (int p = 1, q = 1, r = 0, v = u + 1; ; ++v) {
        const int f = v - ((r != 0) ? ((u + r) - fs[u + r]) : p);
        if (fs[v] != f) {
          return {};
        }
        if (v == R) {
          break;
        } else if (fs[v + 1] == u) {
          // as[v - p] < as[v]
          ids[v] = id++;
          par[ids[v]] = ids[v - p];
          p = v + 1 - u; q = 1; r = 0;
        } else {
          // as[v - p] == as[v]
          ids[v] = ids[v - p];
          if (++r == p) { ++q; r = 0; }
        }
      }
    }
    bool large = false;
    int last = -1;
    for (int u = L; u < R; ++u) {
      // correspoinding in next Lyndon factor
      const int tar = (u - L < RR - R) ? as[R + (u - L)] : -1;
      int &val = vals[ids[u]];
      if (!~val) {
        val = 0;
        if (~par[ids[u]]) {
          chmax(val, vals[par[ids[u]]] + 1);
        }
        if (!large) {
          chmax(val, tar);
        }
        last = ids[u];
      }
      if (!large) {
        if (val < tar) {
          ++vals[last];
          large = true;
        } else if (val > tar) {
          large = true;
        }
      }
    }
    if (!large && R - L < RR - R) {
      ++vals[last];
    }
    for (int u = L; u < R; ++u) {
      as[u] = vals[ids[u]];
    }
  }
  return as;
}


void experiment() {
  for (int n = 1; n <= 8; ++n) {
    vector<int> pw(n + 1);
    pw[0] = 1;
    for (int i = 1; i <= n; ++i) pw[i] = pw[i - 1] * n;
    map<vector<int>, vector<int>> app;
    for (int p = 0; p < pw[n]; ++p) {
      vector<int> as(n);
      for (int i = 0; i < n; ++i) {
        as[i] = p / pw[n - 1 - i] % n;
      }
      const auto pqs = lyndonSuffix(as);
      vector<int> fs(n + 1, -1);
      for (int i = 1; i <= n; ++i) {
        fs[i] = i - pqs[i].first;
      }
      if (!app.count(fs)) {
        app[fs] = as;
      }
    }
    int cntLyndon = 0;
    for (const auto &kv : app) {
      // cout << kv.first << " " << kv.second << endl;
      if (kv.first[n] == 0) {
        ++cntLyndon;
      }
    }
    cerr << n << ": " << app.size() << " " << cntLyndon << endl;
    
    vector<int> fac(n + 1);
    fac[0] = 1;
    for (int i = 1; i <= n; ++i) fac[i] = fac[i - 1] * i;
    for (int p = 0; p < fac[n]; ++p) {
      vector<int> fs(n + 1, -1);
      for (int i = 1; i <= n; ++i) {
        fs[i] = p % fac[i] / fac[i - 1];
      }
      vector<int> brt;
      {
        auto it = app.find(fs);
        if (it != app.end()) {
          brt = it->second;
        }
      }
      const auto slv = solve(fs);
      if (brt != slv) {
        cerr << "fs = " << fs << endl;
        cerr << "brt = " << brt << endl;
        cerr << "slv = " << slv << endl;
        assert(false);
      }
    }
  }
}

int main() {
  // experiment(); return 0;
  
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    int N;
    scanf("%d", &N);
    vector<int> F(N + 1, -1);
    for (int i = 1; i <= N; ++i) {
      scanf("%d", &F[i]);
      --F[i];
    }
    
    const auto ans = solve(F);
    if (!ans.empty()) {
      for (int i = 0; i < N; ++i) {
        if (i) printf(" ");
        printf("%d", ans[i] + 1);
      }
      puts("");
    } else {
      puts("-1");
    }
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}