description: Given n, find any array a_1, a_2, …, a_n of integers such that all of the following conditions hold: 
  
    * 1 ≤ a_i ≤ 10^9 for every i from 1 to n.
  
    * a_1 < a_2 < … <a_n
  
    * For every i from 2 to n, a_i isn't divisible by a_{i-1}
  
  
  
  
  It can be shown that such an array always exists under the constraints of the problem.
  
  Input
  
  The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
  
  The only line of each test case contains a single integer n (1 ≤ n ≤ 1000).
  
  It is guaranteed that the sum of n over all test cases does not exceed 10^4.
  
  Output
  
  For each test case print n integers a_1, a_2, …, a_n — the array you found. If there are multiple arrays satisfying all the conditions, print any of them.
  
  Example
  
  Input
  
  
  3
  1
  2
  7
  
  
  Output
  
  
  1
  2 3
  111 1111 11111 111111 1111111 11111111 111111111
  
  Note
  
  In the first test case, array [1] satisfies all the conditions.
  
  In the second test case, array [2, 3] satisfies all the conditions, as 2<3 and 3 is not divisible by 2.
  
  In the third test case, array [111, 1111, 11111, 111111, 1111111, 11111111, 111111111] satisfies all the conditions, as it's increasing and a_i isn't divisible by a_{i-1} for any i from 2 to 7.
solution: import java.io.IOException;
  import java.io.InputStream;
  import java.util.Arrays;
  import java.util.InputMismatchException;
  
  public class CF_1112 {
  
      public static void main(String[] args) {
          StringBuilder output = new StringBuilder();
          int testcase = ni();
          for (int t = 0; t < testcase; t++) {
              int n = ni();
              if (n == 1) {
                  output.append(1).append("\n");
              } else {
                  int[] numbers = new int[n];
                  numbers[0] = 2;
                  output.append(numbers[0]);
                  for (int i = 1; i < numbers.length; i++) {
                      numbers[i] = numbers[i - 1] + 1;
                      output.append(" ").append(numbers[i]);
                  }
                  output.append("\n");
              }
          }
          System.out.println(output);
      }
  
      static InputStream is = System.in;
      static byte[] inbuf = new byte[1 << 24];
      static int lenbuf = 0, ptrbuf = 0;
  
      static int readByte() {
          if (lenbuf == -1)
              throw new InputMismatchException();
          if (ptrbuf >= lenbuf) {
              ptrbuf = 0;
              try {
                  lenbuf = is.read(inbuf);
              } catch (IOException e) {
                  throw new InputMismatchException();
              }
              if (lenbuf <= 0)
                  return -1;
          }
          return inbuf[ptrbuf++];
      }
  
      static boolean isSpaceChar(int c) {
          return !(c >= 33 && c <= 126);
      }
  
      static int skip() {
          int b;
          while ((b = readByte()) != -1 && isSpaceChar(b))
              ;
          return b;
      }
  
      static double nd() {
          return Double.parseDouble(ns());
      }
  
      static char nc() {
          return (char) skip();
      }
  
      static String ns() {
          int b = skip();
          StringBuilder sb = new StringBuilder();
          while (!(isSpaceChar(b))) {
              sb.appendCodePoint(b);
              b = readByte();
          }
          return sb.toString();
      }
  
      static char[] ns(int n) {
          char[] buf = new char[n];
          int b = skip(), p = 0;
          while (p < n && !(isSpaceChar(b))) {
              buf[p++] = (char) b;
              b = readByte();
          }
          return n == p ? buf : Arrays.copyOf(buf, p);
      }
  
      static int ni() {
          int num = 0, b;
          boolean minus = false;
          while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
              ;
          if (b == '-') {
              minus = true;
              b = readByte();
          }
          while (true) {
              if (b >= '0' && b <= '9') {
                  num = num * 10 + (b - '0');
              } else {
                  return minus ? -num : num;
              }
              b = readByte();
          }
      }
  
      static long nl() {
          long num = 0;
          int b;
          boolean minus = false;
          while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
              ;
          if (b == '-') {
              minus = true;
              b = readByte();
          }
          while (true) {
              if (b >= '0' && b <= '9') {
                  num = num * 10 + (b - '0');
              } else {
                  return minus ? -num : num;
              }
              b = readByte();
          }
      }
  }
  