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
#------------------Important Modules------------------#

from sys import stdin,stdout
from bisect import bisect_left as bl
from bisect import bisect_right as br

from heapq import *
input=stdin.readline
#prin=stdout.write
from random import sample
t=int(input())
#t=1
from collections import Counter,deque
from math import sqrt,ceil,log2,gcd
#dist=[0]*(n+1)
class DisjSet: 
    def __init__(self, n): 
        # Constructor to create and 
        # initialize sets of n items 
        self.rank = [1] * n 
        self.parent = [i for i in range(n)] 
  
  
    # Finds set of given item x 
    def find(self, x): 
          
        # Finds the representative of the set 
        # that x is an element of 
        if (self.parent[x] != x): 
              
            # if x is not the parent of itself 
            # Then x is not the representative of 
            # its set, 
            self.parent[x] = self.find(self.parent[x]) 
              
            # so we recursively call Find on its parent 
            # and move i's node directly under the 
            # representative of this set 
  
        return self.parent[x] 
  
  
    # Do union of two sets represented 
    # by x and y. 
    def union(self, x, y): 
          
        # Find current sets of x and y 
        xset = self.find(x) 
        yset = self.find(y) 
  
        # If they are already in same set 
        if xset == yset: 
            return
  
        # Put smaller ranked item under 
        # bigger ranked item if ranks are 
        # different 
        if self.rank[xset] < self.rank[yset]: 
            self.parent[xset] = yset 
  
        elif self.rank[xset] > self.rank[yset]: 
            self.parent[yset] = xset 
  
        # If ranks are same, then move y under 
        # x (doesn't matter which one goes where) 
        # and increment rank of x's tree 
        else: 
            self.parent[yset] = xset 
            self.rank[xset] = self.rank[xset] + 1
  
# Driver code 



def f(arr,i,j,d,dist):
    if i==j:
        return 
    nn=max(arr[i:j])
    for tl in range(i,j):
        if arr[tl]==nn:
            dist[tl]=d
            #print(tl,dist[tl])
            f(arr,i,tl,d+1,dist)
            f(arr,tl+1,j,d+1,dist)
    #return dist
            
        
def ps(n):
    cp=0
    while n%2==0:
        n=n//2
        cp+=1
    for ps in range(3,ceil(sqrt(n))+1,2):
        while n%ps==0:
            n=n//ps
            cp+=1
            
    if n!=1:
        return False
    return True


#count=0
#dp=[[0 for i in range(m)] for j in range(n)]
#[int(x) for x in input().strip().split()]
def find_gcd(x, y): 
      
    while(y): 
        x, y = y, x % y 
      
    return x 
          
# Driver Code         
def factorials(n,r):
    #This calculates ncr mod 10**9+7
    slr=n;dpr=r
    qlr=1;qs=1
    mod=10**9+7
    
    for ip in range(n-r+1,n+1):
        qlr=(qlr*ip)%mod
    for ij in range(1,r+1):
        qs=(qs*ij)%mod
    #print(qlr,qs)
    ans=(qlr*modInverse(qs))%mod
    return ans

        
        
def modInverse(b):
    qr=10**9+7
    return pow(b, qr - 2,qr)

tt=[xa**3 for xa in range(0,10**4+1)]
qq=set(tt)


for jj in range(t):
    #n=int(input())
    n,k=[int(x) for x in input().strip().split()]
    #arr=[int(x) for x in input().strip().split()];
    #brr=[int(x) for x in input().strip().split()];brr.sort()
    print(n-k+k//2)
    u=(n-k)+k//2
    count=0
    arr=[]
    for i in range(n,0,-1):
        if count==u:
            break
        if i!=k:
            arr.append(str(i))
            count+=1
        #xr-=1
    if len(arr)!=0:
        print(' '.join(arr))
            
        
    
        
        
        
        
    
    
        
        
        
    
    
    
        
    
    
    
    
    
            
        
        
            
    
    
                
                    
                
                        
                    
            
            
        
                
            
        
    
    
            
    
        
    
    
    
        
        
    
    
            
            
            
        
        
            
        
        
        
    
        
            
            
            
            
    
    
    
            
    
    
        
    
    
    
        
    
    
                   
    
        
                
        
    
        
        
        
        
        
                
    
    
    
    
        
    
    
    
    
        
        
        
        
            
        
    

