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>
//package codeforces.round624div3;

import java.io.*;
import java.util.*;

public class ConstructBinaryTree {
    private static int UNVISITED = 0;
    private static int VISITING = -1;
    private static int VISITED = 1;

    public static void main(String[] args) {
//        try {
//            FastScanner in = new FastScanner(new FileInputStream("src/input.in"));
//            PrintWriter out = new PrintWriter(new FileOutputStream("src/output.out"));

        FastScanner in = new FastScanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

            int t = in.nextInt();
            solve(t, in, out);
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
    }

    private static void solve(int q, FastScanner in, PrintWriter out) {
        for (int qq = 0; qq < q; qq++) {
            int n = in.nextInt(), d = in.nextInt();
            int max = n * (n - 1) / 2;
            int min = 0;
            int cnt = n - 1, base = 2, depth = 1;
            while(cnt > 0) {
                min += Math.min(base, cnt) * depth;
                depth++;
                cnt -= base;
                base = base * 2;
            }
            if(d < min || d > max) {
                out.println("NO");
            }
            else {
                int[] parent = new int[n + 1];
                for(int i = 2; i <= n; i++) {
                    parent[i] = i - 1;
                }
                int[] childCnt = new int[n + 1];
                for(int i = 1; i < n; i++) {
                    childCnt[i] = 1;
                }
//                Set<Integer>[] children = new Set[n + 1];
//                for(int i = 0; i <= n; i++) {
//                    children[i] = new HashSet<>();
//                }
//                for(int i = 1; i < n; i++) {
//                    children[i].add(i + 1);
//                }
                TreeMap<Integer, List<Integer>> dist = new TreeMap<>();
                for(int i = 1; i <= n; i++) {
                    List<Integer> list = new ArrayList<>();
                    list.add(i);
                    dist.put(i - 1, list);
                }
                int diff = max - d;
                while(diff > 0) {
                    Map.Entry<Integer, List<Integer>> entry = dist.lastEntry();
                    int currDist = entry.getKey();
                    List<Integer> currList = entry.getValue();
                    int currNode = currList.remove(currList.size() - 1);


                    Map.Entry<Integer, List<Integer>> ancestorEntry = dist.ceilingEntry(currDist - diff - 1);
                    int ancestorDist = ancestorEntry.getKey();
                    List<Integer> ancestorList = ancestorEntry.getValue();
                    int ancestor = ancestorList.get(ancestorList.size() - 1);

                    childCnt[parent[currNode]]--;
                    childCnt[ancestor]++;
                    parent[currNode] = ancestor;

                    if(currList.size() == 0) {
                        dist.remove(currDist);
                    }
                    if(!dist.containsKey(ancestorDist + 1)) {
                        dist.put(ancestorDist + 1, new ArrayList<>());
                    }
                    dist.get(ancestorDist + 1).add(currNode);

                    if(childCnt[ancestor] == 2) {
                        ancestorList.remove(ancestorList.size() - 1);
                        if(ancestorList.size() == 0) {
                            dist.remove(ancestorDist);
                        }
                    }
                    diff -= (currDist - ancestorDist - 1);
                }
                out.println("YES");
                for(int i = 2; i <= n; i++) {
                    out.print(parent[i] + " ");
                }
                out.println();
            }
        }
        out.close();
    }

    private static long modularAdd(long a, long b, int mod) {
        long sum = a + b;
        if (sum >= mod) {
            sum -= mod;
        }
        return sum;
    }

    private static long modularSubtract(long a, long b, int mod) {
        long diff = a - b;
        if (diff < 0) {
            diff += mod;
        }
        return diff;
    }

    private static Stack<Integer> topologicalSort(Set<Integer>[] g) {
        Stack<Integer> stack = new Stack<>();
        int[] state = new int[g.length];

        for (int node = 0; node < g.length; node++) {
            if (!topoSortHelper(g, stack, state, node)) {
                return null;
            }
        }
        return stack;
    }

    private static boolean topoSortHelper(Set<Integer>[] g, Stack<Integer> stack, int[] state, int currNode) {
        if (state[currNode] == VISITED) {
            return true;
        } else if (state[currNode] == VISITING) {
            return false;
        }
        state[currNode] = VISITING;
        for (int neighbor : g[currNode]) {
            if (!topoSortHelper(g, stack, state, neighbor)) {
                return false;
            }
        }
        state[currNode] = VISITED;
        stack.push(currNode);
        return true;
    }

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        FastScanner(InputStream stream) {
            try {
                br = new BufferedReader(new InputStreamReader(stream));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                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;
        }
    }
}


