description: 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. 
solution: // HOPE
  
  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  //----------------------------------------------------------------------------------------------------------------------
  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  //----------------------------------------------------------------------------------------------------------------------
  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  ///////                                                                                                       //////////
  ///////                                                                                                       //////////
  ///////            RRRRRRRRRRRRR     YY          YY         AA               NN         NN                    //////////
  ///////            RR         RR      YY        YY        AA  AA             NN NN      NN                    //////////
  ///////            RR        RR         YY     YY        AA    AA            NN  NN     NN                    //////////
  ///////            RRRRRRRRRR            YY   YY       AAAAAAAAAAAA          NN    NN   NN                    //////////
  ///////            RR RR                   YY         AAAAAAAAAAAAAA         NN      NN NN                    //////////
  ///////            RR   RR                 YY        AA            AA        NN       NNNN                    //////////
  ///////            RR     RR               YY       AA              AA       NN         NN                    //////////
  ///////            RR       RR_____________________________________________________________________________   //////////
  ////////                                                                                                      //////////
  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  //----------------------------------------------------------------------------------------------------------------------
  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  //----------------------------------------------------------------------------------------------------------------------
  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.math.BigInteger;
  import java.util.*;
  
  public class Codeforces2 {
      static final int mod=1_000_000_007;
  
      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());
          }
  
          long nextLong() {
              return Long.parseLong(next());
          }
  
          double nextDouble() {
              return Double.parseDouble(next());
          }
  
          String nextLine() {
              String str = "";
              try {
                  str = br.readLine();
              } catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
  
      public static void main(String[] args) {
          FastReader s = new FastReader();
          int t = s.nextInt();
          while(t-->0)
          {
              int a = s.nextInt();
              int b = s.nextInt();
              find(a, b);
          }
      }
  
      public static void find(int a, int b)
      {
          Set<Integer> hs = new TreeSet<>();
          int total = a + b;//Total Matches
          int f = total/2;
          int s = total - f;
  
          //B-A-B-A-B
          //Team1 for A and Team2 for B
          for(int i=0;i<=Math.min(a, f);i++)
          {
              if(a-i<=s)
                  hs.add(f-i + a-i);
          }
  
          //A-B-A-B-A
          //Team2 for A and Team1 for B
          for(int i=0;i<=Math.min(a, s);i++)
          {
              if(a-i<=f)
                  hs.add(s-i + a-i);
          }
          System.out.println(hs.size());
          for(int x:hs)
              System.out.print(x+" ");
  
          System.out.println();
  
      }
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
      /////////////////////////////////////////////////THE END///////////////////////////////////////////////////////////
      //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
      public static int gcd(int x,int y)
      {
          return y==0?x:gcd(y,x%y);
      }
      public static long gcd(long x,long y)
      {
          return y==0L?x:gcd(y,x%y);
      }
  
      public static int lcm(int a, int b) {
          return (a * b) / gcd(a, b);
      }
      public static long lcm(long a, long b) {
          return (a * b) / gcd(a, b);
      }
  
      public static long pow(long a,long b)
      {
          if(b==0L)
              return 1L;
          long tmp=1;
          while(b>1L)
          {
              if((b&1L)==1)
                  tmp*=a;
              a*=a;
              b>>=1;
          }
          return (tmp*a);
      }
  
      public static long modPow(long a,long b,long mod)
      {
          if(b==0L)
              return 1L;
          long tmp=1;
          while(b>1L)
          {
              if((b&1L)==1L)
                  tmp*=a;
  
              a*=a;
              a%=mod;
              tmp%=mod;
              b>>=1;
          }
          return (tmp*a)%mod;
      }
  
      static long mul(long a, long b) {
          return a*b%mod;
      }
  
      static long fact(int n) {
          long ans=1;
          for (int i=2; i<=n; i++) ans=mul(ans, i);
          return ans;
      }
  
      static long fastPow(long base, long exp) {
          if (exp==0) return 1;
          long half=fastPow(base, exp/2);
          if (exp%2==0) return mul(half, half);
          return mul(half, mul(half, base));
      }
  
      static boolean check(int n,int d)//check for digit 7 in 504732 number
      {
          String s = n+"";
          return s.contains(d + "");
      }
      static void reverseArray(int[] a) {
          int n = a.length;
          int[] arr = new int[n];
          for (int i = 0; i < n; i++)
              arr[i] = a[n - i - 1];
          for (int i = 0; i < n; i++)
              a[i] = arr[i];
      }
  
      static void reverseArray(long[] a) {
          int n = a.length;
          long[] arr = new long[n];
          for (int i = 0; i < n; i++)
              arr[i] = a[n - i - 1];
          for (int i = 0; i < n; i++)
              a[i] = arr[i];
      }
  
      static class Pair{
          int x, y;
          Pair(int x, int y)
          {
              this.x = x;
              this.y = y;
          }
  
          @Override
          public String toString() {
              return "Pair{" +
                      "x=" + x +
                      ", y=" + y +
                      '}';
          }
      }
      static class MyCmp implements Comparator<Pair>
      {
          public int compare(Pair p1, Pair p2)
          {
              return p1.x-p2.x;
          }
      }
  }
  