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: #include <bits/stdc++.h>
  #pragma GCC optimize("Ofast")
  #pragma GCC optimize("unroll-loops")
  #pragma GCC optimize("inline")
  using namespace std;
  inline int my_getchar() {
    static char buf[1048576];
    static int s = 1048576;
    static int e = 1048576;
    if (s == e && e == 1048576) {
      e = fread(buf, 1, 1048576, stdin);
      s = 0;
    }
    if (s == e) {
      return EOF;
    }
    return buf[s++];
  }
  inline void rd(int &x) {
    int k;
    int m = 0;
    x = 0;
    for (;;) {
      k = my_getchar();
      if (k == '-') {
        m = 1;
        break;
      }
      if ('0' <= k && k <= '9') {
        x = k - '0';
        break;
      }
    }
    for (;;) {
      k = my_getchar();
      if (k < '0' || k > '9') {
        break;
      }
      x = x * 10 + k - '0';
    }
    if (m) {
      x = -x;
    }
  }
  inline int rd_int(void) {
    int x;
    rd(x);
    return x;
  }
  struct MY_WRITER {
    char buf[1048576];
    int s;
    int e;
    MY_WRITER() {
      s = 0;
      e = 1048576;
    }
    ~MY_WRITER() {
      if (s) {
        fwrite(buf, 1, s, stdout);
      }
    }
  };
  MY_WRITER MY_WRITER_VAR;
  void my_putchar(int a) {
    if (MY_WRITER_VAR.s == MY_WRITER_VAR.e) {
      fwrite(MY_WRITER_VAR.buf, 1, MY_WRITER_VAR.s, stdout);
      MY_WRITER_VAR.s = 0;
    }
    MY_WRITER_VAR.buf[MY_WRITER_VAR.s++] = a;
  }
  inline void wt_L(char a) { my_putchar(a); }
  inline void wt_L(int x) {
    int s = 0;
    int m = 0;
    char f[10];
    if (x < 0) {
      m = 1;
      x = -x;
    }
    while (x) {
      f[s++] = x % 10;
      x /= 10;
    }
    if (!s) {
      f[s++] = 0;
    }
    if (m) {
      my_putchar('-');
    }
    while (s--) {
      my_putchar(f[s] + '0');
    }
  }
  int main() {
    int Lj4PdHRW;
    int KL2GvlyY = rd_int();
    for (Lj4PdHRW = (0); Lj4PdHRW < (KL2GvlyY); Lj4PdHRW++) {
      int i;
      int N;
      rd(N);
      int res[N];
      for (i = (0); i < (N); i++) {
        res[i] = i + 2;
      }
      {
        int FmcKpFmN;
        if (N == 0) {
          wt_L('\n');
        } else {
          for (FmcKpFmN = (0); FmcKpFmN < (N - 1); FmcKpFmN++) {
            wt_L(res[FmcKpFmN]);
            wt_L(' ');
          }
          wt_L(res[FmcKpFmN]);
          wt_L('\n');
        }
      }
    }
    return 0;
  }
  