Alice and Borys are playing tennis.

A tennis match consists of games. In each game, one of the players is serving and the other one is receiving.

Players serve in turns: after a game where Alice is serving follows a game where Borys is serving, and vice versa.

Each game ends with a victory of one of the players. If a game is won by the serving player, it's said that this player holds serve. If a game is won by the receiving player, it's said that this player breaks serve.

It is known that Alice won a games and Borys won b games during the match. It is unknown who served first and who won which games.

Find all values of k such that exactly k breaks could happen during the match between Alice and Borys in total.

Input

Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.

Each of the next t lines describes one test case and contains two integers a and b (0 ≤ a, b ≤ 10^5; a + b > 0) — the number of games won by Alice and Borys, respectively.

It is guaranteed that the sum of a + b over all test cases does not exceed 2 ⋅ 10^5.

Output

For each test case print two lines.

In the first line, print a single integer m (1 ≤ m ≤ a + b + 1) — the number of values of k such that exactly k breaks could happen during the match.

In the second line, print m distinct integers k_1, k_2, …, k_m (0 ≤ k_1 < k_2 < … < k_m ≤ a + b) — the sought values of k in increasing order.

Example

Input


3
2 1
1 1
0 5


Output


4
0 1 2 3
2
0 2
2
2 3

Note

In the first test case, any number of breaks between 0 and 3 could happen during the match: 

  * Alice holds serve, Borys holds serve, Alice holds serve: 0 breaks; 
  * Borys holds serve, Alice holds serve, Alice breaks serve: 1 break; 
  * Borys breaks serve, Alice breaks serve, Alice holds serve: 2 breaks; 
  * Alice breaks serve, Borys breaks serve, Alice breaks serve: 3 breaks. 



In the second test case, the players could either both hold serves (0 breaks) or both break serves (2 breaks).

