#include <bits/stdc++.h>
namespace Templates {
namespace InputOutput {
template <typename Tp>
inline void input(Tp &x) {
  static bool k;
  static char ch;
  for (k = 0, ch = getchar(); ch < '0' || '9' < ch; ch = getchar())
    if (ch == '-') k = 1;
  for (x = 0; '0' <= ch && ch <= '9'; ch = getchar())
    x = (x << 1) + (x << 3) + ch - '0';
  if (k) x = -x;
}
char Flof[97], emptyc = '\n';
int Fcnto;
template <typename Tp>
inline void output(Tp x, const char &ch = emptyc) {
  Fcnto = 0;
  if (!x) return (void)(putchar('0'), putchar(ch));
  if (x < 0) x = -x, putchar('-');
  while (x) Flof[Fcnto++] = x % 10 + '0', x /= 10;
  while (Fcnto) putchar(Flof[--Fcnto]);
  putchar(ch);
}
}  // namespace InputOutput
using namespace InputOutput;
namespace Containers {
template <typename Tp, const int SZ, typename comp = std::less<Tp> >
struct Priority_Queue {
  Tp q[SZ];
  int tail;
  Priority_Queue() { tail = 0; }
  void clear() { tail = 0; }
  inline bool empty() { return tail < 1; }
  inline int size() { return tail; }
  inline void push(const Tp &x) {
    q[tail++] = x, std::push_heap(q, q + tail, comp());
  }
  inline void pop() { std::pop_heap(q, q + tail, comp()), tail--; }
  inline Tp top() { return q[0]; }
};
template <typename Tp, const int SZ>
struct Queue {
  Tp q[SZ];
  int head, tail;
  Queue() { head = 1, tail = 0; }
  void clear() { head = 1, tail = 0; }
  inline bool empty() { return head > tail; }
  inline int size() { return tail - head + 1; }
  inline void push(const Tp &x) { q[++tail] = x; }
  inline void pop() { head++; }
  inline Tp front() { return q[head]; }
};
template <typename Tp, const int SZ>
struct Deque {
  Tp q[SZ << 1];
  int head, tail;
  Deque() { head = SZ + 1, tail = SZ; }
  void clear() { head = SZ + 1, tail = SZ; }
  inline bool empty() { return head > tail; }
  inline int size() { return tail - head + 1; }
  inline void push_front(const Tp &x) { q[--head] = x; }
  inline void push_back(const Tp &x) { q[++tail] = x; }
  inline void pop_front() { head++; }
  inline void pop_back() { tail--; }
  inline Tp front() { return q[head]; }
  inline Tp back() { return q[tail]; }
};
template <typename Tp, const int SZ>
struct Stack {
  Tp q[SZ];
  int tail;
  Stack() { tail = 0; }
  void clear() { tail = 0; }
  inline bool empty() { return tail <= 0; }
  inline int size() { return tail; }
  inline void push(const Tp &x) { q[++tail] = x; }
  inline void pop() { tail--; }
  inline Tp top() { return q[tail]; }
};
template <typename Tp, const int SZ>
struct BIT {
  int n;
  Tp c[SZ];
  BIT(const int sz = SZ - 1) { n = sz, memset(c, 0, sizeof c); }
  void clear(const int sz = SZ - 1) { n = sz, memset(c, 0, sizeof c); }
  inline void add(int x, const Tp &val) {
    while (x <= n) c[x] += val, x += x & -x;
  }
  inline Tp sum(int x) {
    Tp s = 0;
    while (x) s += c[x], x -= x & -x;
    return s;
  }
  inline Tp sum(const int x, const int y) { return sum(y) - sum(x - 1); }
};
}  // namespace Containers
using namespace Containers;
using std::bitset;
using std::get;
using std::lower_bound;
using std::max;
using std::min;
using std::pair;
using std::sort;
using std::swap;
using std::tuple;
using std::upper_bound;
using std::vector;
template <typename Tp>
Tp gcd(Tp a, Tp b) {
  Tp t;
  while (b) t = a, a = b, b = t % b;
  return a;
}
template <typename Tp>
Tp lcm(const Tp a, const Tp b) {
  return a / gcd(a, b) * b;
}
template <typename Tp>
void tomax(Tp &x, const Tp y) {
  x = std::max(x, y);
}
}  // namespace Templates
using namespace Templates;
int n;
void solve() {
  input(n);
  for (int i = 1; i <= n; i++) output(i + 1, i == n ? '\n' : ' ');
}
int main() {
  int caseCount;
  input(caseCount);
  while (caseCount--) solve();
  return 0;
}

### Prompt

Create a solution in CPP for the following problem:

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.

