```go
package main

import (
	"io"
	"os"
	"sort"
	"strconv"
)

type FastScanner struct {
	data []byte
	idx  int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data}
}

func (fs *FastScanner) NextInt64() int64 {
	n := len(fs.data)
	for fs.idx < n && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
	sign := int64(1)
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	var v int64
	for fs.idx < n {
		b := fs.data[fs.idx]
		if b < '0' || b > '9' {
			break
		}
		v = v*10 + int64(b-'0')
		fs.idx++
	}
	return sign * v
}

func upperBound(a []int64, l, r int, val int64) int {
	if l > r {
		return l - 1
	}
	pos := sort.Search(r-l+1, func(i int) bool {
		return a[l+i] > val
	})
	return l + pos - 1
}

func solveLargestBlock(v []int64, k int64, res *[]int64) {
	m := len(v)
	if m == 0 {
		return
	}
	*res = append(*res, v[0])
	if m == 1 {
		return
	}
	prevVal := v[0]
	l, r := 1, m-1
	for l <= r {
		if l == r {
			*res = append(*res, v[l])
			break
		}
		currentVal := prevVal
		u := l
		p := l
		chosen := make([]int, 0)
		for u < r {
			reach := upperBound(v, u, r-1, currentVal+k)
			cand := -1
			if p == u && u <= reach {
				cand = u
			}
			if reach > p {
				limit2 := upperBound(v, p+1, r, v[p]+k)
				up2 := reach
				if limit2-1 < up2 {
					up2 = limit2 - 1
				}
				low := u
				if p+1 > low {
					low = p + 1
				}
				if up2 >= low && up2 > cand {
					cand = up2
				}
			}
			if cand == -1 {
				break
			}
			*res = append(*res, v[cand])
			chosen = append(chosen, cand)
			currentVal = v[cand]
			if cand == p {
				p++
			}
			u = cand + 1
		}
		ptr := len(chosen) - 1
		for i := u - 1; i >= l; i-- {
			if ptr >= 0 && chosen[ptr] == i {
				ptr--
			} else {
				*res = append(*res, v[i])
			}
		}
		if p < u {
			prevVal = v[p]
		} else {
			prevVal = currentVal
		}
		l = u
	}
}

func appendSeq(out []byte, seq []int64, negate bool) []byte {
	for i, v := range seq {
		if negate {
			v = -v
		}
		out = strconv.AppendInt(out, v, 10)
		if i+1 == len(seq) {
			out = append(out, '\n')
		} else {
			out = append(out, ' ')
		}
	}
	return out
}

func main() {
	fs := NewFastScanner()
	t := int(fs.NextInt64())
	out := make([]byte, 0, 1<<20)
	for ; t > 0; t-- {
		n := int(fs.NextInt64())
		c := fs.NextInt64()
		a := make([]int64, n)
		for i := 0; i < n; i++ {
			a[i] = fs.NextInt64()
		}
		if c >= 0 {
			sort.Slice(a, func(i, j int) bool { return a[i] < a[j] })
			out = appendSeq(out, a, false)
		} else {
			k := -c
			x := make([]int64, n)
			for i := 0; i < n; i++ {
				x[i] = -a[i]
			}
			sort.Slice(x, func(i, j int) bool { return x[i] < x[j] })
			res := make([]int64, 0, n)
			for l := 0; l < n; {
				r := l
				for r+1 < n && x[r+1]-x[r] <= k {
					r++
				}
				solveLargestBlock(x[l:r+1], k, &res)
				l = r + 1
			}
			out = appendSeq(out, res, true)
		}
	}
	_, _ = os.Stdout.Write(out)
}
```