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, \dots, 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:

each element of the sequence is either painted in one of $k$ colors or isn't painted;

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);

let's calculate for each of $k$ colors the number of elements painted in the color — all calculated numbers must be equal;

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.

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 \le t \le 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 \le n \le 2\cdot10^5$, $1 \le k \le n$) — the length of a given sequence and the number of colors, respectively. The second one contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le n$).

It is guaranteed that the sum of $n$ over all test cases doesn't exceed $2 \cdot 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, \dots, c_n$ ($0 \le c_i \le 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.


-----Examples-----

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$.

Difficulty: MEDIUM

Solutions:
import sys
import math
import collections
dy = [1, 0, -1, 0]
dx = [0, 1, 0, -1]
r = sys.stdin.readline
for _ in range(int(r())):
	(N, K) = map(int, r().split())
	L = list(map(int, r().split()))
	LL = []
	ans = [0] * (N + 1)
	d = {}
	can = 0
	for i in range(N):
		LL.append([L[i], i])
		try:
			d[L[i]] += 1
		except:
			d[L[i]] = 1
		if d[L[i]] <= K:
			can += 1
	can //= K
	can -= 1
	LL.sort()
	dic = {}
	idx = 1
	for i in range(N):
		try:
			dic[LL[i][0]] += 1
		except:
			dic[LL[i][0]] = 1
		if dic[LL[i][0]] > K:
			continue
		ans[LL[i][1]] = idx
		if idx >= K:
			if can:
				can -= 1
				idx = 0
			else:
				break
		idx += 1
	for i in range(N):
		print(ans[i], end=' ')
	print()


NUM = int(input())
for T in range(0, NUM):
	(n, k) = map(int, input().split())
	vallist = list(map(int, input().split()))
	answer = [0] * n
	countnum = [[] for i in range(0, n)]
	for i in range(0, n):
		countnum[vallist[i] - 1].append(i)
	ans = 0
	for i in range(0, n):
		ans += min(k, len(countnum[i]))
	ans //= k
	current = 0
	for i in countnum:
		for j in range(0, min(k, len(i))):
			if ans:
				answer[i[j]] = current + 1
				current = (current + 1) % k
				ans -= current == 0
	for i in answer:
		print(i, end=' ')
	print('')


import sys
N = int(200000.0 + 5)
sys.setrecursionlimit(N)

def charming():
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	b = list(zip(a, range(n)))
	b.sort(key=lambda x: x[0])
	cnt = 0
	color = [0] * n
	c = 1
	stk = list()
	for i in range(n):
		if i == 0 or b[i - 1][0] != b[i][0]:
			cnt = 1
		else:
			cnt += 1
		if cnt > k:
			continue
		else:
			color[b[i][1]] = (c - 1) % k + 1
			c += 1
			stk.append(i)
	c = (c - 1) % k + 1
	siz = len(stk)
	for i in range(siz - (c - 1), siz):
		color[b[stk[i]][1]] = 0
	for i in color:
		print(i, end=' ')
	print()
for t in range(int(input())):
	charming()


R = lambda : map(int, input().split())
p = print
t = 1
(t,) = R()
alpali = list(map(chr, range(97, 123)))

def solve():
	(n, k) = R()
	li = list(enumerate(list(R())))
	li.sort(key=lambda x: x[1])
	di = {}
	lia = [0] * len(li)
	cnt = 1
	for i in range(len(li)):
		if di.get(li[i][1], 0) < k:
			lia[li[i][0]] = cnt
			di[li[i][1]] = di.get(li[i][1], 0) + 1
			cnt += 1
			if cnt == k + 1:
				cnt = 1
		if i == len(li) - 1:
			j = i
			while j >= 0 and lia[li[j][0]] != k:
				lia[li[j][0]] = 0
				j -= 1
	for a in lia:
		p(a, end=' ')
	p()
while t:
	t -= 1
	solve()