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.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map.Entry;
  import java.util.PriorityQueue;
  import java.util.StringTokenizer;
   
  public class Main {
  	static FastReader fr;
  	static int arrForIndexSort[];
  	static class FastReader {
          BufferedReader br;
          StringTokenizer st;
   
          public FastReader()
          {
              br = new BufferedReader(
                  new InputStreamReader(System.in));
          }
   
          String next()
          {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  }
                  catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
   
          int nextInt() { return Integer.parseInt(next()); }
   
          long nextLong() { return Long.parseLong(next()); }
   
          double nextDouble()
          {
              return Double.parseDouble(next());
          }
   
          String nextLine()
          {
              String str = "";
              try {
                  str = br.readLine();
              }
              catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
  	static class Pair{
  		int first;
  		int second;
  		Pair(int first, int second){
  			this.first = first;
  			this.second = second;
  		}
  		@Override
  		public boolean equals(Object b) {
  			Pair a = (Pair)b;
  			if(this.first == a.first && this.second==a.second) {
  				return true;
  			}
  			return false;
  		}
  	}
  	class PairSorter implements Comparator<Main.Pair>{
  		public int compare(Pair a, Pair b) {
  			if(a.first!=b.first) {
  				return a.first-b.first;
  			}
  			return a.second-b.second; 
  		}
  	}
  	static class DoublePair{
  		double first;
  		double second;
  		DoublePair(double first, double second){
  			this.first = first;
  			this.second = second;
  		}
  		@Override
  		public boolean equals(Object b) {
  			Pair a = (Pair)b;
  			if(this.first == a.first && this.second==a.second) {
  				return true;
  			}
  			return false;
  		}
  	}
  	class DoublePairSorter implements Comparator<Main.DoublePair>{
  		public int compare(DoublePair a, DoublePair b) {
  			 if(a.second>b.second) {
  				 return 1;
  			 }
  			 else if(a.second<b.second) {
  				 return -1;
  			 }
  			 return 0;
  		}
  	}
  	class IndexSorter implements Comparator<Integer>{
  		public int compare(Integer a, Integer b) {
  			//desc
  			if(arrForIndexSort[b]==arrForIndexSort[a]) {
  				return b-a;
  			}
  			return arrForIndexSort[b]-arrForIndexSort[a];
  		}
  	}
  	class ListSorter implements Comparator<List>{
  		public int compare(List a, List b) {
  			return b.size()-a.size(); 
  		}
  	}
  	static class DisjointSet{
  		int[] dsu;
  		public DisjointSet(int n) {
  			makeSet(n);
  		}
  		public void makeSet(int n) {
  			dsu = new int[n+1];
  			//*** 1 Based indexing ***
  			for(int i=1;i<=n;i++) {
  				dsu[i] = -1;
  			}
  		}
  		public int find(int i) {
  			while(dsu[i] > 0) {
  				i = dsu[i];
  			}
  			return i;
  		}
  		public void union(int i, int j) {
  			int iRep = find(i);
  			int jRep = find(j);
  			if(iRep == jRep) {
  				return;
  			}
  			if(dsu[iRep]>dsu[jRep]) {
  				dsu[jRep] += dsu[iRep];
  				dsu[iRep] = jRep;
  			}
  			else {
  				dsu[iRep] += dsu[jRep];
  				dsu[jRep] = iRep;
  			}
  		}
  	}
  	public static void main(String[] args) {
  		fr = new FastReader();
  		int T = 1;
  		T = fr.nextInt();
  		int t1 = T;
  		while (T-- > 0) {
  			solve();
  		}
  	}
  	public static void solve() {
  		int n = fr.nextInt();
  		StringBuilder sb = new StringBuilder();
  		for(int i=2;i<=n+1;i++) {
  			sb.append(i).append(" ");
  		}
  		System.out.println(sb.toString());
  		
  	}
  
  }