#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <iomanip>
#define endl '\n'
#define int long long
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define rep2(i,a,b) for(int i=(a);i>=(b);i--)
using namespace std;
template<typename... Args>
void bu(Args... args) { cout << ":: "; ((cout << args << " "), ...); cout << endl; }
template<typename T>
void bu(vector<T> tem) { for (auto x : tem) cout << x << ' '; cout << endl; }
void kuaidu() { ios::sync_with_stdio(false), cin.tie(0), cout.tie(0); }
inline int max(int a, int b) { if (a < b) return b; return a; }
inline int min(int a, int b) { if (a < b) return a; return b; }
using PII = pair<int, int>;
using i128 = __int128;

//--------------------------------------------------------------------------------
const int N = 1e5 + 10;
const int M = 1e6 + 10;
const int mod = 1e9 + 7;
const int INF = 1e16;
int n, m, T;
int A[N];
class tree {
    vector<int> F;
    int n;
    int fan(int x) { return x & -x; }
    int get(int x) {
        x += 1; int tem = 0; for (int i = x; i >= 1; i -= fan(i)) tem += F[i];
        return tem;
    }
public:
    void init(int n_) {
        vector<int>().swap(F);
        n = n_ + 1;
        F.resize(n + 5);
    }
    void add(int x, int val) {
        x += 1; for (int i = x; i <= n; i += fan(i)) F[i] += val;
    }
    int qry(int l, int r) {
        if (l > r) return 0; if (l - 1 < 0) return get(r);
        return get(r) - get(l - 1);
    }
    int find(int k) {
        int x = 0, sum = 0;
        if (qry(0, n) < k || k <= 0) return -114514;
        for (int i = 1 << std::__lg(n); i; i /= 2) {
            if (x + i <= n and sum + F[x + i] < k) {
                sum += F[x + i];
                x += i;
            }
        }
        return x;
    }
}shu;
int dp[N], pre[N];
int num[N];
//--------------------------------------------------------------------------------

signed main() {
    kuaidu();
    shu.init(1000000 + 10);

    T = 1; cin >> T;
    while (T--) {
        cin >> n;
        int mmax = -INF;

        rep(i, 1, n) {
            pre[i] = 0;
            dp[i] = 0;
        }

        rep(i, 1, n) {
            cin >> A[i];
            pre[i] = max(pre[i - 1], A[i]);

            if (i == 1) dp[i] = 0, mmax = A[i];
            else {
                if (A[i] > mmax) {
                    dp[i] = dp[i - 1] + 1;
                    mmax = A[i];
                }
                else {
                    dp[i] = dp[i - 1];
                }
            }
            // cout << i << " " << dp[i] << endl;
        }


        int ans = 0;
        rep(i, 1, n) {

            if (A[i] > pre[i - 1] and i != 1) ans++;
            else {
                int tem = shu.qry(A[i] + 1, pre[i]);
                ans += tem;
            }

            if (num[A[i]] == 0) {
                shu.add(A[i], 1);
                num[A[i]] = 1;
            }

            dp[i] += ans;
        }

        rep(i, 1, n) {
            if (i != n)
                cout << dp[i] << " ";
            else cout << dp[i] << endl;
        }

        rep(i, 1, n) {
            // shu.add(A[i], -1);
            if (num[A[i]]) shu.add(A[i], -1);
            num[A[i]] = 0;
        }

    }
    return 0;
}
/*

0 2 4 6 9 13

6
1
3
2
3 4
3
3 4 2
4
3 4 2 6
5
3 4 2 6 2
6
3 4 2 6 2 1
*/