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>
import java.util.Scanner;
import java.util.Stack;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Comparator;
import java.util.LinkedList;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.FileWriter;

public class E{
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		int t = in.nextInt();
		StringBuilder res = new StringBuilder();
		for(int u = 0;u<t;++u){
			int n = in.nextInt();
			int d = in.nextInt();
			int mindeep = 0;
			for(int i = 0, layer = 1, count = 0;count<n;){
				mindeep +=  layer * i;
				if(layer + count > n){
					mindeep -= (layer + count - n) *i;
				}
				count += layer;
				layer = layer*2;
				i++;
			}
			// System.out.println(mindeep);
			if(mindeep > d  || d > n*(n-1)/2){
				res.append("NO\n");
				continue;
			}
			res.append("YES\n");
			int sumdepth = n*(n-1)/2;
			int[] stepen = new int[15];
			stepen[0] = 1;
			for(int i = 1;i<15;++i)
				stepen[i] = stepen[i-1] * 2;
			// int[] chilCount = new int[n+1];
			// int[] par = new in[n+1];
			int[] depthCount = new int[n];
			for(int i = 0;i<n;++i)
				depthCount[i] = 1;
			int i = n-1;
			int mindepth = 1;
			while(sumdepth > d){
				int dif = i - mindepth;
				if(sumdepth - d <=dif){
					depthCount[i]--;
					depthCount[i - sumdepth + d]++;
					break;
				}
				depthCount[i]--;
				depthCount[mindepth]++;
				sumdepth -= i - mindepth;
				if(depthCount[mindepth] == stepen[mindepth])
					mindepth++;
				i--;
			}
			int[] par = new int[n+1];
			int[] depth = new int[n+1];
			int[] children = new int[n+1];
			// System.out.println(Arrays.toString(depthCount));
			depth[1] = 1;
			LinkedList<Integer> queue = new LinkedList<>();
			queue.offer(1);
			depthCount[0]--;
			depth[1] = 0;
			int curdepth = 1;
			// int edge = 2;
			for(i = 2;i <= n;++i){
				// System.out.println(i + " " + queue);
				if(depthCount[curdepth] == 0) curdepth++;
				while(queue.size() > 0 && (depth[queue.peek()] + 1< curdepth || children[queue.peek()] == 2)) queue.poll();
				depthCount[curdepth]--;
				par[i] = queue.peek();
				children[queue.peek()]++;
				depth[i] = depth[queue.peek()]+1;
				queue.offer(i);
			}
			System.out.println();
			for(i = 2;i<=n;++i)
				res.append(par[i] + " ");
			res.append("\n");
		}
		System.out.println(res);
	}
}