package main

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

type FastScanner struct {
	data []byte
	idx  int
}

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

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

func feasible(a []int64, n int, k int64, x int64, R int64) bool {
	if R == 0 {
		return int64(x+1) >= k
	}
	rad := R - 1
	var count int64 = 0
	have := false
	var L, Rr int64
	for i := 0; i < n; i++ {
		l := a[i] - rad
		if l < 0 {
			l = 0
		}
		r := a[i] + rad
		if r > x {
			r = x
		}
		if !have {
			L, Rr = l, r
			have = true
			if L > 0 {
				count += L
				if count >= k {
					return true
				}
			}
		} else {
			if l <= Rr+1 {
				if r > Rr {
					Rr = r
				}
			} else {
				gap := l - Rr - 1
				if gap > 0 {
					count += gap
					if count >= k {
						return true
					}
				}
				L, Rr = l, r
			}
		}
	}
	if have {
		tail := x - Rr
		if tail > 0 {
			count += tail
			if count >= k {
				return true
			}
		}
	} else {
		return int64(x+1) >= k
	}
	return count >= k
}

func generatePositions(a []int64, n int, k int64, x int64, R int64) []int64 {
	ans := make([]int64, 0, k)
	if R == 0 {
		for p := int64(0); int64(len(ans)) < k; p++ {
			ans = append(ans, p)
		}
		return ans
	}
	rad := R - 1
	have := false
	var Rr int64
	addRange := func(start, end int64) {
		for p := start; p <= end && int64(len(ans)) < k; p++ {
			ans = append(ans, p)
		}
	}
	for i := 0; i < n && int64(len(ans)) < k; i++ {
		l := a[i] - rad
		if l < 0 {
			l = 0
		}
		r := a[i] + rad
		if r > x {
			r = x
		}
		if !have {
			if l > 0 {
				addRange(0, l-1)
			}
			Rr = r
			have = true
		} else {
			if l <= Rr+1 {
				if r > Rr {
					Rr = r
				}
			} else {
				addRange(Rr+1, l-1)
				Rr = r
			}
		}
	}
	if int64(len(ans)) < k {
		if have {
			if Rr+1 <= x {
				addRange(Rr+1, x)
			}
		} else {
			addRange(0, x)
		}
	}
	if int64(len(ans)) > k {
		ans = ans[:k]
	}
	return ans
}

func main() {
	in := NewFastScanner()
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	t := int(in.NextInt64())
	var sb strings.Builder
	for ; t > 0; t-- {
		n := int(in.NextInt64())
		k := in.NextInt64()
		x := in.NextInt64()
		a := make([]int64, n)
		for i := 0; i < n; i++ {
			a[i] = in.NextInt64()
		}
		sort.Slice(a, func(i, j int) bool { return a[i] < a[j] })

		lo := int64(0)
		hi := x
		for lo < hi {
			mid := (lo + hi + 1) >> 1
			if feasible(a, n, k, x, mid) {
				lo = mid
			} else {
				hi = mid - 1
			}
		}
		R := lo
		pos := generatePositions(a, n, k, x, R)
		for i := 0; i < len(pos); i++ {
			if i > 0 {
				sb.WriteByte(' ')
			}
			sb.WriteString(strconv.FormatInt(pos[i], 10))
		}
		sb.WriteByte('\n')
	}
	out.WriteString(sb.String())
}