You are given two integers n and k. You are asked to choose maximum number of distinct integers from 1 to n so that there is no subset of chosen numbers with sum equal to k.

A subset of a set is a set that can be obtained from initial one by removing some (possibly all or none) elements of it.

Input

The first line contains the number of test cases T (1 ≤ T ≤ 100).

Each of the next T lines contains two integers n and k (1 ≤ k ≤ n ≤ 1000) — the description of test cases.

Output

For each test case output two lines. In the first line output a single integer m — the number of chosen integers.

In the second line output m distinct integers from 1 to n — the chosen numbers.

If there are multiple answers, print any. You can print the numbers in any order.

Example

Input


3
3 2
5 3
1 1


Output


2
3 1 
3
4 5 2 
0


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;

public class Main {

    public static void main(String[] args) throws IOException {
        read re=new read();
        re.init(System.in);


        int T=re.nextInt();


        for(int i=0;i<T;i++) {
            int N=re.nextInt();
            int K=re.nextInt();
            antiknap(N,K);
        }
    }
    public static void displaywithout0s(ArrayList<Integer> arr){
        for(int i=0;i<arr.size();i++){
            System.out.print(arr.get(i)+" ");
        }
        System.out.println("");

    }
    public static void antiknap(int n, int k){
        int j=0;
        ArrayList<Integer> arr=new ArrayList<>();
        for(int i=k/2;i<k;i++){
            if(k%2!=0){
                continue;
            }
            arr.add(i);
        }
        for(int i=k+1;i<=n;i++){
            arr.add(i);

        }
        System.out.println(arr.size());
        displaywithout0s(arr);
    }
    public static int binarysearchfirstarrlist(ArrayList<Integer> lst, int element) {
        int low=0;
        int high=lst.size()-1;
        int first=0;


        int mid = (low + high) / 2;

        while(low<=high){
            if(element<lst.get(mid)){
                high=mid-1;
                mid = (low + high) / 2;

            }
            else if(element>lst.get(mid)){
                low=mid+1;
                mid = (low + high) / 2;

            }
            else {
                if(mid==0){
                    return mid;
                }
                if(lst.get(mid-1)==element){
                    mid=mid-1;
                    continue;
                }

                return mid;
            }
        }
        return -1;


    }

    static class read {
        BufferedReader reader;
        StringTokenizer tokenizer;

        void init(InputStream input) {
            reader = new BufferedReader(
                    new InputStreamReader(input) );
            tokenizer = new StringTokenizer("");
        }

        String next() throws IOException {
            while ( ! tokenizer.hasMoreTokens() ) {
                tokenizer = new StringTokenizer(
                        reader.readLine() );
            }
            return tokenizer.nextToken();
        }

        String readLine() throws IOException {
            String s = reader.readLine();
            return s;
        }

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

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

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



}
