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: import java.io.OutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.PrintWriter;
  import java.util.Arrays;
  import java.io.BufferedWriter;
  import java.util.Collection;
  import java.util.InputMismatchException;
  import java.io.IOException;
  import java.io.Writer;
  import java.io.OutputStreamWriter;
  import java.util.NoSuchElementException;
  import java.io.InputStream;
  
  /**
   * Built using CHelper plug-in
   * Actual solution is at the top
   */
  public class Main {
      public static void main(String[] args) {
          InputStream inputStream = System.in;
          OutputStream outputStream = System.out;
          InputReader in = new InputReader(inputStream);
          OutputWriter out = new OutputWriter(outputStream);
          BCharmedByTheGame solver = new BCharmedByTheGame();
          solver.solve(1, in, out);
          out.close();
      }
  
      static class BCharmedByTheGame {
          public void solve(int testNumber, InputReader in, OutputWriter out) {
              int tc = in.nextInt();
              for (int i = 0; i < tc; i++) {
                  int a = in.nextInt();
                  int b = in.nextInt();
  
                  int totalGames = a + b;
                  int h = totalGames / 2;
  
                  EzIntSortedSet ez = new EzIntTreeSet();
                  // how many ways are there of distributing p
  
                  //int h or h + 1 = breaks away from you
                  h += totalGames % 2;
  
                  // b serves first, a has max h breaks;
                  for (int x = 0; x < 2; x++) {
                      int mina = 0;
                      int maxa = 0;
                      if (a < h) {
                          mina = 0;
                          maxa = a;
                      }
  
                      if (a >= h) {
                          mina = a - (totalGames - h);
                          maxa = h;
                      }
  
                      for (int j = mina; j <= maxa; j++) {
                          int bonb = h - j;
                          int totalbreaks = b - bonb + j;
                          ez.add(totalbreaks);
                      }
                      int tmp = b;
                      b = a;
                      a = tmp;
                  }
                  out.println(ez.size());
                  out.println(ez.toArray());
              }
          }
  
      }
  
      static class InputReader {
          private InputStream stream;
          private byte[] buf = new byte[1024];
          private int curChar;
          private int numChars;
          private InputReader.SpaceCharFilter filter;
  
          public InputReader(InputStream stream) {
              this.stream = stream;
          }
  
          public int read() {
              if (numChars == -1) {
                  throw new InputMismatchException();
              }
              if (curChar >= numChars) {
                  curChar = 0;
                  try {
                      numChars = stream.read(buf);
                  } catch (IOException e) {
                      throw new InputMismatchException();
                  }
                  if (numChars <= 0) {
                      return -1;
                  }
              }
              return buf[curChar++];
          }
  
          public int nextInt() {
              int c = read();
              while (isSpaceChar(c)) {
                  c = read();
              }
              int sgn = 1;
              if (c == '-') {
                  sgn = -1;
                  c = read();
              }
              int res = 0;
              do {
                  if (c < '0' || c > '9') {
                      throw new InputMismatchException();
                  }
                  res *= 10;
                  res += c - '0';
                  c = read();
              } while (!isSpaceChar(c));
              return res * sgn;
          }
  
          public boolean isSpaceChar(int c) {
              if (filter != null) {
                  return filter.isSpaceChar(c);
              }
              return isWhitespace(c);
          }
  
          public static boolean isWhitespace(int c) {
              return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
          }
  
          public interface SpaceCharFilter {
              public boolean isSpaceChar(int ch);
  
          }
  
      }
  
      static interface EzIntSortedSet extends EzIntSet {
          int size();
  
          EzIntIterator iterator();
  
          int[] toArray();
  
          boolean add(int element);
  
          boolean equals(Object object);
  
          int hashCode();
  
          String toString();
  
      }
  
      static interface EzIntCollection {
          int size();
  
          EzIntIterator iterator();
  
          boolean equals(Object object);
  
          int hashCode();
  
          String toString();
  
      }
  
      static class EzIntTreeSet implements EzIntSortedSet {
          private static final int DEFAULT_CAPACITY = 10;
          private static final double ENLARGE_SCALE = 2.0;
          private static final int HASHCODE_INITIAL_VALUE = 0x811c9dc5;
          private static final int HASHCODE_MULTIPLIER = 0x01000193;
          private static final boolean BLACK = false;
          private static final boolean RED = true;
          private static final int NULL = 0;
          private int[] key;
          private int[] left;
          private int[] right;
          private int[] p;
          private boolean[] color;
          private int size;
          private int root;
          private boolean returnedNull;
  
          public EzIntTreeSet() {
              this(DEFAULT_CAPACITY);
          }
  
          public EzIntTreeSet(int capacity) {
              if (capacity < 0) {
                  throw new IllegalArgumentException("Capacity must be non-negative");
              }
              capacity++;
              key = new int[capacity];
              left = new int[capacity];
              right = new int[capacity];
              p = new int[capacity];
              color = new boolean[capacity];
              color[NULL] = BLACK;
              size = 0;
              root = NULL;
              returnedNull = false;
          }
  
          public EzIntTreeSet(EzIntCollection collection) {
              this(collection.size());
              for (EzIntIterator iterator = collection.iterator(); iterator.hasNext(); ) {
                  add(iterator.next());
              }
          }
  
          public EzIntTreeSet(int[] srcArray) {
              this(srcArray.length);
              for (int element : srcArray) {
                  add(element);
              }
          }
  
          public EzIntTreeSet(Collection<Integer> javaCollection) {
              this(javaCollection.size());
              for (int element : javaCollection) {
                  add(element);
              }
          }
  
          public int size() {
              return size;
          }
  
          public EzIntIterator iterator() {
              return new EzIntTreeSetIterator();
          }
  
          public int[] toArray() {
              int[] result = new int[size];
              for (int i = 0, x = firstNode(); x != NULL; x = successorNode(x), i++) {
                  result[i] = key[x];
              }
              return result;
          }
  
          public boolean add(int element) {
              int y = NULL;
              int x = root;
              while (x != NULL) {
                  //noinspection SuspiciousNameCombination
                  y = x;
                  if (element < key[x]) {
                      x = left[x];
                  } else if (element > key[x]) {
                      x = right[x];
                  } else {
                      return false;
                  }
              }
              if (size == color.length - 1) {
                  enlarge();
              }
              int z = ++size;
              key[z] = element;
              p[z] = y;
              if (y == NULL) {
                  root = z;
              } else {
                  if (element < key[y]) {
                      left[y] = z;
                  } else {
                      right[y] = z;
                  }
              }
              left[z] = NULL;
              right[z] = NULL;
              color[z] = RED;
              fixAfterAdd(z);
              return true;
          }
  
          private int successorNode(int x) {
              if (right[x] != NULL) {
                  x = right[x];
                  while (left[x] != NULL) {
                      x = left[x];
                  }
                  return x;
              } else {
                  int y = p[x];
                  while (y != NULL && x == right[y]) {
                      //noinspection SuspiciousNameCombination
                      x = y;
                      y = p[y];
                  }
                  return y;
              }
          }
  
          private void fixAfterAdd(int z) {
              while (color[p[z]] == RED) {
                  if (p[z] == left[p[p[z]]]) {
                      int y = right[p[p[z]]];
                      if (color[y] == RED) {
                          color[p[z]] = BLACK;
                          color[y] = BLACK;
                          color[p[p[z]]] = RED;
                          z = p[p[z]];
                      } else {
                          if (z == right[p[z]]) {
                              z = p[z];
                              rotateLeft(z);
                          }
                          color[p[z]] = BLACK;
                          color[p[p[z]]] = RED;
                          rotateRight(p[p[z]]);
                      }
                  } else {
                      int y = left[p[p[z]]];
                      if (color[y] == RED) {
                          color[p[z]] = BLACK;
                          color[y] = BLACK;
                          color[p[p[z]]] = RED;
                          z = p[p[z]];
                      } else {
                          if (z == left[p[z]]) {
                              z = p[z];
                              rotateRight(z);
                          }
                          color[p[z]] = BLACK;
                          color[p[p[z]]] = RED;
                          rotateLeft(p[p[z]]);
                      }
                  }
              }
              color[root] = BLACK;
          }
  
          private void rotateLeft(int x) {
              int y = right[x];
              right[x] = left[y];
              if (left[y] != NULL) {
                  p[left[y]] = x;
              }
              p[y] = p[x];
              if (p[x] == NULL) {
                  root = y;
              } else {
                  if (x == left[p[x]]) {
                      left[p[x]] = y;
                  } else {
                      right[p[x]] = y;
                  }
              }
              left[y] = x;
              p[x] = y;
          }
  
          private void rotateRight(int x) {
              int y = left[x];
              left[x] = right[y];
              if (right[y] != NULL) {
                  p[right[y]] = x;
              }
              p[y] = p[x];
              if (p[x] == NULL) {
                  root = y;
              } else {
                  if (x == right[p[x]]) {
                      right[p[x]] = y;
                  } else {
                      left[p[x]] = y;
                  }
              }
              right[y] = x;
              p[x] = y;
          }
  
          private void enlarge() {
              int newLength = Math.max(color.length + 1, (int) (color.length * ENLARGE_SCALE));
              key = Arrays.copyOf(key, newLength);
              left = Arrays.copyOf(left, newLength);
              right = Arrays.copyOf(right, newLength);
              p = Arrays.copyOf(p, newLength);
              color = Arrays.copyOf(color, newLength);
          }
  
          private int firstNode() {
              int x = root;
              while (left[x] != NULL) {
                  x = left[x];
              }
              return x;
          }
  
          public boolean equals(Object o) {
              if (this == o) return true;
              if (o == null || getClass() != o.getClass()) return false;
              EzIntTreeSet that = (EzIntTreeSet) o;
  
              if (size != that.size) {
                  return false;
              }
              for (int x = firstNode(), y = that.firstNode();
                   x != NULL;
                  //noinspection SuspiciousNameCombination
                   x = successorNode(x), y = that.successorNode(y)
              ) {
                  if (key[x] != that.key[y]) {
                      return false;
                  }
              }
              return true;
          }
  
          public int hashCode() {
              int hash = HASHCODE_INITIAL_VALUE;
              for (int x = firstNode(); x != NULL; x = successorNode(x)) {
                  hash = (hash ^ PrimitiveHashCalculator.getHash(key[x])) * HASHCODE_MULTIPLIER;
              }
              return hash;
          }
  
          public String toString() {
              StringBuilder sb = new StringBuilder();
              sb.append('[');
              for (int x = firstNode(); x != NULL; x = successorNode(x)) {
                  if (sb.length() > 1) {
                      sb.append(", ");
                  }
                  sb.append(key[x]);
              }
              sb.append(']');
              return sb.toString();
          }
  
          private class EzIntTreeSetIterator implements EzIntIterator {
              private int x;
  
              private EzIntTreeSetIterator() {
                  x = firstNode();
              }
  
              public boolean hasNext() {
                  return x != NULL;
              }
  
              public int next() {
                  if (x == NULL) {
                      throw new NoSuchElementException("Iterator doesn't have more elements");
                  }
                  final int result = key[x];
                  x = successorNode(x);
                  return result;
              }
  
          }
  
      }
  
      static interface EzIntIterator {
          boolean hasNext();
  
          int next();
  
      }
  
      static class OutputWriter {
          private final PrintWriter writer;
  
          public OutputWriter(OutputStream outputStream) {
              writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
          }
  
          public OutputWriter(Writer writer) {
              this.writer = new PrintWriter(writer);
          }
  
          public void print(int[] array) {
              for (int i = 0; i < array.length; i++) {
                  if (i != 0) {
                      writer.print(' ');
                  }
                  writer.print(array[i]);
              }
          }
  
          public void println(int[] array) {
              print(array);
              writer.println();
          }
  
          public void close() {
              writer.close();
          }
  
          public void println(int i) {
              writer.println(i);
          }
  
      }
  
      static final class PrimitiveHashCalculator {
          private PrimitiveHashCalculator() {
          }
  
          public static int getHash(int x) {
              return x;
          }
  
      }
  
      static interface EzIntSet extends EzIntCollection {
          int size();
  
          EzIntIterator iterator();
  
          boolean equals(Object object);
  
          int hashCode();
  
          String toString();
  
      }
  }
  
  