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 os
  import sys
  from io import BytesIO, IOBase
  import math
  from queue import Queue
  import collections
  import itertools
  import bisect
  import heapq
  # sys.setrecursionlimit(100000)
  # ^^^TAKE CARE FOR MEMORY LIMIT^^^
  import random
  
  
  def main():
      pass
  
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  
  def binary(n):
      return (bin(n).replace("0b", ""))
  
  
  def decimal(s):
      return (int(s, 2))
  
  
  def pow2(n):
      p = 0
      while (n > 1):
          n //= 2
          p += 1
      return (p)
  
  
  def primeFactors(n):
      cnt = []
      while n % 2 == 0:
          cnt.append(2)
          n = n / 2
      for i in range(3, int(math.sqrt(n)) + 1, 2):
          while n % i == 0:
              cnt.append(i)
              n = n / i
      if n > 2:
          cnt.append(int(n))
      return (cnt)
  
  def primeFactorsCount(n):
      cnt=0
      while n % 2 == 0:
          cnt+=1
          n = n // 2
      for i in range(3, int(math.sqrt(n)) + 1, 2):
          while n % i == 0:
              cnt+=1
              n = n // i
      if n > 2:
          cnt+=1
      return (cnt)
  
  def isPrime(n):
      if (n == 1):
          return (False)
      else:
          root = int(n ** 0.5)
          root += 1
          for i in range(2, root):
              if (n % i == 0):
                  return (False)
          return (True)
  
  
  def maxPrimeFactors(n):
      maxPrime = -1
      while n % 2 == 0:
          maxPrime = 2
          n >>= 1
      for i in range(3, int(math.sqrt(n)) + 1, 2):
          while n % i == 0:
              maxPrime = i
              n = n / i
      if n > 2:
          maxPrime = n
      return int(maxPrime)
  
  
  def countcon(s, i):
      c = 0
      ch = s[i]
      for i in range(i, len(s)):
          if (s[i] == ch):
              c += 1
          else:
              break
      return (c)
  
  
  def lis(arr):
      n = len(arr)
      lis = [1] * n
      for i in range(1, n):
          for j in range(0, i):
              if arr[i] > arr[j] and lis[i] < lis[j] + 1:
                  lis[i] = lis[j] + 1
      maximum = 0
      for i in range(n):
          maximum = max(maximum, lis[i])
      return maximum
  
  
  def isSubSequence(str1, str2):
      m = len(str1)
      n = len(str2)
      j = 0
      i = 0
      while j < m and i < n:
          if str1[j] == str2[i]:
              j = j + 1
          i = i + 1
      return j == m
  
  
  def maxfac(n):
      root = int(n ** 0.5)
      for i in range(2, root + 1):
          if (n % i == 0):
              return (n // i)
      return (n)
  
  
  def p2(n):
      c = 0
      while (n % 2 == 0):
          n //= 2
          c += 1
      return c
  
  
  def seive(n):
      primes = [True] * (n + 1)
      primes[1] = primes[0] = False
      i = 2
      while (i * i <= n):
          if (primes[i] == True):
              for j in range(i * i, n + 1, i):
                  primes[j] = False
          i += 1
      pr = []
      for i in range(0, n + 1):
          if (primes[i]):
              pr.append(i)
      return pr
  
  
  def ncr(n, r, p):
      num = den = 1
      for i in range(r):
          num = (num * (n - i)) % p
          den = (den * (i + 1)) % p
      return (num * pow(den,
                        p - 2, p)) % p
  
  
  def denofactinverse(n, m):
      fac = 1
      for i in range(1, n + 1):
          fac = (fac * i) % m
      return (pow(fac, m - 2, m))
  
  
  def numofact(n, m):
      fac = 1
      for i in range(1, n + 1):
          fac = (fac * i) % m
      return (fac)
  
  def sod(n):
      s = 0
      while (n > 0):
          s += n % 10
          n //= 10
      return s
  '''for xyz in range(0,int(input())):
      n,k=map(int,input().split())
      l=list(map(int,input().split()))
      cnt=[0]*(max(l)+1)
      for i in l:
          cnt[i]+=1
      #print(cnt)
      val=0
      for i in cnt:
          val+=min(i,k)
      #print(val)
      maxC=val//k
      #print(maxC)
      exc=n-maxC*k
      tbv=[0]*(1+max(l))
      for i in range(0,len(cnt)):
          tbv[i]=min(cnt[i],k)
          exc-=cnt[i]-tbv[i]
      print(exc)
      prevcnt=0
      prevCol=0
      col=[1]*(len(cnt))
      for i in set(l):
          currCol=((prevcnt+prevCol)%k)+1
          col[i]=currCol
          prevCol=currCol
          prevcnt=tbv[i]
      #print(col)
      ans=[]
      for i in range(0,n):
          val=l[i]
          if(tbv[val]==0):
              ans.append(0)
          else:
              ans.append(col[val])
              col[val]=(col[val])%(k)+1
              tbv[val]-=1
      print(*ans)'''
  for xyz in range(0,int(input())):
      n,k=map(int,input().split())
      l=list(map(int,input().split()))
      MA=max(l)
      pos=[[] for i in range(0,MA+1)]
      tc=0
      for i in range(0,n):
          if(len(pos[l[i]])<k):
              pos[l[i]].append(i)
              tc+=1
      col=[[]for i in range(0,k)]
      trim=tc%k
      cc=0
      for i in range(0,len(pos)):
          cl=pos[i]
          for j in range(0,len(cl)):
              if(trim>0):
                  trim-=1
                  continue
              col[cc].append(pos[i][j])
              cc=(cc+1)%k
      ans=[0]*n
      for i in range(0,len(col)):
          cuco=i+1
          cl=col[i]
          for j in cl:
              ans[j]=cuco
      print(*ans)