description: This problem is an extension of the problem "Wonderful Coloring - 1". It has quite many differences, so you should read this statement completely.
  
  Recently, Paul and Mary have found a new favorite sequence of integers a_1, a_2, ..., a_n. They want to paint it using pieces of chalk of k colors. The coloring of a sequence is called wonderful if the following conditions are met:
  
    1. each element of the sequence is either painted in one of k colors or isn't painted; 
    2. each two elements which are painted in the same color are different (i. e. there's no two equal values painted in the same color); 
    3. let's calculate for each of k colors the number of elements painted in the color — all calculated numbers must be equal; 
    4. the total number of painted elements of the sequence is the maximum among all colorings of the sequence which meet the first three conditions. 
  
  
  
  E. g. consider a sequence a=[3, 1, 1, 1, 1, 10, 3, 10, 10, 2] and k=3. One of the wonderful colorings of the sequence is shown in the figure.
  
  <image> The example of a wonderful coloring of the sequence a=[3, 1, 1, 1, 1, 10, 3, 10, 10, 2] and k=3. Note that one of the elements isn't painted.
  
  Help Paul and Mary to find a wonderful coloring of a given sequence a.
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 10000) — the number of test cases. Then t test cases follow.
  
  Each test case consists of two lines. The first one contains two integers n and k (1 ≤ n ≤ 2⋅10^5, 1 ≤ k ≤ n) — the length of a given sequence and the number of colors, respectively. The second one contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n).
  
  It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
  
  Output
  
  Output t lines, each of them must contain a description of a wonderful coloring for the corresponding test case.
  
  Each wonderful coloring must be printed as a sequence of n integers c_1, c_2, ..., c_n (0 ≤ c_i ≤ k) separated by spaces where
  
    * c_i=0, if i-th element isn't painted; 
    * c_i>0, if i-th element is painted in the c_i-th color. 
  
  
  
  Remember that you need to maximize the total count of painted elements for the wonderful coloring. If there are multiple solutions, print any one.
  
  Example
  
  Input
  
  
  6
  10 3
  3 1 1 1 1 10 3 10 10 2
  4 4
  1 1 1 1
  1 1
  1
  13 1
  3 1 4 1 5 9 2 6 5 3 5 8 9
  13 2
  3 1 4 1 5 9 2 6 5 3 5 8 9
  13 3
  3 1 4 1 5 9 2 6 5 3 5 8 9
  
  
  Output
  
  
  1 1 0 2 3 2 2 1 3 3
  4 2 1 3
  1
  0 0 1 1 0 1 1 1 0 1 1 1 0
  2 1 2 2 1 1 1 1 2 1 0 2 2
  1 1 3 2 1 3 3 1 2 2 3 2 0
  
  Note
  
  In the first test case, the answer is shown in the figure in the statement. The red color has number 1, the blue color — 2, the green — 3.
