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: 
  /**
  * @author: Prasad Chaudhari
  * @linkedIn: https://www.linkedin.com/in/prasad-chaudhari-841655a6/
  * @git: https://github.com/Prasad-Chaudhari
  */
  import java.io.BufferedReader;
  import java.io.BufferedWriter;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.OutputStreamWriter;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashSet;
  import java.util.LinkedList;
  import java.util.Set;
  import java.util.TreeSet;
  
  public class Main {
      public static void main(String args[]) throws Exception {
          FastIO in = new FastIO(args);
          int t = in.ni();
          while (t-- > 0) {
              int n = in.ni();
              int k = in.ni();
              int a[] = in.gia(n);
              ArrayList<LinkedList<Integer>> al = new ArrayList<>();
              for (int i = 0; i <= n; i++) {
                  al.add(new LinkedList<>());
              }
              for (int i = 0; i < n; i++) {
                  if (al.get(a[i]).size() < k)
                      al.get(a[i]).add(i);
              }
              int ans[] = new int[n];
              int index = 0;
              LinkedList<int[]> l = new LinkedList<>();
              for (int i = 1; i <= n; i++) {
                  while (!al.get(i).isEmpty()) {
                      l.add(new int[] { al.get(i).remove(), index + 1 });
                      index++;
                      index %= k;
                      if (l.size() == k) {
                          while (!l.isEmpty()) {
                              int p[] = l.remove();
                              ans[p[0]] = p[1];
                          }
                      }
                  }
              }
              for (int i = 0; i < n; i++)
                  System.out.print(ans[i] + " ");
              System.out.println();
          }
          in.bw.flush();
      }
  
      static class Data implements Comparable<Data> {
  
          int a, b;
  
          public Data(int a, int b) {
              this.a = a;
              this.b = b;
          }
  
          @Override
          public int compareTo(Data o) {
              if (a == o.a) {
                  return Integer.compare(b, o.b);
              }
              return Long.compare(a, o.a);
          }
  
          public static void sort(int a[]) {
              Data d[] = new Data[a.length];
              for (int i = 0; i < a.length; i++) {
                  d[i] = new Data(a[i], 0);
              }
              Arrays.sort(d);
              for (int i = 0; i < a.length; i++) {
                  a[i] = d[i].a;
              }
          }
      }
  
      static class FastIO {
  
          private final BufferedReader br;
          private final BufferedWriter bw;
          private String s[];
          private int index;
  
          public FastIO(String[] args) throws IOException {
              if (args.length > 1) {
                  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(args[0]))));
                  bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(args[1]))));
              } else {
                  br = new BufferedReader(new InputStreamReader(System.in));
                  bw = new BufferedWriter(new OutputStreamWriter(System.out, "UTF-8"));
              }
              s = br.readLine().split(" ");
              index = 0;
          }
  
          public int ni() throws IOException {
              return Integer.parseInt(nextToken());
          }
  
          public double nd() throws IOException {
              return Double.parseDouble(nextToken());
          }
  
          public long nl() throws IOException {
              return Long.parseLong(nextToken());
          }
  
          public String next() throws IOException {
              return nextToken();
          }
  
          public String nli() throws IOException {
              try {
                  return br.readLine();
              } catch (IOException ex) {
  
              }
              return null;
          }
  
          public int[] gia(int n) throws IOException {
              int a[] = new int[n];
              for (int i = 0; i < n; i++) {
                  a[i] = ni();
              }
              return a;
          }
  
          public int[] gia(int n, int start, int end) throws IOException {
              validate(n, start, end);
              int a[] = new int[n];
              for (int i = start; i < end; i++) {
                  a[i] = ni();
              }
              return a;
          }
  
          public double[] gda(int n) throws IOException {
              double a[] = new double[n];
              for (int i = 0; i < n; i++) {
                  a[i] = nd();
              }
              return a;
          }
  
          public double[] gda(int n, int start, int end) throws IOException {
              validate(n, start, end);
              double a[] = new double[n];
              for (int i = start; i < end; i++) {
                  a[i] = nd();
              }
              return a;
          }
  
          public long[] gla(int n) throws IOException {
              long a[] = new long[n];
              for (int i = 0; i < n; i++) {
                  a[i] = nl();
              }
              return a;
          }
  
          public long[] gla(int n, int start, int end) throws IOException {
              validate(n, start, end);
              long a[] = new long[n];
              for (int i = start; i < end; i++) {
                  a[i] = nl();
              }
              return a;
          }
  
          public void print(String s) throws IOException {
              bw.write(s);
          }
  
          public void println(String s) throws IOException {
              bw.write(s);
              bw.newLine();
          }
  
          public void print(int s) throws IOException {
              bw.write(s + "");
          }
  
          public void println(int s) throws IOException {
              bw.write(s + "");
              bw.newLine();
          }
  
          public void print(long s) throws IOException {
              bw.write(s + "");
          }
  
          public void println(long s) throws IOException {
              bw.write(s + "");
              bw.newLine();
          }
  
          public void print(double s) throws IOException {
              bw.write(s + "");
          }
  
          public void println(double s) throws IOException {
              bw.write(s + "");
              bw.newLine();
          }
  
          private String nextToken() throws IndexOutOfBoundsException, IOException {
              if (index == s.length) {
                  s = br.readLine().split(" ");
                  index = 0;
              }
              return s[index++];
          }
  
          private void validate(int n, int start, int end) {
              if (start < 0 || end >= n) {
                  throw new IllegalArgumentException();
              }
          }
      }
  }
  