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.util.*;
  public class solution {
  
  public static void main(String[] args)  {
  	FScanner sc = new FScanner();
  	//Arrays.fill(prime, true);
  	//sieve();
  	int t=sc.nextInt();
  //	 StringBuilder sb = new StringBuilder();
  	while(t-->0) {	
  	int n=sc.nextInt();
  	int arr1[]=new int[n];
  	int a=2;
  	
  	
  	for(int k=0;k<n;k++)
  	{
  		 System.out.print(a+" ");
  		 a++;
  	}
  	
  	System.out.println();
  	
  	
  	}
  }
  
  
          
   /* public static void sieve()
  {   prime[0]=prime[1]=false;
  int n=1000000;
  	for(int p = 2; p*p <=n; p++)
      {
          if(prime[p] == true)
          {
            
              for(int i = p*p; i <= n; i += p)
                  prime[i] = false;
          }
      }
     */
  }
   
  /*  class pair implements Comparable<pair>{
  	int val;int edge;
  	 pair(int f,int ind)
  	{
  		val=f;
  		edge=ind;
  	}
  	public int compareTo(pair p)
  	{
  		return -p.edge+this.edge;
  	}
  	
  }  */
   
   class FScanner {
  	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  	StringTokenizer sb = new StringTokenizer("");
   
  	String next(){
  		while(!sb.hasMoreTokens()){
  			try{
  				sb = new StringTokenizer(br.readLine());
  			} catch(IOException e){ }
  		}
  		return sb.nextToken();
  	}
  	String nextLine(){
  		try{ return br.readLine(); } 
  		catch(IOException e) { } return "";
  	}
   
  	int nextInt(){
  		return Integer.parseInt(next());
  	}
   
  	long nextLong() {
  		return Long.parseLong(next());
  	}
   
  	int[] readArray(int n) {
  		int a[] = new int[n];
  		for(int i=0;i<n;i++) a[i] = nextInt();
  		return a;
  	}
   
  	float nextFloat(){
  	return Float.parseFloat(next());
  	}
  	
  	double nextDouble(){
  	return Double.parseDouble(next());
  	}
  }