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>
#include <bits/stdc++.h>
const int MAXN = 20001;
using namespace std;
int fa[MAXN];
bool vis[MAXN];
pair<int, int> f_range[MAXN];
int node_idx;
pair<int, int> calc_range(int num_nodes) {
  if (vis[num_nodes]) return f_range[num_nodes];
  vis[num_nodes] = true;
  if (num_nodes == 0) return f_range[num_nodes] = make_pair(0, 0);
  int depth = 1;
  int up_bound = (0 + num_nodes - 1) * num_nodes / 2;
  int low_bound = 0;
  while ((1 << depth) - 1 < num_nodes) {
    low_bound += (1 << depth) * depth;
    ++depth;
  }
  low_bound -= ((1 << depth) - 1 - num_nodes) * (depth - 1);
  return f_range[num_nodes] = make_pair(low_bound, up_bound);
}
void build(int x, int num_nodes, int total_depth) {
  if (num_nodes == 1) return;
  total_depth -= num_nodes - 1;
  num_nodes -= 1;
  for (int i = 0; i * 2 <= num_nodes; ++i) {
    pair<int, int> left_range = calc_range(i);
    pair<int, int> right_range = calc_range(num_nodes - i);
    if (total_depth < left_range.first + right_range.first ||
        total_depth > left_range.second + right_range.second)
      continue;
    int left_depth = left_range.first + max(0, total_depth - left_range.first -
                                                   right_range.second);
    if (i > 0) fa[++node_idx] = x;
    build(node_idx, i, left_depth);
    fa[++node_idx] = x;
    build(node_idx, num_nodes - i, total_depth - left_depth);
    break;
  }
}
int main() {
  int num_test_case;
  cin >> num_test_case;
  for (int cas_idx = 0; cas_idx < num_test_case; ++cas_idx) {
    int num_nodes, depth;
    scanf("%d%d", &num_nodes, &depth);
    if (depth < calc_range(num_nodes).first ||
        depth > calc_range(num_nodes).second) {
      printf("NO\n");
      continue;
    }
    node_idx = 1;
    build(1, num_nodes, depth);
    printf("YES\n");
    for (int i = 2; i <= num_nodes; ++i)
      printf("%d%c", fa[i], i == num_nodes ? '\n' : ' ');
  }
  return 0;
}
