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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class E1311 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int test = Integer.parseInt(br.readLine());
        while (test-- > 0){

            String in[] = br.readLine().trim().split(" ");

            int n = Integer.parseInt(in[0]);
            int m = Integer.parseInt(in[1]);
            //List<Integer> L = new ArrayList<>();

            int sz[] = new int[Math.max(n+1, 15)];
            Arrays.fill(sz, 2);

            for (int i=0;i<=13;++i){
                sz[i+1] = 1<<i;
            }

            int sz1[] = new int[Math.max(n+1, 15)];
            Arrays.fill(sz1,1);
            int tot = n * (n-1) /2 ;
            int end = n;

            while (tot>m){
                int cur = end - 1;
                while (true){
                    if (cur<0){
                        break;
                    }
                    if (sz1[cur]+1<=sz[cur] && tot>m){
                        sz1[cur]++;
                        sz1[cur+1]--;
                    } else {
                        break;
                    }
                    --cur;
                    --tot;
                }
                if (cur<0){
                    break;
                }
                --end;
            }

//            for (int i=1;i<=n;++i){
//                System.out.print(sz1[i] + " ");
//            }
//            System.out.println();
//            System.out.println(tot);

            int cnt = 2;
            if (tot == m && sz1[1]>0){
                System.out.println("YES");
                List<Integer>L[] = new ArrayList[5000];
                List<Integer>P[] = new ArrayList[5000];

                int last = 2;
                L[1] = new ArrayList<>();
                L[1].add(1);
                for (int i=2;i<=n;++i){
                    L[i] = new ArrayList<>();
                    P[i] = new ArrayList<>();
                    if (sz1[i]>0){
                        for (int j=1;j<=sz1[i]; ++j){
                            L[i].add(cnt++);
                        }
                    } else {
                        last = i;
                        break;
                    }
                }

                int tot1 = (n * (n-1))/2;
                if(tot1 == m){
                    last = n;
                }

                L[last+1] = new ArrayList<>();
                P[last+1] = new ArrayList<>();

//
//                for (int i=2;i<=last;++i){
//                    if (L[i].size() > 0)
//                    for (Integer e:L[i]){
//                        System.out.print(e + " ");
//                    }
//                    System.out.println("");
//                }

                for (int i=1;i<=last;++i){
                    if (L[i].size() > 0) {
                        for (int j=0;j<L[i].size();++j){
                            int cur = L[i].get(j);
                            if (L[i+1].size()>(j*2)){
                                P[i+1].add(cur);
                            }
                            if (L[i+1].size()>(j*2+1)){
                                P[i+1].add(cur);
                            }
                        }
                    }
                }

                for (int i=2;i<=last;++i){
                    if (P[i].size() > 0)
                    for (Integer e:P[i]){
                        System.out.print(e + " ");
                    }
                    //System.out.println("");
                }

                System.out.println("");



            } else {
                System.out.println("NO");
            }
        }
    }
}
