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>
/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;


/* Name of the class has to be "Main" only if the class is public. */
public class p5
{
         static class Input {
        private StringTokenizer tokenizer = null;
        private BufferedReader reader;
 
        public Input(InputStream inputStream) {
            reader = new BufferedReader(new InputStreamReader(inputStream));
        }
 
        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException();
            }
        }
 
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                tokenizer = new StringTokenizer(nextLine());
            }
            return tokenizer.nextToken();
        }
 
        public int nextInt() {
            return Integer.parseInt(next());
        }
 
        public long nextLong() {
            return Long.parseLong(next());
        }
 
        public int[] nextIntArray(int n, int add) {
            int[] result = new int[n];
            for (int i = 0; i < n; i++) {
                result[i] = nextInt() + add;
            }
            return result;
        }
 
        public long[] nextLongArray(int n, long add) {
            long[] result = new long[n];
            for (int i = 0; i < n; i++) {
                result[i] = nextLong() + add;
            }
            return result;
        }
 
        public int[] nextIntArray(int n) {
            return nextIntArray(n, 0);
        }
 
    }
    
	public static void main (String[] args) throws java.lang.Exception
	{
		Input s=new Input(System.in);
		int t=s.nextInt();
		PrintWriter out=new PrintWriter(System.out);
		
		while(t-->0)
		{
                int n=s.nextInt();
                int d=s.nextInt();

                int tn=n-1;
                int l=2,vl=1,low=0;
                while(tn!=0)
                {
                    low+=Math.min(tn,l)*vl;
                    tn-=Math.min(tn,l);
                    l=l*2;
                    vl++;
                }

                if(d>n*(n-1)/2 || d<low)
                {out.println("NO");
                continue;}

                int par[]=new int[n];
                int child[]=new int[n];
                int depth[]=new int[n];
                boolean bad[]=new boolean[n];
                for(int i=1;i<n;i++)
                {
                    par[i]=i-1;
                    child[i-1]++;
                    depth[i]=i;
                }
                int upper=n*(n-1)/2;
                while(upper>d)
                {

                   // out.println("upper"+upper);

                    int findmin=-1,findmax=-1;
                    for(int i=0;i<n;i++)
                    {

                        if(!bad[i] && child[i]==0)
                        {
                            if(findmax==-1)
                            findmax=i;
                            else if(depth[findmax]>depth[i])
                            findmax=i;
                        }
                    }
                    //out.println("findmax "+findmax);
                    if(findmax==-1)
                    break;
                    for(int i=0;i<n;i++)
                    {   //out.println("child"+child[i]+" "+(depth[i]-depth[findmax])); 
                        if(child[i]<2 && depth[i]<depth[findmax]-1)
                        {
                            if(findmin==-1 || depth[findmin]<depth[i])
                            findmin=i;
                        }
                    }

                    if(findmin==-1)
                    {
                        bad[findmax]=true;
                        continue;
                    }

                    if(depth[findmax]-depth[findmin]==2)
                    upper--;
                    child[par[findmax]]--;
                    depth[findmax]--;
                    child[findmin]++;
                    par[findmax]=findmin;
                }
                if(upper<=d)
                {out.println("YES");
                for(int i=1;i<n;i++)
                out.print((par[i]+1)+" ");
                out.println();
                }
                else
                out.println("NO");
        }
        out.flush();
	}
}