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.*;
  import java.math.BigInteger;
  import java.util.StringTokenizer;
  
  import static java.lang.Double.parseDouble;
  import static java.lang.Integer.parseInt;
  import static java.lang.Long.parseLong;
  import static java.lang.System.getProperty;
  import static java.lang.System.in;
  import static java.math.BigInteger.valueOf;
  
  public class FindArray {
  
      public static void main(String[] args) {
          try (FastScanner scanner = getProperty("ONLINE_JUDGE", "").isEmpty() ? new FastScanner(new File("test.txt")) : new FastScanner(in)) {
              int T = scanner.nextInt();
              for (int t = 1; t <= T; ++t) {
                  int N = scanner.nextInt();
                  int[] a = new FindArray(N).solve();
                  for (int i = 0; i < N - 1; ++i) {
                      System.out.print(a[i] + " ");
                  }
                  System.out.println(a[N-1]);
              }
          }
          catch (Exception e) {
              e.printStackTrace();
          }
      }
  
      private int[] solve() {
          int[] a = new int[N];
          for (int i = 0; i < N; ++i) {
              a[i] = i + 2;
          }
  
          return a;
      }
  
      private final int N;
  
      public FindArray(int n) {
          N = n;
      }
  
      /**
       * Modulo class for facebook HackerCup.
       */
      private static class Modulo extends BaseModulo<Modulo> {
  
          public static final long MODULO = 1000000007;
  
          public Modulo(BigInteger v) {
              super(v.mod(valueOf(MODULO)).longValue(), MODULO);
          }
  
          public Modulo(long v) {
              super(v, MODULO);
          }
  
          private Modulo() {
              super(MODULO);
          }
  
          @Override
          public Modulo factory(long value) {
              return new Modulo(value);
          }
  
      }
  
      private abstract static class BaseModulo<T> {
  
          // public so we don't need a getter
          public final long value;
  
          private final long       mod;
          private final BigInteger bigMod;
  
          public BaseModulo(long v, long mod) {
              this.mod    = mod;
              this.bigMod = valueOf(mod);
              v %= mod;
              if (v < 0) {
                  v += mod;
              }
              value = v;
          }
  
          public BaseModulo(long mod) {
              this.mod    = mod;
              this.bigMod = valueOf(mod);
              value       = 0;
          }
  
          public T add(BigInteger v) {
              return add(v.mod(bigMod).longValue());
          }
  
          public T add(long v) {
              return factory(value + (v % mod));
          }
  
          public abstract T factory(long value);
  
          public T add(Modulo modulo) {
              return add(modulo.value);
          }
  
          public T subtract(BigInteger v) {
              return subtract(v.mod(bigMod).longValue());
          }
  
          public T subtract(long v) {
              return factory(value - (v % mod));
          }
  
          public T subtract(Modulo modulo) {
              return subtract(modulo.value);
          }
  
          public T twice() {
              return factory(value << 1);
          }
  
          public T halve() {
              return factory(value >> 1);
          }
  
          public T shiftLeft(long v) {
              return factory(value << v);
          }
  
          public T shiftRight(long v) {
              return factory(value >> v);
          }
  
          public T multiply(Modulo modulo) {
              return multiply(modulo.value);
          }
  
          public T multiply(long v) {
              return factory(value * (v % mod));
          }
  
          public T divide(Modulo modulo) {
              return divide(modulo.value);
          }
  
          // Function to compute this/b under modulo mod
          public T divide(long v) {
              return divide(valueOf(v));
          }
  
          public T divide(BigInteger v) {
              v = v.modInverse(bigMod);
              return multiply(v);
          }
  
          public T multiply(BigInteger v) {
              return multiply(v.mod(bigMod).longValue());
          }
  
          public T pow(Modulo v) {
              return pow(v.value);
          }
  
          // Function to compute this^v under modulo mod
          public T pow(long v) {
              return pow(valueOf(v));
          }
  
          public T pow(BigInteger v) {
              return factory(valueOf(value).modPow(v, bigMod).longValue());
          }
  
      }
  
      static class FastScanner implements AutoCloseable {
          final BufferedReader bufferedReader;
          StringTokenizer stringTokenizer;
  
          private FastScanner(File file) throws FileNotFoundException {
              bufferedReader = new BufferedReader(new FileReader(file));
          }
  
          private FastScanner(InputStream in) {
              bufferedReader = new BufferedReader(new InputStreamReader(in));
          }
  
          @Override
          public void close() throws Exception {
              bufferedReader.close();
          }
  
          public double nextDouble() throws IOException {
              return parseDouble(nextToken());
          }
  
          private String nextToken() throws IOException {
              while (stringTokenizer == null || !stringTokenizer.hasMoreTokens()) {
                  stringTokenizer = new StringTokenizer(bufferedReader.readLine());
              }
              return stringTokenizer.nextToken();
          }
  
          public int[] nextIntArray(int n) throws IOException {
              int[] res = new int[n];
              for (int i = 0; i < n; ++i) {
                  res[i] = nextInt();
              }
              return res;
          }
  
          public int nextInt() throws IOException {
              return parseInt(nextToken(), 10);
          }
  
          public long[] nextLongArray(int n) throws IOException {
              long[] res = new long[n];
              for (int i = 0; i < n; ++i) {
                  res[i] = nextLong();
              }
              return res;
          }
  
          public long nextLong() throws IOException {
              return parseLong(nextToken(), 10);
          }
  
          public String[] nextStringArray(int n) throws IOException {
              String[] res = new String[n];
              for (int i = 0; i < n; ++i) {
                  res[i] = nextString();
              }
              return res;
          }
  
          public String nextString() throws IOException {
              return nextToken();
          }
  
      }
  }
  
  