Problem: You are given two integers n and d. You need to construct a rooted binary tree consisting of n vertices with a root at the vertex 1 and the sum of depths of all vertices equals to d.

A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a vertex v is the last different from v vertex on the path from the root to the vertex v. The depth of the vertex v is the length of the path from the root to the vertex v. Children of vertex v are all vertices for which v is the parent. The binary tree is such a tree that no vertex has more than 2 children.

You have to answer t independent test cases.

Input

The first line of the input contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.

The only line of each test case contains two integers n and d (2 ≤ n, d ≤ 5000) — the number of vertices in the tree and the required sum of depths of all vertices.

It is guaranteed that the sum of n and the sum of d both does not exceed 5000 (∑ n ≤ 5000, ∑ d ≤ 5000).

Output

For each test case, print the answer.

If it is impossible to construct such a tree, print "NO" (without quotes) in the first line. Otherwise, print "{YES}" in the first line. Then print n-1 integers p_2, p_3, ..., p_n in the second line, where p_i is the parent of the vertex i. Note that the sequence of parents you print should describe some binary tree.

Example

Input


3
5 7
10 19
10 18


Output


YES
1 2 1 3 
YES
1 2 3 3 9 9 2 1 6 
NO

Note

Pictures corresponding to the first and the second test cases of the example:

<image>

<image>

Solution (in PYTHON3):

Solution:
# 3/2/2020, 8:23 PM

# edited to just edit the parent array 





import math 
import sys
import operator



# note that we will only increase the depth of a node, never decrease
def raise_d(parent):
	# find the deepest depth that has more than one vertex
	just_parent = [i for i, j in parent]
	for deep in range(n - 1, -1, -1):
		if depth_track[deep] >= 2:
			break 
	deep_nodes = []
	c = 0
	for p, depth in parent[::-1]:
		if depth == deep:
			deep_nodes.append(n - c)
		if len(deep_nodes) == 2:
			break 
		c += 1

	# deep_nodes contains vertices at depth = deep
	for NC in deep_nodes:
		if just_parent.count(NC) == 0:
			C ,= [x for x in deep_nodes if x != NC]
			break 

	# now we have NC with at most one child and C the other node
	# we just have to move NC to be a child of C
	parent[NC] = C, deep + 1
	depth_track[deep + 1] += 1
	depth_track[deep] -= 1

	return parent 





T = int(input())

for _ in range(T):
	# 2 cases: one where we use as little vertices and 
	# another where we fill us levels are much as we can 
	n, d = map(int, input().split())

	# upper bound 
	ub = n*(n - 1)//2

	# calculating the lower bound
	count = n 
	depth = 0
	lb = 0
	while count > 0:
		depth_count = 2**depth
		fill = min(count, depth_count)
		count -= fill 
		lb += fill*depth 
		depth += 1

	# testing d against bounds
	if not (lb <= d <= ub):
		print ('NO')
		continue

	# create an array to keep track of how many nodes are at each depth 
	depth_track = [0]*(n)
	# create the parent array for lower bound
	parent = [(-1, -1) for i in range(n + 1)]
	for i in range(1, n + 1):
		if i % 2 == 1:
			p = (i - 1)//2
			depth = len(bin(i)) - 3
			parent[i] = (p, depth)
			depth_track[depth] += 1
		else:
			p = i//2
			depth = len(bin(i)) - 3
			parent[i] = (p, depth)
			depth_track[depth] += 1


	for i in range(d - lb):
		parent = raise_d(parent)


	print ('YES')
	# making an array so that vertex v at index v - 1 has its parent node there
	parent = [p for p, depth in parent if depth != 0 and depth != -1]
	print (*parent)