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>
using namespace std;
inline int read() {
  register int x = 0, f = 1;
  register char ch = getchar();
  while (ch < '0' || ch > '9') {
    if (ch == '-') f = -1;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9') x = x * 10 + (ch ^ 48), ch = getchar();
  return x * f;
}
const int N = 5e3 + 5;
int du[N], fa[N], dep[N];
struct each {
  queue<int> que;
  int find(int ty, int d) {
    while (!que.empty()) {
      int x = que.front();
      if (du[x] != ty || dep[x] != d)
        que.pop();
      else
        return x;
    }
    return 0;
  }
  void clear() {
    while (!que.empty()) que.pop();
  }
  void push(int x) { que.push(x); }
  void pop() { que.pop(); }
} b[N][2];
void run(int d, int &t) {
  if (!d || !t) return;
  while (t) {
    int x = b[d][0].find(0, d);
    int y = b[d][1].find(1, d);
    if (!x) {
      run(d - 1, t);
      return;
    }
    if (!y) {
      int k = b[d][0].find(0, d);
      while (k == x) b[d][0].pop(), k = b[d][0].find(0, d);
      if (!k) {
        b[d][0].push(x);
        return void(run(d - 1, t));
      }
      b[d + 1][0].push(x), dep[x] = d + 1;
      --du[fa[x]], b[d - 1][du[fa[x]]].push(fa[x]);
      --t, b[d][0].pop(), du[fa[x] = k] = 1, b[d][1].push(k);
    } else {
      b[d + 1][0].push(x), dep[x] = d + 1;
      --du[fa[x]], b[d - 1][du[fa[x]]].push(fa[x]);
      --t, b[d][0].pop(), b[d][1].pop(), du[fa[x] = y] = 2;
    }
    run(d + 1, t);
  }
}
int main() {
  int t = read();
  while (t--) {
    int tot = 0, n = read(), d = read();
    for (int i = 2; i <= n; i++) fa[i] = i >> 1, ++du[fa[i]];
    for (int i = 2; i <= n; i++) {
      dep[i] = dep[fa[i]] + 1, tot += dep[i];
      if (du[i] != 2) b[dep[i]][du[i]].push(i);
    }
    if (d < tot || d > n * (n - 1) / 2)
      puts("NO");
    else {
      run(dep[n], d -= tot), puts("YES");
      for (int i = 2; i <= n; i++) printf("%d ", fa[i]);
      putchar('\n');
    }
    for (int i = 1; i <= n; i++) du[i] = dep[i] = 0;
    for (int i = 1; i <= n; i++) b[i][0].clear(), b[i][1].clear();
  }
  return 0;
}
