```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

const (
	MAX_C    = 200000
	MAX_M    = 1000
	MAX_TRI  = 700
	WORDSIZE = 64
	MAX_WORD = (MAX_C + WORDSIZE) / WORDSIZE
)

var tri []int
var isTri []bool
var isSum2 []bool
var dp [][]uint64

func init() {
	tri = make([]int, MAX_TRI+1)
	for i := 0; i <= MAX_TRI; i++ {
		tri[i] = i * (i + 1) / 2
	}

	isTri = make([]bool, MAX_C+1)
	for i := 0; i <= MAX_TRI; i++ {
		if tri[i] <= MAX_C {
			isTri[tri[i]] = true
		}
	}

	isSum2 = make([]bool, MAX_C+1)
	for i := 0; i <= MAX_TRI; i++ {
		for j := i; j <= MAX_TRI; j++ {
			s := tri[i] + tri[j]
			if s > MAX_C {
				break
			}
			isSum2[s] = true
		}
	}

	dp = make([][]uint64, MAX_M+1)
	dp[0] = make([]uint64, MAX_WORD)
	dp[0][0] = 1

	for m := 1; m <= MAX_M; m++ {
		bs := make([]uint64, MAX_WORD)
		for k := 1; k <= m; k++ {
			shift := tri[k-1]
			if shift > MAX_C {
				continue
			}
			wordShift := shift / WORDSIZE
			bitShift := shift % WORDSIZE
			src := dp[m-k]
			if bitShift == 0 {
				for i := 0; i+wordShift < MAX_WORD; i++ {
					bs[i+wordShift] |= src[i]
				}
			} else {
				for i := 0; i+wordShift < MAX_WORD; i++ {
					bs[i+wordShift] |= src[i] << bitShift
					if i+wordShift+1 < MAX_WORD {
						bs[i+wordShift+1] |= src[i] >> (WORDSIZE - bitShift)
					}
				}
			}
		}
		dp[m] = bs
	}
}

func isSet(bs []uint64, pos int) bool {
	return (bs[pos/WORDSIZE]>>uint(pos%WORDSIZE))&1 == 1
}

func findPartition(C, m int) ([]int, bool) {
	if C < 0 || C > m*(m-1)/2 {
		return nil, false
	}
	if m == 0 {
		if C == 0 {
			return []int{}, true
		}
		return nil, false
	}

	if m <= MAX_M {
		if !isSet(dp[m], C) {
			return nil, false
		}
		blocks := make([]int, 0)
		curM, curC := m, C
		for curM > 0 {
			for k := 1; k <= curM; k++ {
				need := tri[k-1]
				if curC >= need && isSet(dp[curM-k], curC-need) {
					blocks = append(blocks, k)
					curM -= k
					curC -= need
					break
				}
			}
		}
		return blocks, true
	}

	// Large m: use 3 triangular numbers (Gauss)
	// Also check 1 and 2 for efficiency
	blocks := make([]int, 0)
	rem := m

	if C == 0 {
		for i := 0; i < rem; i++ {
			blocks = append(blocks, 1)
		}
		return blocks, true
	}

	// Check 1 number
	for a := 0; a <= MAX_TRI && tri[a] <= C; a++ {
		if tri[a] == C {
			if a+1 <= m {
				return []int{a + 1}, true
			}
		}
	}

	// Check 2 numbers
	for a := 0; a <= MAX_TRI && tri[a] <= C; a++ {
		rem1 := C - tri[a]
		for b := 0; b <= MAX_TRI && tri[b] <= rem1; b++ {
			if tri[b] == rem1 {
				len := (a + 1) + (b + 1)
				if len <= m {
					blocks = append(blocks, a+1, b+1)
					for i := len; i < m; i++ {
						blocks = append(blocks, 1)
					}
					return blocks, true
				}
			}
		}
	}

	// Check 3 numbers
	for a := 0; a <= MAX_TRI && tri[a] <= C; a++ {
		rem1 := C - tri[a]
		for b := 0; b <= MAX_TRI && tri[b] <= rem1; b++ {
			rem2 := rem1 - tri[b]
			if rem2 > MAX_C {
				continue
			}
			if !isTri[rem2] {
				continue
			}
			for c := 0; c <= MAX_TRI; c++ {
				if tri[c] == rem2 {
					len := (a + 1) + (b + 1) + (c + 1)
					if len <= m {
						blocks = append(blocks, a+1, b+1, c+1)
						for i := len; i < m; i++ {
							blocks = append(blocks, 1)
						}
						return blocks, true
					}
					break
				}
			}
		}
	}

	return nil, false
}

func solve() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var t int
	fmt.Fscan(reader, &t)
	for tc := 0; tc < t; tc++ {
		var n, x, y, s int
		fmt.Fscan(reader, &n, &x, &y, &s)

		r := x % y
		q := x / y

		minSum := n * r
		if s < minSum || (s-minSum)%y != 0 {
			fmt.Fprintln(writer, "No")
			continue
		}

		B := (s - minSum) / y
		found := false

		// l is the length of the first block (before first mod, or whole sequence)
		maxL := n
		if q > 0 && B/q < maxL {
			maxL = B / q
		}

		for l := 1; l <= maxL && l <= n; l++ {
			contribution := l*q + tri[l-1]
			if contribution > B {
				break
			}
			C := B - contribution
			m := n - l

			blocks, ok := findPartition(C, m)
			if ok {
				found = true
				fmt.Fprintln(writer, "Yes")
				// Output the sequence
				// First l elements: x, x+y, ...
				for i := 0; i < l; i++ {
					if i > 0 {
						fmt.Fprint(writer, " ")
					}
					fmt.Fprint(writer, x+i*y)
				}
				// Suffix
				for _, blk := range blocks {
					for j := 0; j < blk; j++ {
						if l > 0 || blk > 0 || j > 0 {
							fmt.Fprint(writer, " ")
						}
						fmt.Fprint(writer, r+j*y)
					}
				}
				fmt.Fprintln(writer)
				break
			}
		}

		if !found {
			fmt.Fprintln(writer, "No")
		}
	}
}

func main() {
	solve()
}
```