#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <random>
#include <stdio.h>
#include <fstream>
#include <functional>
#include <cassert>
#include <unordered_map>
#include <bitset>
#include <chrono>




using namespace std;




#define rep(i,n) for (int i=0;i<n;i+=1)
#define rrep(i,n) for (int i=n-1;i>-1;i--)
#define pb push_back
#define all(x) (x).begin(), (x).end()

#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << " )\n";

template<class T>
using vec = vector<T>;
template<class T>
using vvec = vec<vec<T>>;
template<class T>
using vvvec = vec<vvec<T>>;
using ll = long long;
using ld = long double;
using pii = pair<int,int>;
using pll = pair<ll,ll>;


template<class T>
bool chmin(T &a, T b){
  if (a>b){
    a = b;
    return true;
  }
  return false;
}

template<class T>
bool chmax(T &a, T b){
  if (a<b){
    a = b;
    return true;
  }
  return false;
}

template<class T>
T sum(vec<T> x){
  T res=0;
  for (auto e:x){
    res += e;
  }
  return res;
}

template<class T>
void printv(vec<T> x){
  for (auto e:x){
    cout<<e<<" ";
  }
  cout<<endl;
}



template<class T,class U>
ostream& operator<<(ostream& os, const pair<T,U>& A){
  os << "(" << A.first <<", " << A.second << ")";
  return os;
}

template<class T>
ostream& operator<<(ostream& os, const set<T>& S){
  os << "set{";
  for (auto a:S){
    os << a;
    auto it = S.find(a);
    it++;
    if (it!=S.end()){
      os << ", ";
    }
  }
  os << "}";
  return os;
}

template<class T0,class T1,class T2>
ostream& operator<<(ostream& os, const tuple<T0,T1,T2>& a){
  auto [x,y,z] = a;
  os << "(" << x << ", " << y << ", " << z << ")";
  return os;
}

template<class T0,class T1,class T2,class T3>
ostream& operator<<(ostream& os, const tuple<T0,T1,T2,T3>& a){
  auto [x,y,z,w] = a;
  os << "(" << x << ", " << y << ", " << z << ", " << w  << ")";
  return os;
}

template<class T,class U>
ostream& operator<<(ostream& os, const map<U,T>& A){
  os << "map{";
  for (auto e:A){
    os << e.first;
    os << ":";
    os << e.second;
    os << ", ";
  }
  os << "}";
  return os;
}

template<class T>
ostream& operator<<(ostream& os, const vec<T>& A){	
  os << "[";
  rep(i,A.size()){
    os << A[i];
    if (i!=A.size()-1){
      os << ", ";
    }
  }
  os << "]" ;
  return os;
}

template <typename T, bool isMin = true> struct ConvexHullTrick {
    std::deque<std::pair<T, T>> lines;  // slope decreases as index increases

    bool empty() const { return lines.empty(); }

    void add(T a, T b) {
        if (!isMin) a *= -1, b *= -1;
        std::pair<T, T> l(a, b);
        if (empty()) {
            lines.emplace_back(a, b);
            return;
        }
        if (lines.front().first <= a) {
            if (lines.front().first == a) {
                if (lines.front().second <= b) return;
                lines.pop_front();
            }
            while (lines.size() >= 2 && check(l, lines.front(), lines[1])) lines.pop_front();
            lines.emplace_front(l);
        } else if (a <= lines.back().first) {
            if (lines.back().first == a) {
                if (lines.back().second <= b) return;
                lines.pop_back();
            }
            while (lines.size() >= 2 && check(lines[lines.size() - 2], lines.back(), l)) lines.pop_back();
            lines.emplace_back(l);
        } else
            assert(false);
    }

    T query(T x) {
        assert(!called_query_monotonic_inc && !called_query_monotonic_dec);
        assert(!empty());
        called_query = true;
        int lb = -1, ub = lines.size() - 1;
        while (ub - lb > 1) {
            int mid = (ub + lb) >> 1;
            (f(lines[mid], x) >= f(lines[mid + 1], x) ? lb : ub) = mid;
        }
        T res = f(lines[ub], x);
        return isMin ? res : -res;
    }

    T query_monotone_inc(T x) {
        assert(!called_query && !called_query_monotonic_dec);
        assert(!empty());
        if (!called_query_monotonic_inc)
            called_query_monotonic_inc = true;
        else
            assert(prev_query <= x);
        prev_query = x;
        while (lines.size() >= 2 && f(lines.front(), x) >= f(lines[1], x)) lines.pop_front();
        T res = f(lines.front(), x);
        return isMin ? res : -res;
    }

    T query_monotone_dec(T x) {
        assert(!called_query && !called_query_monotonic_inc);
        assert(!empty());
        if (!called_query_monotonic_dec)
            called_query_monotonic_dec = true;
        else
            assert(x <= prev_query);
        prev_query = x;
        while (lines.size() >= 2 && f(lines.back(), x) >= f(lines[lines.size() - 2], x)) lines.pop_back();
        T res = f(lines.back(), x);
        return isMin ? res : -res;
    }

  private:
    bool called_query = false, called_query_monotonic_inc = false, called_query_monotonic_dec = false;
    T prev_query;

    using D = long double;

    // check if b is unnecessary
    inline bool check(const std::pair<T, T>& a, const std::pair<T, T>& b, const std::pair<T, T>& c) {
        // return (b.first - a.first) * (c.second - b.second) >= (c.first - b.first) * (b.second - a.second);
        // note that slopes are distinct and decrease
        return D(c.second - b.second) / (c.first - b.first) >= D(b.second - a.second) / (b.first - a.first);
    }

    inline T f(const std::pair<T, T>& l, T x) { return l.first * x + l.second; }
};

