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 JAVA):

Solution:
/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
I'm working for the day I will surpass you
https://www.a2oj.com/Ladder16.html
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class x1311E
   {
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));  
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int T = Integer.parseInt(st.nextToken());
         StringBuilder sb = new StringBuilder();
         while(T-->0)
         {
            st = new StringTokenizer(infile.readLine());
            int N = Integer.parseInt(st.nextToken());
            int D = Integer.parseInt(st.nextToken());
            if(!pos(N, D))
               sb.append("NO\n");
            else
            {
               int[] res = new int[N+1];
               for(int i=2; i <= N; i++)
                  res[i] = i-1;
               int leftover = N*(N-1)/2-D;
               //depth to node id
               ArrayList<Integer>[] left = new ArrayList[N+1];
               ArrayList<Integer>[] right = new ArrayList[N+1];
               int[] depths = new int[N+1];
               for(int i=1; i <= N; i++)
               {
                  left[i] = new ArrayList<Integer>();
                  right[i] = new ArrayList<Integer>();
                  if(i < N)
                     right[i].add(i);
                  depths[i] = i-1;
               }
               int curr = N;
               while(curr > 2 && leftover > 0)
               {
                  int depth = depths[curr];
                  int min = 1;
                  ArrayList<Integer> ls = null;
                  for(int d=1; d <= N-1; d++)
                  {
                     if(left[d].size() > 0)
                     {
                        ls = left[d];
                        min = d;
                        break;
                     }
                     if(right[d].size() > 0)
                     {
                        ls = right[d];
                        min = d;
                        break;
                     }
                  }
                  if(leftover-depth+min > 0)
                  {
                     int prev = res[curr];
                     int newt = ls.get(0);
                     res[curr] = newt;
                     ls.remove(0);
                     left[min+1].add(curr);
                     right[min+1].add(curr);
                     leftover = leftover-depth+min;
                  }
                  else
                  {
                     for(int d=1; d <= N-1; d++)
                        if(leftover-depth+d >= 0)
                        {
                           if(leftover <= leftover-depth+d)
                              break;
                           ArrayList<Integer> temp = null;
                           if(left[d].size() > 0)
                              temp = left[d];
                           if(right[d].size() > 0)
                              temp = right[d];
                           if(temp != null)
                           {
                              res[curr] = temp.get(0);
                              leftover = leftover-depth+d;
                              left[d+1].add(curr);
                              right[d+1].add(curr);
                              break;
                           }
                        }
                  }
                  curr--;
               }
               if(leftover == 0)
               {
                  sb.append("YES\n");
                  for(int i=2; i <= N; i++)
                     sb.append(res[i]+" ");
                  sb.append("\n");
               }
               else
                  sb.append("NO\n");
            }
         }
         System.out.print(sb);
      }
      public static boolean pos(int N, int D)
      {
         int min = 0;
         int val = 1;
         int b = 1;
         int cnt = N-1;
         while(cnt > 0)
         {
            b *= 2;
            for(int i=0; i < b; i++)
            {
               if(cnt == 0)
                  break;
               min += val;
               cnt--;
            }
            val++;
         }
         int max = 0;
         for(int i=1; i < N; i++)
            max += i;
         return D >= min && D <= max;
      }
   }