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. 
import java.io.*;
import java.util.*;
 
public class Practice
{
	static int mod=1000000007;
	static int dp[][][];
	static FastReader sc=new FastReader(System.in);
//	static Reader sc=new Reader();
	static  PrintWriter out=new PrintWriter(System.out);
	public static void main(String[] args) throws IOException
	{ 
		int t=1;
		t=sc.nextInt();
//		StringBuilder sb=new StringBuilder();
		while(t-->0)
		{
			solve();
//			sb.append("\n");
		}
//		out.print(sb);
		out.close();
		out.flush();
	}
	static class Pair
	{
		int x;
		int y;
		Pair(int c,int f)
		{
			x=c;
			y=f;
		}
		@Override
		public String toString() 
		{
			return x+" "+y;
		}
	}
	static void arraySort(int arr[])
	{
		ArrayList<Integer> a=new ArrayList<Integer>();
		for (int i = 0; i < arr.length; i++) {
			a.add(arr[i]);
		}
		Collections.sort(a);
		for (int i = 0; i < arr.length; i++) {
			arr[i]=a.get(i);
		}
	}
	static void solve() throws IOException
	{
		int a=sc.nextInt(),b=sc.nextInt(),n=a+b;
		int arr[]=new int[n],A=a,B=b;
		//O =>  alice
		//1 => bob
		//fill a
		int sameA=0,sameB=0,dif=0;
		ArrayList<Integer> k=new ArrayList<Integer>();
		for(int i=0;i<n;i++)
		{
			if((i&1)==0)
			{//alice
				if(A!=0)
				{
					arr[i]=0;
					A--;
				}
				else
				{
					arr[i]=1;
					B--;
				}
			}
			else
			{
				if(B!=0)
				{
					arr[i]=1;
					B--;
				}
				else
				{
					arr[i]=0;
					A--;
				}
			}
			if(arr[i]==0)
			{
				if((i&1)==0)
					sameA++;
				else
					dif++;
			}
			else
			{
				if((i&1)==1)
					sameB++;
				else
					dif++;
			}
		}
//		out.println(sameA+" "+sameB+" "+dif);
		k.add(dif);
		int min=Math.min(sameA, sameB);
		while(min-->0)
		{
			dif+=2;
			k.add(dif);
		}
		if((a+b)%2==0)
		{
			out.println(k.size());
			for(int v: k)
				out.print(v+" ");
			out.println();
			return;
		}
		sameA=0;
		sameB=0;
		dif=0;
		A=a;
		B=b;
		for(int i=0;i<n;i++)
		{
			if(((i+1)&1)==0)
			{//alice
				if(A!=0)
				{
					arr[i]=0;
					A--;
				}
				else
				{
					arr[i]=1;
					B--;
				}
			}
			else
			{
				if(B!=0)
				{
					arr[i]=1;
					B--;
				}
				else
				{
					arr[i]=0;
					A--;
				}
			}
			if(arr[i]==0)
			{
				if(((i+1)&1)==0)
					sameA++;
				else
					dif++;
			}
			else
			{
				if(((i+1)&1)==1)
					sameB++;
				else
					dif++;
			}
		}
//		out.println(Arrays.toString(arr));
//		out.println(sameA+" "+sameB+" "+dif);
		min=Math.min(sameA, sameB);
		k.add(dif);
		while(min-->0)
		{
			dif+=2;
			k.add(dif);
		}
		Collections.sort(k);
		out.println(k.size());
		for(int v: k)
			out.print(v+" ");
		out.println();
	}
	static boolean check(int arr[])
	{
		for (int i = 1; i < arr.length; i++) {
			if(arr[i-1]>arr[i])
				return false;
		}
		return true;
	}
	static double dfs(Node ver,Node par)
	{
		if(ver.adj.size()==1 && ver.adj.get(0)==par)
		{
			return 0;
		}
		else
		{
			double sum=0,c=0;			
			for(Node child: ver.adj)
			if(child!=par)
			{
				c++;
				sum+=dfs(child, ver);
			}
			return 1+(sum/c);
		}
	}
	static int LOWER_BOUND(ArrayList<Integer> arr,int x)
	{
		int low=0,high=arr.size();
		int ans=0;
		while(low<=high)
		{
			int mid=(low+high)/2;
			if(arr.get(mid)==x)
			{
				ans=arr.get(mid);
				break;
			}
			else if(arr.get(mid)<x)
			{
				ans=arr.get(mid);
				low=mid+1;
			}
			else
				high=mid-1;
		}
		return ans;
	}
	static int gcd(int a,int b)
	{
		return (b==0)?a:gcd(b,a%b);
	}
	static class UnionFind
	{
		  private int size;
		  private int[] sz;
		  private int[] parent;
		  private int numComponents;
		  public UnionFind(int size,Pair dancers[]) 
		  {
		    if (size <= 0) throw new IllegalArgumentException("Size <= 0 is not allowed");
		    this.size = numComponents = size;
		    sz = new int[size];
		    parent = new int[size];
		    for (int i = 0; i < size; i++) 
		    {
		      parent[i] = i; 									// Link to itself (self root)
		      sz[i] = 1; 										// Each component is originally of size one
		    }
		  }
		  public int find(int p) 
		  {
		    int root = p;
		    while (root != parent[root])
		    	root = parent[root];
		    while (p != root)
		    {
		      int next = parent[p];
		      parent[p] = root;
		      p = next;
		    }
		    return root;
		  }
		  public boolean isConnected(int p, int q) 
		  {
		    return find(p) == find(q);
		  }
		  public int componentSize(int x) 
		  {
		    return sz[find(x)];
		  }
		  public int size() 
		  {
		    return size;
		  }
		  public int components() 
		  {
		    return numComponents;
		  }
		  public void unify(int p, int q) 
		  {
		    int root1 = find(p);
		    int root2 = find(q);
		    if(root1==root2)
		    {
		    	return;
		    }
		    else if (sz[root1] < sz[root2]) 
		    {
		    	parent[root1] = root2;
		    	sz[root2] += sz[root1];
		    	sz[root1] = 0;
		  } 
		    else 
		    {
		    	parent[root2] = root1;
		    	sz[root1] += sz[root2];
		    	sz[root2] = 0;
		    }
		    numComponents--;
		  }
		  void calc()
		  {
			  for(int i=0;i<size;i++)
				  find(i);
			  
		  }
	}
	static class Node
	{
		int vertex;
		ArrayList<Node> adj;
		boolean rec;
		boolean vis;
		int color;
		Node(int v)
		{
			vertex=v;
			adj=new ArrayList<Node>();
			vis=false;
			color=-1;
		}
		@Override
		public String toString() 
		{
			return vertex+" ";
		}
	}
	static class Edge
	{
		Node a;
		Node b;
		Edge(Node m,Node n)
		{
			this.a=m;
			this.b=n;
		}
		@Override
		public String toString() {
			return a.vertex+" "+b.vertex;
		}
	}
	static long power(long x, long y)
	  {
	    long res = 1; 
	    x = x % mod; 
	    if (x == 0)
	      return 0; 
	    while (y > 0)
	    {
	    	if ((y & 1) != 0)
	    		res = (res * x) % mod;
	    	
	    	y = y >> 1; // y = y/2
	    	x = (x * x) % mod;
	    }
	    return res;
	  }
	static long binomialCoeff(long n, long k)
    {
        long res = 1;
        if(k>n)
        	return 0;
        // Since C(n, k) = C(n, n-k)
        if (k > n - k)
            k = n - k;
 
        // Calculate value of
        // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
        for (long i = 0; i < k; ++i) {
            res *= (n - i);
            res /= (i + 1);
        }
 
        return res;
    }
	static class FastReader
	{
        byte[] buf = new byte[2048];
        int index, total;
        InputStream in;
 