### Response

```cpp
#include <bits/stdc++.h>
namespace Templates {
namespace InputOutput {
template <typename Tp>
inline void input(Tp &x) {
  static bool k;
  static char ch;
  for (k = 0, ch = getchar(); ch < '0' || '9' < ch; ch = getchar())
    if (ch == '-') k = 1;
  for (x = 0; '0' <= ch && ch <= '9'; ch = getchar())
    x = (x << 1) + (x << 3) + ch - '0';
  if (k) x = -x;
}
char Flof[97], emptyc = '\n';
int Fcnto;
template <typename Tp>
inline void output(Tp x, const char &ch = emptyc) {
  Fcnto = 0;
  if (!x) return (void)(putchar('0'), putchar(ch));
  if (x < 0) x = -x, putchar('-');
  while (x) Flof[Fcnto++] = x % 10 + '0', x /= 10;
  while (Fcnto) putchar(Flof[--Fcnto]);
  putchar(ch);
}
}  // namespace InputOutput
using namespace InputOutput;
namespace Containers {
template <typename Tp, const int SZ, typename comp = std::less<Tp> >
struct Priority_Queue {
  Tp q[SZ];
  int tail;
  Priority_Queue() { tail = 0; }
  void clear() { tail = 0; }
  inline bool empty() { return tail < 1; }
  inline int size() { return tail; }
  inline void push(const Tp &x) {
    q[tail++] = x, std::push_heap(q, q + tail, comp());
  }
  inline void pop() { std::pop_heap(q, q + tail, comp()), tail--; }
  inline Tp top() { return q[0]; }
};
template <typename Tp, const int SZ>
struct Queue {
  Tp q[SZ];
  int head, tail;
  Queue() { head = 1, tail = 0; }
  void clear() { head = 1, tail = 0; }
  inline bool empty() { return head > tail; }
  inline int size() { return tail - head + 1; }
  inline void push(const Tp &x) { q[++tail] = x; }
  inline void pop() { head++; }
  inline Tp front() { return q[head]; }
};
template <typename Tp, const int SZ>
struct Deque {
  Tp q[SZ << 1];
  int head, tail;
  Deque() { head = SZ + 1, tail = SZ; }
  void clear() { head = SZ + 1, tail = SZ; }
  inline bool empty() { return head > tail; }
  inline int size() { return tail - head + 1; }
  inline void push_front(const Tp &x) { q[--head] = x; }
  inline void push_back(const Tp &x) { q[++tail] = x; }
  inline void pop_front() { head++; }
  inline void pop_back() { tail--; }
  inline Tp front() { return q[head]; }
  inline Tp back() { return q[tail]; }
};
template <typename Tp, const int SZ>
struct Stack {
  Tp q[SZ];
  int tail;
  Stack() { tail = 0; }
  void clear() { tail = 0; }
  inline bool empty() { return tail <= 0; }
  inline int size() { return tail; }
  inline void push(const Tp &x) { q[++tail] = x; }
  inline void pop() { tail--; }
  inline Tp top() { return q[tail]; }
};
template <typename Tp, const int SZ>
struct BIT {
  int n;
  Tp c[SZ];
  BIT(const int sz = SZ - 1) { n = sz, memset(c, 0, sizeof c); }
  void clear(const int sz = SZ - 1) { n = sz, memset(c, 0, sizeof c); }
  inline void add(int x, const Tp &val) {
    while (x <= n) c[x] += val, x += x & -x;
  }
  inline Tp sum(int x) {
    Tp s = 0;
    while (x) s += c[x], x -= x & -x;
    return s;
  }
  inline Tp sum(const int x, const int y) { return sum(y) - sum(x - 1); }
};
}  // namespace Containers
using namespace Containers;
using std::bitset;
using std::get;
using std::lower_bound;
using std::max;
using std::min;
using std::pair;
using std::sort;
using std::swap;
using std::tuple;
using std::upper_bound;
using std::vector;
template <typename Tp>
Tp gcd(Tp a, Tp b) {
  Tp t;
  while (b) t = a, a = b, b = t % b;
  return a;
}
template <typename Tp>
Tp lcm(const Tp a, const Tp b) {
  return a / gcd(a, b) * b;
}
template <typename Tp>
void tomax(Tp &x, const Tp y) {
  x = std::max(x, y);
}
}  // namespace Templates
using namespace Templates;
int n;
void solve() {
  input(n);
  for (int i = 1; i <= n; i++) output(i + 1, i == n ? '\n' : ' ');
}
int main() {
  int caseCount;
  input(caseCount);
  while (caseCount--) solve();
  return 0;
}

```