Problem: 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

Solution (in JAVA):

Solution:
import java.util.*;
import java.io.*;

public class Main{

    static class fastReader{
        BufferedReader br;
        StringTokenizer st;

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

        float nextFloat(){
            return Float.parseFloat(Next());
        }

        boolean nextBoolean(){
            return Boolean.parseBoolean(Next());
        }

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

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

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

        String next(){
            return Next();
        }
    }
    static int int_max = Integer.MAX_VALUE;
    static int int_min = Integer.MIN_VALUE;

    private static final fastReader f = new fastReader();
    private static final PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

    public static void print(Object o){out.print(o);}
    public static void println(Object o){out.println(o);}
    public static void println(){out.println();}
    
    public static<T extends Comparable<T>> T max(T a , T b){return a.compareTo(b) > 0 ? a : b;}
    public static<T extends Comparable<T>> T min(T a , T b){return a.compareTo(b) > 0 ? b : a;}
    
    public static void main(String[] args){
        int t = f.nextInt();
        while(t-- > 0){
          solve();
        }
        out.close();
    }

    public static void solve(){
      int n = f.nextInt();
      int k = f.nextInt();
      HashSet<Integer> set = new HashSet<>();
      for(int i = n; i > 0; i-- ){
          if(i > k){
              set.add(i);
          }
          else if(i < k){
              int diff =  k - i;
              if(!set.contains(diff)){
                  set.add(i);
              }
          }
      }
      println(set.size());
      for(int i : set){
        print(i+" ");
      }
      println();
    }
}