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.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

public class C1311E_1 {
    public static void main(String[] args) {
        var scanner = new BufferedScanner();
        var writer = new PrintWriter(new BufferedOutputStream(System.out));

        var t = scanner.nextInt();
        for (int tc = 0; tc < t; tc++) {
            var n = scanner.nextInt();
            var d = scanner.nextInt();
            var ans = solve(n, d);
            if (ans == null) {
                writer.println("NO");
            } else {
                writer.println("YES");
                for (int i = 2; i <= n; i++) {
                    writer.print(ans[i] + " ");
                }
                writer.println();
            }
        }

        scanner.close();
        writer.flush();
        writer.close();
    }

    private static int[] solve(int n, int d) {
        var maxD = (n - 1) * n / 2;
        if (d > maxD) {
            return null;
        }
        var parent = new int[n + 1];
        var childCount = new int[n + 1];
        var depth = new int[n + 1];
        for (int i = 2; i <= n; i++) {
            parent[i] = i - 1;
            depth[i] = i - 1;
            childCount[i - 1] = 1;
        }
        var dToRemove = maxD - d;
        while (dToRemove > 0) {
            var leaf = 0;
            for (int i = 1; i <= n; i++) {
                if (childCount[i] == 0
                        && (leaf == 0 || depth[i] > depth[leaf])) {
                    leaf = i;
                }
            }
            var newParent = 0;
            for (int i = 1; i <= n; i++) {
                int delta = depth[leaf] - 1 - depth[i];
                if (childCount[i] < 2
                        && delta > 0
                        && delta <= dToRemove
                        && (newParent == 0 || depth[i] < depth[newParent])) {
                    newParent = i;
                }
            }
            if (newParent == 0) {
                return null;
            }
            var oldParent = parent[leaf];
            childCount[oldParent]--;
            var newDepth = depth[newParent] + 1;
            dToRemove -= (depth[leaf] - newDepth);
            depth[leaf] = newDepth;
            parent[leaf] = newParent;
            childCount[newParent]++;
        }
        return parent;
    }

    private static void add(int node, Map<Integer, List<Integer>> nodes, int[] depth, int[] childCount) {
        var hash = hash(depth[node], childCount[node]);
        nodes.putIfAbsent(hash, new LinkedList<>());
        nodes.get(hash).add(node);
    }

    private static void remove(Integer node, Map<Integer, List<Integer>> nodes, int[] depth, int[] childCount) {
        var hash = hash(depth[node], childCount[node]);
        nodes.get(hash).remove(node);
    }

    private static int hash(int depth, int childCount) {
        return depth * 3 + childCount;
    }

    public static class BufferedScanner {
        BufferedReader br;
        StringTokenizer st;

        public BufferedScanner(Reader reader) {
            br = new BufferedReader(reader);
        }

        public BufferedScanner() {
            this(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        void close() {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    static long gcd(long a, long b) {
        if (a < b) {
            return gcd(b, a);
        }
        while (b > 0) {
            long tmp = b;
            b = a % b;
            a = tmp;
        }
        return a;
    }

    static long inverse(long a, long m) {
        long[] ans = extgcd(a, m);
        return ans[0] == 1 ? (ans[1] + m) % m : -1;
    }

    private static long[] extgcd(long a, long m) {
        if (m == 0) {
            return new long[]{a, 1, 0};
        } else {
            long[] ans = extgcd(m, a % m);
            long tmp = ans[1];
            ans[1] = ans[2];
            ans[2] = tmp;
            ans[2] -= ans[1] * (a / m);
            return ans;
        }
    }

    private static List<Integer> primes(double upperBound) {
        var limit = (int) Math.sqrt(upperBound);
        var isComposite = new boolean[limit + 1];
        var primes = new ArrayList<Integer>();
        for (int i = 2; i <= limit; i++) {
            if (isComposite[i]) {
                continue;
            }
            primes.add(i);
            int j = i + i;
            while (j <= limit) {
                isComposite[j] = true;
                j += i;
            }
        }
        return primes;
    }


}