In the third test case, either 2 or 3 breaks could happen: 

  * Borys holds serve, Borys breaks serve, Borys holds serve, Borys breaks serve, Borys holds serve: 2 breaks; 
  * Borys breaks serve, Borys holds serve, Borys breaks serve, Borys holds serve, Borys breaks serve: 3 breaks. 
					/*
					ID: abdelra29
LANG: JAVA
PROG: zerosum
					*/
						/*
						TO LEARN
				
						2-euler tour
					
						*/
						/*
						TO SOLVE 
						*/
						/*
						bit manipulation shit
						1-Computer Systems: A Programmer's Perspective
						2-hacker's delight
						*/
						/*
						TO WATCH
						
						*/
						            import java.util.*;
								    import java.math.*;
								    import java.io.*; 
								    import java.util.stream.Collectors;

								       public class A{
						            static FastScanner scan=new FastScanner();
									     public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
static TreeSet<Integer>set;
static void rec(int a,int b,boolean turn,int num)
{
	//System.out.println(a+" "+b+" "+turn);
	if(a==0&&b==0){
		//System.out.println("FUCK");
		set.add(num);
		return ;
	}
	int res=0;
	if(turn)
	{
		//Alice
		if(b-1>=0&&a-1>=0)
		{
			rec(a-1,b,turn^true,num);
			rec(a,b-1,turn^true,num+1);
		}
		else if(b-1>=0)
		{
			//if(a==0&&b==1)
				//System.out.println("FUCK");
			rec(a,b-1,turn^true,num+1);
		}
		else  
		{
			//if(a==0&&b==1)
			//	System.out.println("FUCK");
			rec(a-1,b,turn^true,num);
		}
	}
	else 
	{
		if(b-1>=0&&a-1>=0)
		{
			rec(a-1,b,turn^true,num+1);
			rec(a,b-1,turn^true,num);
		}
		else if(b-1>=0)
		{
			rec(a,b-1,turn^true,num);
		}
		else  
		{
			rec(a-1,b,turn^true,num+1);
		}
	}
}

		public static void main(String[] args)  throws Exception 
						      {
						 /*
						 very important tips 
						 1-just fucking think backwards once in your shitty life
						 2-consider brute forcing and finding some patterns and observations
						 3-when you're in contest don't get out because you think there is no enough time
						 4-don't get stuck on one approach 
						 */
						
							//scan=new FastScanner("binary.in");
								///out = new PrintWriter("zerosum.out");
								 
								 							 /*
								 READING 
							
								 3-Introduction to DP with Bitmasking codefoces
								 4-Bit Manipulation hackerearth
								 5-read more about mobious and inculsion-exclusion 
								 */
								
								
					
								    int tt=1;
		tt=scan.nextInt();
						
							 outer:while(tt-->0)
								    {
								    	int a=scan.nextInt(),b=scan.nextInt();
								   /* set=new TreeSet();
								    	rec(a,b,true,0);
								    	rec(a,b,false,0);
								    	while(set.size()>0)
								    	{
								    		int p=set.pollFirst();
								    		out.print(p+" ");
								    	}*/
								    	if(a==0)
								    	{
								    		if(b%2==1)
								    		{
								    			out.println(2);
								    			out.println((b/2)+" "+(b/2+1));
								    		}
								    		else{
								    			out.println(1);
								    		 out.println(b/2);
								    		}
								    	}
								    	else if(b==0)
								    	{
								    		if(a%2==1)
								    		{
								    			out.println(2);
								    			out.println((a/2)+" "+(a/2+1));
								    		}
								    		else {
								    			out.println(1);
								    			out.println(a/2);
								    		}
								    	}
								    	else 
								    	{
								    		if(a==b)
								    		{
								    			out.println((a+b)/2);
								    			for(int i=0;i<=a+b;i+=2)
								    			out.print(i+" ");
								    		}
								    		else{
								    			out.println(a+b+1);
								    		for(int i=0;i<=a+b;i++)
								    			out.print(i+" ");}
								    		out.println();
								    	}
								    	//out.println();
								    	
								  



				    	
								    	
	 }

								

		out.close();
					}
					

					static class special{
					boolean is;
					char c;
					public special(boolean is,char c)
					{
						this.is=is;
						this.c=c;
					}

						 @Override
								            public int hashCode() {
								                return (int)(c+ 31 *(is?1:0));
								            }
						  @Override
								            public boolean equals(Object o){
								            //	System.out.println("FUCK");
								                if (o == this) return true;
								                if (o.getClass() != getClass()) return false;
								                special t = (special)o;
								                return t.is == is && t.c == c;
								            }
					}
		
								   
								     static long binexp(long a,long n)
								    {
								        if(n==0)
								            return 1;
								        long res=binexp(a,n/2);
								        if(n%2==1)
								            return res*res*a;
								        else 
								            return res*res;
								    }
								     
								    static long powMod(long base, long exp, long mod) {
								           if (base == 0 || base == 1) return base;
								           if (exp == 0) return 1;
								           if (exp == 1) return (base % mod+mod)%mod;
								           long R = (powMod(base, exp/2, mod) % mod+mod)%mod;
								           R *= R;
								           R %= mod;
								           if ((exp & 1) == 1) {
								               return (base * R % mod+mod)%mod;
								           }
								           else return (R %mod+mod)%mod;
								       }
								    static double dis(double x1,double y1,double x2,double y2)
								    {
								        return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
								    }
								    static long mod(long x,long y)
								        {
								            if(x<0)
								                x=x+(-x/y+1)*y;
								            return x%y;
								        }
								     public static  long pow(long b, long e) {
								                long r = 1;
								                while (e > 0) {
								                    if (e % 2 == 1) r = r * b ;
								                    b = b * b;
								                    e >>= 1;
								                }
								                return r;
								            }
								    private static void sort(int[] arr) {
								            List<Integer> list = new ArrayList<>();
								            for (int object : arr) list.add(object);
								            Collections.sort(list);
								        //Collections.reverse(list);
								            for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
								        }
								    private static void sort2(long[] arr) {
								            List<Long> list = new ArrayList<>();
								            for (Long object : arr) list.add(object);
								            Collections.sort(list);
								        Collections.reverse(list);
								            for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
								        }
								     static class FastScanner
						{
						    private int BS = 1 << 16;
						    private char NC = (char) 0;
						    private byte[] buf = new byte[BS];
						    private int bId = 0, size = 0;
						    private char c = NC;
						    private double cnt = 1;
						    private BufferedInputStream in;
						 
						    public FastScanner() {
						        in = new BufferedInputStream(System.in, BS);
						    }
						 
						    public FastScanner(String s) {
						        try {
						            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
						        } catch (Exception e) {
						            in = new BufferedInputStream(System.in, BS);
						        }
						    }
						 
						    private char getChar() {
						        while (bId == size) {
						            try {
						                size = in.read(buf);
						            } catch (Exception e) {
						                return NC;
						            }
						            if (size == -1) return NC;
						            bId = 0;
						        }
						        return (char) buf[bId++];
						    }
						 
						    public int nextInt() {
						        return (int) nextLong();
						    }
						 
						    public int[] nextInts(int N) {
						        int[] res = new int[N];
						        for (int i = 0; i < N; i++) {
						            res[i] = (int) nextLong();
						        }
						        return res;
						    }
						 
						    public long[] nextLongs(int N) {
						        long[] res = new long[N];
						        for (int i = 0; i < N; i++) {
						            res[i] = nextLong();
						        }
						        return res;
						    }
						 
						    public long nextLong() {
						        cnt = 1;
						        boolean neg = false;
						        if (c == NC) c = getChar();
						        for (; (c < '0' || c > '9'); c = getChar()) {
						            if (c == '-') neg = true;
						        }
						        long res = 0;
						        for (; c >= '0' && c <= '9'; c = getChar()) {
						            res = (res << 3) + (res << 1) + c - '0';
						            cnt *= 10;
						        }
						        return neg ? -res : res;
						    }
						 
						    public double nextDouble() {
						        double cur = nextLong();
						        return c != '.' ? cur : cur + nextLong() / cnt;
						    }
						 
						    public double[] nextDoubles(int N) {
						        double[] res = new double[N];
						        for (int i = 0; i < N; i++) {
						            res[i] = nextDouble();
						        }
						        return res;
						    }
						 
						    public String next() {
						        StringBuilder res = new StringBuilder();
						        while (c <= 32) c = getChar();
						        while (c > 32) {
						            res.append(c);
						            c = getChar();
						        }
						        return res.toString();
						    }
						 
						    public String nextLine() {
						        StringBuilder res = new StringBuilder();
						        while (c <= 32) c = getChar();
						        while (c != '\n') {
						            res.append(c);
						            c = getChar();
						        }
						        return res.toString();
						    }
						 
						    public boolean hasNext() {
						        if (c > 32) return true;
						        while (true) {
						            c = getChar();
						            if (c == NC) return false;
						            else if (c > 32) return true;
						        }
						    }
						}

								     static class Pair implements Comparable<Pair>{
								            public long x, y,z;
								            public Pair(long x1, long y1,long z1) {
								                x=x1;
								                y=y1;
								                z=z1;
								            }
								             public Pair(long x1, long y1) {
								                x=x1;
								                y=y1;
								    
								            }
								            
								            @Override
								            public int hashCode() {
								                return (int)(x + 31 * y);
								            }
								            public String toString() {
								                return x + " " + y+" "+z;
								            }
								            @Override
								            public boolean equals(Object o){
								                if (o == this) return true;
								                if (o.getClass() != getClass()) return false;
								                Pair t = (Pair)o;
								                return t.x == x && t.y == y&&t.z==z;
								            }
								    public int compareTo(Pair o)
								    {
								  	
								  
								    	return (int)(x-o.x);
								     
								        }
								     
								    }
								}
								
								    
								   

								     