        FastReader(InputStream is) 
        {
            in = is;
        }
 
        int scan() throws IOException 
        {
            if (index >= total) {
                index = 0;
                total = in.read(buf);
                if (total <= 0) {
                    return -1;
                }
            }
            return buf[index++];
        }
 
        String next() throws IOException 
        {
            int c;
            for (c = scan(); c <= 32; c = scan());
            StringBuilder sb = new StringBuilder();
            for (; c > 32; c = scan()) {
                sb.append((char) c);
            }
            return sb.toString();
        }
 
        int nextInt() throws IOException 
        {
            int c, val = 0;
            for (c = scan(); c <= 32; c = scan());
            boolean neg = c == '-';
            if (c == '-' || c == '+') {
                c = scan();
            }
            for (; c >= '0' && c <= '9'; c = scan()) {
                val = (val << 3) + (val << 1) + (c & 15);
            }
            return neg ? -val : val;
        }
 
        long nextLong() throws IOException 
        {
            int c;
            long val = 0;
            for (c = scan(); c <= 32; c = scan());
            boolean neg = c == '-';
            if (c == '-' || c == '+') {
                c = scan();
            }
            for (; c >= '0' && c <= '9'; c = scan()) {
                val = (val << 3) + (val << 1) + (c & 15);
            }
            return neg ? -val : val;
        }
    }
	static class Reader 
	{
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;
 
        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
 
        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(
                new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
 
        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n') {
                    if (cnt != 0) {
                        break;
                    }
                    else {
                        continue;
                    }
                }
                buf[cnt++] = (byte)c;
            }
            return new String(buf, 0, cnt);
        }
 
        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
 
            if (neg)
                return -ret;
            return ret;
        }
 
        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }
 
        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
 
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
 
            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }
 
            if (neg)
                return -ret;
            return ret;
        }
 
        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0,
                                 BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }
 
        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }
 
        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
        public void printarray(int arr[])
        {
        	for (int i = 0; i < arr.length; i++)
				System.out.print(arr[i]+" ");
        	System.out.println();
        }
    }
}








