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.io.*;
import java.util.*;


public class  Main{
	public static void main(String[] args) throws Exception{
		MScanner sc=new MScanner(System.in);
		PrintWriter pw=new PrintWriter(System.out);
		int tc=sc.nextInt();
		while(tc-->0) {
			int n=sc.nextInt(),d=sc.nextInt();
			long max=((n-1)*n)/2;
			long min=0;
			int nodes=n-1;
			int lvl=1;long cnt=2;
			while(true) {
				if(cnt>nodes) {
					long inc=lvl*1l*nodes;
					min+=inc;
					break;
				}
				long inc=lvl*1l*cnt;
				min+=inc;
				nodes-=cnt;
				lvl++;
				cnt*=2;
			}
			if(d<min || d>max) {
				pw.println("NO");
			}
			else {
				pw.println("YES");
				LinkedList<Integer>[]levels=new LinkedList[n];
				long[]cap=new long[n];
				
				for(int i=0;i<n;i++) {
					levels[i]=new LinkedList<Integer>();
					levels[i].add(i);
					cap[i]=i==0?1:(cap[i-1]*2l);
				}
				int cmax=n-1,cmin=1;
				while(true) {
					long dif=cmax-cmin;
					if(max-dif<=d) {
						dif=max-d;
						levels[(int)(cmax-dif)].add(levels[cmax].poll());
						break;
					}
					else {
						levels[cmin].add(levels[cmax].poll());
						if(levels[cmin].size()==cap[cmin]) {
							cmin++;
						}
					}
					cmax--;
					max-=dif;
				}
				int[]par=new int[n];
				int[]children=new int[n];
				for(int i=n-1;i>=1;i--) {
					if(levels[i].size()==0)continue;
					int[]parents=new int[levels[i-1].size()];
					int o=0;
					
					for(int j:levels[i-1]) {
						parents[o++]=j;
					}
					o=0;
					for(int j:levels[i]) {
						int curP=parents[o];
						par[j]=curP;
						children[curP]++;
						if(children[curP]==2)o++;
					}
				}
				for(int i=1;i<n;i++)pw.print((par[i]+1)+" ");
				pw.println();
			}
		}
		
		pw.flush();
	}
	static class MScanner {
		StringTokenizer st;
		BufferedReader br;
		public MScanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}
 
		public MScanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}
 
		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public int[] takearr(int n) throws IOException {
	        int[]in=new int[n];for(int i=0;i<n;i++)in[i]=nextInt();
	        return in;
		}
		public long[] takearrl(int n) throws IOException {
	        long[]in=new long[n];for(int i=0;i<n;i++)in[i]=nextLong();
	        return in;
		}
		public Integer[] takearrobj(int n) throws IOException {
	        Integer[]in=new Integer[n];for(int i=0;i<n;i++)in[i]=nextInt();
	        return in;
		}
		public Long[] takearrlobj(int n) throws IOException {
	        Long[]in=new Long[n];for(int i=0;i<n;i++)in[i]=nextLong();
	        return in;
		}
		public String nextLine() throws IOException {
			return br.readLine();
		}
 
		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
 
		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}
 
		public char nextChar() throws IOException {
			return next().charAt(0);
		}
 
		public Long nextLong() throws IOException {
			return Long.parseLong(next());
		}
 
		public boolean ready() throws IOException {
			return br.ready();
		}
 
		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
}