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 sys

__author__ = 'ratmir'

from collections import deque

alphabet = "abcdefghijklmnopqrstuvwxyz"


def solve(n, a, graph):
    return 1


def execute():
    [t] = [int(x) for x in sys.stdin.readline().split()]
    results = []
    for ti in range(0, t):
        [n, d] = [int(x1) for x1 in sys.stdin.readline().split()]

        result, rr, sl = getR(n, d)

        if result == "NO":
            results.append("NO\n")
            continue
        # print sum(levelss)
        results.append("YES\n" + ''.join('{} '.format(k) for k in rr))

    print(''.join('{}\n'.format(k) for k in results))


def getR(n, d):
    if d > (n * (n - 1) / 2):
        return "NO", None, None
    levels = []
    used = 0
    toadd = 1
    ls = 0
    height = 0
    while used < n:
        ta = min(toadd, n - used)
        levels.append(ta)
        used += ta
        ls += ta * height
        height += 1
        toadd *= 2
    if ls > d:
        return "NO", None, None
        # print ls, d
    levels.append(0)
    # print "s", levels
    while ls < d:
        for l in range(0, len(levels)):
            if levels[l + 1] + 1 <= 2 * (levels[l] - 1):
                levels[l + 1] += 1
                levels[l] -= 1
                ls += 1

                break
        if levels[len(levels) - 1] != 0:
            levels.append(0)
    starts = [0]
    for i in levels:
        starts.append(starts[len(starts) - 1] + i)
    # print starts, levels, ls
    rr = []
    for i in range(1, len(levels) - 1):
        for j in range(0, levels[i]):
            rr.append(starts[i - 1] + (j / 2) + 1)
        # print levels[i], starts[i], rr
    # print rr
    levelss = [0]
    for i in range(0, len(rr)):
        levelss.append(levelss[rr[i] - 1] + 1)
    return "YES", rr, sum(levelss)


# for n in range(1, 5000):
#     print n
#     for d in range(1, 5000):
#         res, rr, sl = getR(n, d)
#         if res == "NO":
#             continue
#         if sl != d:
#             print d, n, sl, rr

execute()
