import fractions
import math
import sys

from collections import Counter, defaultdict, deque

# https://raw.githubusercontent.com/cheran-senthil/PyRival/master/pyrival/data_structures/SegmentTree.py
class SegmentTree:
    def __init__(self, data, default=0, func=max):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size : _size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        """func of data[start, stop)"""
        start += self._size
        stop += self._size

        res_left = res_right = self._default
        while start < stop:
            if start & 1:
                res_left = self._func(res_left, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res_right = self._func(self.data[stop], res_right)
            start >>= 1
            stop >>= 1

        return self._func(res_left, res_right)


from bisect import bisect_left, bisect_right

def solve(N,K,A):
    Asorted = sorted(A)
    compress = {}
    for i, x in enumerate(Asorted):
        compress[x] = i

    forward = SegmentTree([0] * N, 0, max)
    backward = SegmentTree([0] * N, 0, max)
    for i, x in enumerate(Asorted):
        j = bisect_right(Asorted, x - K)
        forward[i] = forward.query(0, j) + 1
    for i in range(N)[::-1]:
        x = Asorted[i]
        j = bisect_left(Asorted, x + K)
        backward[i] = backward.query(j, N) + 1

    ans = []
    for x in A:
        i = compress[x]
        ans.append(forward[i] + backward[i] - 1)


    return ' '.join(map(str, ans))


if __name__ == "__main__":
    T = int(input())
    for t in range(1, T + 1):
        (N,K) = [int(x) for x in input().split()]
        A= [int(x) for x in input().split()]
        ans = solve(N,K,A)
        print("Case #" + str(t) + ": " + str(ans))