const ll INF = 5e15;


void solve(){
  const int M = 6;

  int N;
  cin>>N;

  vec<set<int>> X_set(M), Y_set(M), Z_set(M);
  priority_queue<tuple<int,int,int>,vector<tuple<int,int,int>>,greater<tuple<int,int,int>>> axis_pq;
  vec<int> point_to_ok_axis(N,3);  

  vec<tuple<int,int,int>> XYZ(N);
  rep(i,N){
    int x,y,z;
    cin>>x>>y>>z;
    XYZ[i] = {x,y,z};
    X_set[x].insert(i);
    Y_set[y].insert(i);
    Z_set[z].insert(i);
  }

  rep(c,M){
    axis_pq.push({X_set[c].size(),0,c});
    axis_pq.push({Y_set[c].size(),1,c});
    axis_pq.push({Z_set[c].size(),2,c});
  }

  int remove_cnt = 0;
  auto remove_axis = [&](int c,vec<set<int>>& axis_set){
    vec<int> delst;
    for (auto idx:axis_set[c]){
        point_to_ok_axis[idx]--;
        if (point_to_ok_axis[idx] == 0){
            delst.push_back(idx);
        }
    }
    for (auto idx:delst){
        remove_cnt++;
        auto [x,y,z] = XYZ[idx];
        X_set[x].erase(idx);
        Y_set[y].erase(idx);
        Z_set[z].erase(idx);
        
        axis_pq.push({X_set[x].size(),0,x});
        axis_pq.push({Y_set[y].size(),1,y});
        axis_pq.push({Z_set[z].size(),2,z});
    }
  };

  

  
  for (int k=0;k<N;k++){
    while (!axis_pq.empty()){
        auto [axis_sz,axis_type,c] = axis_pq.top();        
        
        if (axis_type == 0){
            if (int(X_set[c].size()) != axis_sz){
                axis_pq.pop();
                continue;
            }
        }
        else if (axis_type == 1){
            if (int(Y_set[c].size()) != axis_sz){
                axis_pq.pop();
                continue;
            }
        }
        else{
            if (int(Z_set[c].size()) != axis_sz){
                axis_pq.pop();
                continue;
            }
        }

        if (axis_sz > k) break;

        axis_pq.pop();
        if (axis_type == 0){
            remove_axis(c,X_set);
        }
        else if (axis_type == 1){
            remove_axis(c,Y_set);
        }
        else{
            remove_axis(c,X_set);
        }
    }   

    cout << remove_cnt;
    if (k == N-1){
        cout << "\n";
    }
    else{
        cout << " ";
    }
  }


  
  

}








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

  cout << setprecision(15);

  int T;
  cin>>T;
  while (T--){
    solve();
  }
}