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.InputStreamReader;

import java.util.StringTokenizer;
import java.util.TreeSet;

import static java.lang.System.in;
import static java.lang.System.out;

public class Main {
    final static int INF=Integer.MAX_VALUE;
    final static int nINF=Integer.MIN_VALUE;

    public static void main(String[] args){
        FastReader fr=new FastReader();
        int tc=fr.nextInt();
        while(tc-->0){
            int n=fr.nextInt();
            int k=fr.nextInt();

            TreeSet<Integer>ts=new TreeSet<>();
            for(int i=1;i<=n;i++){
                ts.add(i);
            }

            ts.remove(k);
            int l=1;
            while(true){
                if(ts.contains(k-l) && (k-l)!=l){
                    ts.remove(l);
                    l++;
                }else{
                    break;
                }
            }
            out.println(ts.size());
            StringBuilder sb=new StringBuilder();
            for(int here:ts){
                sb.append(here+" ");
            }
            out.println(sb);
        }
    }

    ///////////////////////////////////////////////////////////

    static int[] fillInt(int n,FastReader fr){
        int ret[]=new int[n];
        for(int i=0;i<n;i++){
            ret[i]=fr.nextInt();
        }
        return ret;
    }

    static long[] fillLong(int n,FastReader fr){
        long ret[]=new long[n];
        for(int i=0;i<n;i++){
            ret[i]=fr.nextInt();
        }
        return ret;
    }

    static int max(int a,int b){
        return Math.max(a,b);
    }

    static int min(int a,int b){
        return Math.min(a,b);
    }

    static int gcd(int a,int b){
        if(b==0){
            return a;
        }
        return gcd(b,a%b);
    }

    static int lcm(int a,int b){
        return (a*b)/gcd(a,b);
    }

    static int lowerBound(int[] a, int l, int r, int v){
        int ret=-1;
        while(l<=r){
            int mid=(l+r)/2;

            if(a[mid]>=v){
                ret=mid;
                r=mid-1;
            }else{
                l=mid+1;
            }
        }
        return ret;
    }

    static int upperBound(int[] a, int l, int r, int v){
        int ret=-1;
        while(l<=r){
            int mid=(l+r)/2;

            if(a[mid]<=v){
                ret=mid;
                l=mid+1;
            }else{
                r=mid-1;
            }
        }
        return ret;
    }

    static class FastReader{
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(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());
        }

        byte nextByte(){
            return Byte.parseByte(next());
        }

        Float nextFloat(){
            return Float.parseFloat(next());
        }

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

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

        short nextShort(){
            return Short.parseShort(next());
        }

        Boolean nextbol(){
            return Boolean.parseBoolean(next());
        }

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