```go
package main

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

func minDepthSum(n int) int {
	if n <= 1 {
		return 0
	}
	rem := n - 1
	prev := 1
	depth := 1
	sum := 0
	for rem > 0 {
		take := prev * 2
		if take > rem {
			take = rem
		}
		sum += depth * take
		rem -= take
		prev = take
		depth++
	}
	return sum
}

func minSuffix(rem, startCount, startDepth int) int {
	if rem == 0 {
		return 0
	}
	if startCount == 0 {
		return 1 << 60
	}
	sum := 0
	cur := startCount
	d := startDepth
	left := rem
	for left > 0 {
		take := cur * 2
		if take > left {
			take = left
		}
		sum += d * take
		left -= take
		cur = take
		d++
	}
	return sum
}

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

	var t int
	if _, err := fmt.Fscan(in, &t); err != nil {
		return
	}
	for ; t > 0; t-- {
		var n, d int
		fmt.Fscan(in, &n, &d)

		smin := minDepthSum(n)
		smax := n * (n - 1) / 2
		if d < smin || d > smax {
			fmt.Fprintln(out, "NO")
			continue
		}

		counts := []int{1}
		sumSoFar := 0
		pc := 1
		rem := n - 1
		depth := 1
		ok := true

		for rem > 0 && ok {
			cap := pc * 2
			if cap > rem {
				cap = rem
			}
			chosen := -1
			for x := 0; x <= cap; x++ {
				sumNow := sumSoFar + depth*x
				remAfter := rem - x
				if remAfter == 0 {
					if sumNow == d {
						chosen = x
						break
					} else {
						continue
					}
				}
				if x == 0 {
					continue
				}
				minS := minSuffix(remAfter, x, depth+1)
				maxS := remAfter*depth + remAfter*(remAfter+1)/2
				totalMin := sumNow + minS
				totalMax := sumNow + maxS
				if d >= totalMin && d <= totalMax {
					chosen = x
					break
				}
			}
			if chosen == -1 {
				ok = false
				break
			}
			counts = append(counts, chosen)
			pc = chosen
			sumSoFar += depth * chosen
			rem -= chosen
			depth++
		}

		if !ok {
			fmt.Fprintln(out, "NO")
			continue
		}

		parents := make([]int, n+1)
		levels := make([][]int, len(counts))
		levels[0] = []int{1}
		id := 2
		for i := 0; i+1 < len(counts); i++ {
			k := counts[i+1]
			if k == 0 {
				levels[i+1] = []int{}
				continue
			}
			par := levels[i]
			children := make([]int, 0, k)
			need := k
			for _, p := range par {
				if need == 0 {
					break
				}
				// up to two children per parent
				for c := 0; c < 2 && need > 0; c++ {
					parents[id] = p
					children = append(children, id)
					id++
					need--
				}
			}
			levels[i+1] = children
		}

		fmt.Fprintln(out, "YES")
		for i := 2; i <= n; i++ {
			if i > 2 {
				fmt.Fprint(out, " ")
			}
			fmt.Fprint(out, parents[i])
		}
		fmt.Fprintln(out)
	}
}
```