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: import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.Scanner;
  import java.util.StringTokenizer;
  import java.io.*;
  import java.util.*;
  import java.text.DecimalFormat;
  import java.math.*;
  
  public class Main {
  
  static int  mod = 1000000007;
  /*****************code By Priyanshu *******************************************/ 
  
      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 nextInt() { return Integer.parseInt(next()); }
  
          long nextLong() { return Long.parseLong(next()); }
  
  
  
          double nextDouble()
          {
              return Double.parseDouble(next());
          }
  
          String nextLine()
          {
              String str = "";
              try {
                  str = br.readLine();
              }
              catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
      // this > other return +ve
      // this < other return -ve
      // this == other return 0
       public static class Pair implements Comparable<Pair> {
        long st;
        long et;
  
        public Pair(long st, long et) {
           this.st = st;
           this.et = et;
        }
  
        public int compareTo(Pair other) {
           if (this.st != other.st) {
              return (int)(this.st - other.st);
           } else {
              return (int)(this.et - other.et);
           }
        }
     }
  
      static long fastPower(long a, long b, int n) {
              
              long res = 1;
              
              while ( b > 0) {
                  
                  if ( (b&1) != 0) {
                      res = (res * a % n) % n;
                  }
                  
                  a = (a % n * a % n) % n;
                  b =  b >> 1;
              }
              
              return res;
              
          }
  
       // function to find
      // the rightmost set bit
      static int PositionRightmostSetbit(int n)
      {
          // Position variable initialize
          // with 1 m variable is used to
          // check the set bit
          int position = 1;
          int m = 1;
   
          while ((n & m) == 0) {
   
              // left shift
              m = m << 1;
              position++;
          }
          return position;
      }
      
           // used for swapping ith and jth elements of array
        // public static void swap(int[] arr, int i, int j) {
        //   int temp = arr[i];
        //   arr[i] = arr[j];
        //   arr[j] = temp;
        // }
          public static void swap(long i, long j) {
          long temp = i;
          i = j;
          j = temp;
        }
  
  
      static boolean palindrome(String s) {
          return new StringBuilder(s).reverse().toString().equals(s);
      }
      
    static boolean isPerfectSquare(double x)
      {
              double sr = Math.sqrt(x);
              return ((sr * sr) == x);     
      }
  
  
   public static long gcd(long a, long b)
      {
        if (b == 0)
          return a;
        return gcd(b, a % b);
      }
      
     
  
     static int nod(long l) {
         if(l>=1000000000000000000l) return 19;
         if(l>=100000000000000000l) return 18;
         if(l>=10000000000000000l) return 17;
         if(l>=1000000000000000l) return 16;
         if(l>=100000000000000l) return 15;
         if(l>=10000000000000l) return 14;
         if(l>=1000000000000l) return 13;
         if(l>=100000000000l) return 12;
         if(l>=10000000000l) return 11;
         if(l>=1000000000) return 10;
         if(l>=100000000) return 9;
         if(l>=10000000) return 8;
         if(l>=1000000) return 7;
         if(l>=100000) return 6;
         if(l>=10000) return 5;
         if(l>=1000) return 4;
         if(l>=100) return 3;
         if(l>=10) return 2;
         return 1;
      }
        //Arrays.sort(a,(c,d) -> Integer.compare(c[0],d[0]));
  
      
      public static boolean areAllBitsSet(int n )
      {
          // all bits are not set
          if (n == 0)
              return false;
       
          // if true, then all bits are set
          if (((n + 1) & n) == 0)
              return true;
       
          // else all bits are not set
          return false;
      }
  
       public static long[] sort(long[] arr) {
          List<Long> temp = new ArrayList();
          for (long i : arr) temp.add(i);
          Collections.sort(temp);
          int start = 0;
          for (long i : temp) arr[start++] = i;
          return arr;
      }
     
   
  
          public static int[] radixSort2(int[] a)
      {
          int n = a.length;
          int[] c0 = new int[0x101];
          int[] c1 = new int[0x101];
          int[] c2 = new int[0x101];
          int[] c3 = new int[0x101];
          for(int v : a) {
              c0[(v&0xff)+1]++;
              c1[(v>>>8&0xff)+1]++;
              c2[(v>>>16&0xff)+1]++;
              c3[(v>>>24^0x80)+1]++;
          }
          for(int i = 0;i < 0xff;i++) {
              c0[i+1] += c0[i];
              c1[i+1] += c1[i];
              c2[i+1] += c2[i];
              c3[i+1] += c3[i];
          }
          int[] t = new int[n];
          for(int v : a)t[c0[v&0xff]++] = v;
          for(int v : t)a[c1[v>>>8&0xff]++] = v;
          for(int v : a)t[c2[v>>>16&0xff]++] = v;
          for(int v : t)a[c3[v>>>24^0x80]++] = v;
          return a;
      } 
  
    
  
  
   
  
  
      public static void main(
          String[] args)
      {
          try {
              System.setIn(new FileInputStream("input.txt"));
              System.setOut(new PrintStream(new FileOutputStream("output.txt")));
          } catch (Exception e) {
              System.err.println("Error");
          }
           
         FastReader sc = new FastReader();
          int t = Integer.parseInt(sc.next());
        // int t = 1;
          StringBuilder ans = new StringBuilder();
          
     while(t-->0){
          int n = sc.nextInt();
          int k = sc.nextInt();
  
          HashMap<Integer,Deque<Integer>> map = new HashMap<>();
  
          int a[] = new int[n];
          int notColor = 0;
          for (int i = 0;i<n;i++) {
              a[i] = sc.nextInt();
              Deque<Integer> l = map.getOrDefault(a[i], new ArrayDeque<>());
              if(l.size() < k ){
                  l.add(i);
              }else{
                  notColor++;
              }
  
              map.put(a[i],l);
              
          }
  
          int total =  (n - notColor)/k * k;
  
          int[] res = new int[n];
          int c = 0; //colour to color
          for(Deque<Integer> l : map.values()){
              while(l.size() > 0 && total-- > 0){
                  int val = l.pop();
                  res[val]  = c+1;
                  c = (++c)%k;
              }
          }
  
          for (int v : res) {
                  ans.append(v);
                  ans.append(" ");
              }
              ans.append("\n");
          
        
             
      }
  
      System.out.println(ans);
    }
  }
  //code By Priyanshu 
  