solution: /*
   
      /$$$$$  /$$$$$$  /$$    /$$  /$$$$$$                                                                  
     |__  $$ /$$__  $$ |$$    |$$ /$$__  $$                                                                 
            | $$| $$  \ $$|    $$|$$| $$  \ $$                                                                 
            | $$| $$$$$$$$|  $$ / $$/| $$$$$$$$                                                                 
  / $$  | $$| $$__  $$ \  $$ $$/ | $$__  $$                                                                 
  | $$  | $$| $$  | $$  \  $$$/  | $$  | $$                                                                 
  |  $$$$$$/| $$  | $$   \  $/   | $$  | $$                                                                 
   \______/ |__/  |__/    \_/    |__/  |__/    
   
  /$$$$$$$  /$$$$$$$   /$$$$$$   /$$$$$$  /$$$$$$$   /$$$$$$  /$$      /$$ /$$      /$$ /$$$$$$$$ /$$$$$$$ 
  | $$__  $$| $$__  $$ /$$__  $$ /$$__  $$| $$__  $$ /$$__  $$| $$$    /$$$| $$$    /$$$| $$_____/| $$__  $$
  | $$  \ $$| $$  \ $$| $$  \ $$| $$  \__/| $$  \ $$| $$  \ $$| $$$$  /$$$$| $$$$  /$$$$| $$      | $$  \ $$
  | $$$$$$$/| $$$$$$$/| $$  | $$| $$ /$$$$| $$$$$$$/| $$$$$$$$| $$ $$/$$ $$| $$ $$/$$ $$| $$$$$   | $$$$$$$/
  | $$____/ | $$__  $$| $$  | $$| $$|_  $$| $$__  $$| $$__  $$| $$  $$$| $$| $$  $$$| $$| $$__/   | $$__  $$
  | $$      | $$  \ $$| $$  | $$| $$  \ $$| $$  \ $$| $$  | $$| $$\  $ | $$| $$\  $ | $$| $$      | $$  \ $$
  | $$      | $$  | $$|  $$$$$$/|  $$$$$$/| $$  | $$| $$  | $$| $$ \/  | $$| $$ \/  | $$| $$$$$$$$| $$  | $$
  |__/      |__/  |__/ \______/  \______/ |__/  |__/|__/  |__/|__/     |__/|__/     |__/|________/|__/  |__/
                                                                                                             
                                                                                                                                                                                                                   
                                                                                                                                                                                                                  
   
  */
  ////solution at bottom 
  import java.util.*;
  import java.lang.*;
  import java.io.*;
  import java.math.*;
  
   
  /* Name of the class has to be "Main" only if the class is public. */
           public class test
  {
  
      
      
  public static void main (String[] args) throws java.lang.Exception
      {
          // your code goes here
           
          int t=1;
          br=new FastReader();
                                    t=br.ni();
  
          
    
       in1 :   for(int TC = 1; TC <= t ; TC++)
          {
              
                  solve();
   
   
       
          }
            
              //          System.out.println("OUTPUT:::");
      
            System.out.print(sb);
      }
      ///end main
      static StringBuilder sb = new StringBuilder();
      
      static void solve() throws Exception{
                        int n = br.ni() , k = br.ni();
                        ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
                        for(int i=0;i<n+10;i++)adj.add(new ArrayList<>());
                          int[] ans = new int[n];
                      int[] a = br.niarr(n);
                      for(int i=0;i<n;i++){
                          adj.get(a[i]).add(i);
                      }
                      boolean[] vis = new boolean[n+1];
                      int rem = n;
                      for(int i=1;i<=n;i++){
                          if(adj.get(i).size() >= k){
                               vis[i] = true;
                                
                               for(int y = 1; y<=k;y++){
                                  ans[adj.get(i).get(y-1)] = y;
                               }
                               rem -= adj.get(i).size();
                          }
  
                      } 
                       Queue<Pair> q1 = new LinkedList<>();
                       for(int i  =1;i<=n;i++){
                          if(vis[i])continue;
                          for(int j : adj.get(i)){
                              q1.add(new Pair(i , j));
                          }
                       }
                       while(q1.size() >= k){
                          for(int y = 1 ; y<=k ; y++){
                              Pair p = q1.poll();
                              ans[p.y ] = y; 
                          }
                       }
                       for(int i : ans)sb.append(i+" ");
                          sb.append("\n");
  
  
  
             }
                  
      //end solve
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
      static void shuffle( int arr[])
      {
          int n = arr.length;
          Random r = new Random();
           
         for (int i = n-1; i > 0; i--) {
             int j = r.nextInt(i+1);
               
              int temp = arr[i];
              arr[i] = arr[j];
              arr[j] = temp;
          }
      }
      static void shuffle( long arr[])
      {
          int n = arr.length;
          Random r = new Random();
           
         for (int i = n-1; i > 0; i--) {
             int j = r.nextInt(i+1);
               
              long temp = arr[i];
              arr[i] = arr[j];
              arr[j] = temp;
          }
      }
      static void shuffle( int arr[][])
      {
          int n = arr.length;
          Random r = new Random();
           
         for (int i = n-1; i > 0; i--) {
             int j = r.nextInt(i+1);
               
              int[] temp = arr[i];
              arr[i] = arr[j];
              arr[j] = temp;
          }
      }
      
      static class FastReader 
      { 
          BufferedReader br; 
          StringTokenizer st; 
    
          public FastReader() 
          { 
              br = new BufferedReader(new
                       InputStreamReader(System.in)); 
          } 
    
          String next() 
          { 
              while (st == null || !st.hasMoreElements()) 
              { 
                  try
                  { 
                      st = new StringTokenizer(br.readLine()); 
                  } 
                  catch (IOException  e) 
                  { 
                      e.printStackTrace(); 
                  } 
              } 
              return st.nextToken(); 
          }
           
          int[][] tdiarr(int m , int n){
              int[][] a = new int[m][n];
              for(int i=0;i<m;i++){
                  for(int j=0;j<n;j++){
                      a[i][j]=Integer.parseInt(next());
                  }
              }
              return a;
          }
          long[][] tdlarr(int m , int n){
              long[][] a = new long[m][n];
              for(int i=0;i<m;i++){
                  for(int j=0;j<n;j++){
                      a[i][j]=Long.parseLong(next());
                  }
              }
              return a;
          }
   
          int[] niarr(int n)
          {
              int[] a = new int[n];
              for(int i=0;i<n;i++)a[i]=Integer.parseInt(next());
              return a;
          }
          long[] nlarr(int n)
          {
              long[] a = new long[n];
              for(int i=0;i<n;i++)a[i]=Long.parseLong(next());
              return a;
          }
          char[] ncarr(){
              return next().trim().toCharArray();
              
              
          }
          
    
          int ni() 
          { 
              return Integer.parseInt(next()); 
          } 
    
          long nl() 
          { 
              return Long.parseLong(next()); 
          } 
    
          double nd() 
          { 
              return Double.parseDouble(next()); 
          } 
    
          String nstr() 
          { 
              String str = ""; 
              try
              { 
                  str = br.readLine(); 
              } 
              catch (IOException e) 
              { 
                  e.printStackTrace(); 
              } 
              return str; 
          } 
      }
      
       
      static boolean checkbound(int x , int y , int m , int n){
          if(x<0 || x>=m || y<0 || y>=n)return false;
          return true;
      }
      static void printarr(int[][] a){
          int m = a.length , n = a[0].length;
          for(int i=0;i<m;i++){
              for(int j=0;j<n;j++){
                  System.out.print(a[i][j]+" ");
              }
              System.out.println();
          }
      }
      static void printarr(char[][] a){
          int m = a.length , n = a[0].length;
          for(int i=0;i<m;i++){
              for(int j=0;j<n;j++){
                  System.out.print(a[i][j]+" ");
              }
              System.out.println();
          }
      }
      static void printarr(int[] a){
          int n = a.length;
          StringBuilder sb = new StringBuilder();
              for(int j=0;j<n;j++){
                  sb.append(a[j]+" "); 
              }
              System.out.println(sb);
   
          
      }
      static void printarr(long[] a){
          int n = a.length;
          StringBuilder sb = new StringBuilder();
              for(int j=0;j<n;j++){
                  sb.append(a[j]+" "); 
              }
              System.out.println(sb);
   
          
      }
   
      static void revarr(int[] a ){
          int i=0,j=a.length-1;
          while(i<j){
              int tem = a[i];
              a[i]=a[j];
              a[j]=tem;
              i++;j--;
          }
           
      }
     
      
   
       static boolean[] sieveOfEratosthenes(int n)
      {
           
          boolean prime[] = new boolean[n + 1];
          for (int i = 0; i <= n; i++)
              prime[i] = true;
   
          for (int p = 2; p * p <= n; p++)
          {
               if (prime[p] == true)
              {
                   for (int i = p * p; i <= n; i += p)
                      prime[i] = false;
              }
          }
          prime[1]=false;
   
          return prime;
      }
   
      static int gcd(int a, int b)
      {
          if (a == 0)
              return b;
           
          return gcd(b%a, a);
      }
   
      static int lcm(int a, int b)
      {
          return (a / gcd(a, b)) * b;
      }
   
      static long gcd(long a, long b)
      {
          if (a == 0L)
              return b;
           
          return gcd(b%a, a);
      }
   
      static long lcm(long a, long b)
      {
          return (a / gcd(a, b)) * b;
      }
   
      public static class Pair{
          int x;
          int y;
   
          public Pair(int x, int y){
              this.x = x;
              this.y = y;
          }
   
           
      }
      
      
      static FastReader br=new FastReader();
  /*
   
  */
  ///////////////////////////////////////////////////////////
   
   
   
   
   
  
              
   
      }
      //end class  
   
      /* stuff you should look for
      * int overflow, array bounds
      * special cases (n=1?)
      * do smth instead of nothing and stay organized
      * WRITE STUFF DOWN
      * DON'T GET STUCK ON ONE APPROACH
    
   TC:
     
   
   
        */          
             
  