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.time.LocalDate;
  	import java.util.*;
  	//BigInteger x = new BigInteger(a);
  	//Collections.reverseOrder()
  	
  	public class Main {
  		static FastScanner sc;
  	//	static PrintWriter syso;
  		static long mod = 1_000_000_007;
  		static int maxi = Integer.MAX_VALUE;  //INF
  		static long maxl = Long.MAX_VALUE;    //LINF
  		static int [] M = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  		static int [] dx = {1,1,0,-1,-1,-1, 0, 1};
  		static int [] dy = {0,1,1, 1, 0,-1,-1,-1};
  		static int [] d4x = {1,-1, 0, 0};
  		static int [] d4y = {0, 0, 1,-1};
  		
  		public static void main(String[]args)  {
  			    sc = new FastScanner();
  			    long testCases=1;
  		        testCases=sc.nextInt();
  		        while (testCases-->0) solve();
  		    } 
  
  		public static void solve(){
  
  //			int a =sc.nextInt();
  //			String s = "11";
  //			for(int i = 0; i<a;i++) {
  //				s += "1";
  //				System.out.print(s + " ");
  //			}
  //			System.out.println();
  			
  			int n = sc.nextInt();
  			if (n == 1) {
  				System.out.println(1);
  			}
  			else {
  				int ans = 2;
  				for(int i = 0; i<n;i++) {
  					System.out.print(ans++ + " ");
  				}
  				System.out.println();
  			}
  			
  			
  			
  		}
  		
  		static class Pair implements Comparable<Pair> {
  	//		Pair [] a = new Pair [n];	
  	//		for (int i = 0; i<n;i++) 
  	//			a[i] = new Pair(sc.nextInt(), sc.nextInt());
  			int a, b;
  			Pair(int a, int b){
  				this.a=a;
  				this.b=b;
  			}
  			public int compareTo(Pair o) {
  				return a==o.a?b-o.b:a-o.a;
  			}
  		}
  		
  	
  		static int BinarySearch(int[] nums, int target) {
  			int lo =0;
  			int hi = nums.length-1;
  			
  			while (lo<hi) {
  				int mid =lo+(hi-lo)/2;
  				int value = nums[mid];
  				if (value > target) {
  					hi = mid;
  				}
  				else if (value < target) {
  					lo = mid+1;
  				}
  				else {
  					return mid;
  				}
  			}
  			return lo;
  		}
  	
  	    static void removeDuplicates(int arr[], int n)
  	    {
  	        if (n == 0 || n == 1)
  	            return;
  	
  	        int j = 0;
  	
  	
  	        for (int i = 0; i < n-1; i++)
  	            if (arr[i] != arr[i+1])
  	                arr[j++] = arr[i];
  	
  	        arr[j++] = arr[n-1];
  	
  	        return;
  	    }
  	    static void primeset(HashSet<Integer> set,int n){
  	
  	        if(n%2==0)
  	            set.add(2);
  	        while (n % 2 == 0)
  	            n /= 2;
  	        for (int i = 3; i <= (n); i += 2) {
  	            while (n % i == 0) {
  	                set.add(i);
  	
  	                n /= i;
  	            }
  	        }
  	    }
  	    static public int missingNumber(int[] nums) {
  	    		int len=nums.length;
  	    		int sum = 0;
  	    		for(int i=0;i<len;i++){
  	    			sum+=nums[i];
  	    		}
  	    		return (((len*(len+1))/2)-sum);//Using maths AP Formula we can easily find the missing number.
  	    	}
  	    static boolean isSquare(int n){
  	        return Math.ceil(Math.sqrt(n))==Math.floor(Math.sqrt(n)) ? true:false;
  	    }
  	
  	    static int getSum(int n){
  	        int res=0;
  	        while(n>0){
  	            res+=(n%10);
  	            n/=10;
  	        }
  	        return res;
  	    }
  	
  	    static int gcd(int a,int b)
  	    {
  	        if(a==0)return b;
  	        else return gcd(b%a,a);
  	    }
  	    
  	    static long Lgcd(long a,long b)
  	    {
  	        if(a==0)return b;
  	        else return Lgcd(b%a,a);
  	    }
  	
  	     static boolean isPrime(int n) {
  	        if (n == 2)
  	            return true;
  	        else if ((n % 2 == 0 && n > 2) || n < 2)
  	            return false;
  	        else {
  	            for (int i = 3; i <= (int) Math.sqrt(n); i += 2) {
  	                if (n % i == 0)
  	                    return false;
  	            }
  	            return true;
  	        }
  	
  	    }
  	    
  	//    static class Dijkstra {
  	//    	static long[] get(List<Edge>[] edges, int start) {
  	//    		long[] ret = new long[edges.length];
  	//    		Arrays.fill(ret, Long.MAX_VALUE);
  	//    		ret[start] = 0;
  	//    		PriorityQueue<Edge> pq = new PriorityQueue<Edge>((s1, s2)->Long.compare(s1.cost, s2.cost));
  	//    		pq.add(new Edge(start, 0));
  	//
  	//    		while (!pq.isEmpty()) {
  	//    			Edge now = pq.poll();
  	//    			if (ret[now.to] < now.cost) continue;
  	//    			for (Edge e : edges[now.to]) {
  	//    				if (e.cost != Long.MAX_VALUE && ret[e.to] > ret[now.to] + e.cost) {
  	//    					ret[e.to] = ret[now.to] + e.cost;
  	//    					pq.add(new Edge(e.to, ret[e.to]));
  	//    				}
  	//    			}
  	//    		}
  	//    		return ret;
  	//    	}
  	//    }
  	
  		static void sort(int[] a) {
  			ArrayList<Integer> l=new ArrayList<>();
  			for (int i:a) l.add(i);
  			Collections.sort(l);
  			for (int i=0; i<a.length; i++) a[i]=l.get(i);
  		}
  		
  		static class FastScanner {
  		    InputStream in = System.in;
  		    private final byte[] buffer = new byte[1024];
  		    private int ptr = 0;
  		    private int buflen = 0;
  		    private boolean hasNextByte() {
  		        if (ptr < buflen) {
  		            return true;
  		        } else {
  		            ptr = 0;
  		            try {
  		                buflen = in.read(buffer);
  		            } catch (IOException e) {
  		                e.printStackTrace();
  		            }
  		            if (buflen <= 0) {
  		                return false;
  		            }
  		        }
  		        return true;
  		    }
  		 
  		    private int readByte() {
  		        if (hasNextByte())
  		            return buffer[ptr++];
  		        else
  		            return -1;
  		    }
  		 
  		    private boolean isPrintableChar(int c) {
  		        return 33 <= c && c <= 126;
  		    }
  		 
  		    public boolean hasNext() {
  		        while (hasNextByte() && !isPrintableChar(buffer[ptr]))
  		            ptr++;
  		        return hasNextByte();
  		    }
  		 
  		    public String next() {
  		        if (!hasNext())
  		            throw new NoSuchElementException();
  		        StringBuilder sb = new StringBuilder();
  		        int b = readByte();
  		        while (isPrintableChar(b)) {
  		            sb.appendCodePoint(b);
  		            b = readByte();
  		        }
  		        return sb.toString();
  		    }
  		 
  		    public char[] nextCA() {
  		    	return next().toCharArray();
  		    }
  		 
  		    public long nextLong() {
  		        if (!hasNext())
  		            throw new NoSuchElementException();
  		        long n = 0;
  		        boolean minus = false;
  		        int b = readByte();
  		        if (b == '-') {
  		            minus = true;
  		            b = readByte();
  		        }
  		        if (b < '0' || '9' < b) {
  		            throw new NumberFormatException();
  		        }
  		        while (true) {
  		            if ('0' <= b && b <= '9') {
  		                n *= 10;
  		                n += b - '0';
  		            } else if (b == -1 || !isPrintableChar(b)) {
  		                return minus ? -n : n;
  		            } else {
  		                throw new NumberFormatException();
  		            }
  		            b = readByte();
  		        }
  		    }
  		 
  		    public int nextInt() {
  		        long nl = nextLong();
  		        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
  		            throw new NumberFormatException();
  		        return (int) nl;
  		    }
  		 
  		    public double nextDouble() {
  		        return Double.parseDouble(next());
  		    }
  		 
  		    public int[] nextIA(int N) {
  		    	int[] a = new int[N];
  		    	for (int i = 0; i < N; i++) a[i] = this.nextInt();
  		    	return a;
  		    }
  		    public int[] nextIA(int N, boolean flag) {
  		    	int[] a = new int[N];
  		    	for (int i = 0; i < N; i++) a[i] = this.nextInt()-1;
  		    	return a;
  		    }
  		    public long[] nextLA(int N) {
  		    	long[] a = new long[N];
  		    	for (int i = 0; i < N; i++) a[i] = this.nextLong();
  		    	return a;
  		    }
  		    public double[] nextDA(int N) {
  		    	double[] a = new double[N];
  		    	for (int i = 0; i < N; i++) a[i] = this.nextDouble();
  		    	return a;
  		    }
  		    public boolean[][] bgrid(int H, int W, char c) {
  		    	boolean[][] a = new boolean[H][W];
  		    	for (int i = 0; i < H; i++) {
  		    		char[] s = this.nextCA();
  		    		for (int j = 0; j < W; j++) a[i][j] = s[j] == c;
  		    	}
  		    	return a;
  		    }
  		    public long[][] nextLongMatrix(int height, int width) {
  				long[][] mat = new long[height][width];
  				for (int h = 0; h < height; h++)
  					for (int w = 0; w < width; w++) {
  						mat[h][w] = this.nextLong();
  					}
  				return mat;
  			}
  		 
  			public int[][] nextIntMatrix(int height, int width) {
  				int[][] mat = new int[height][width];
  				for (int h = 0; h < height; h++)
  					for (int w = 0; w < width; w++) {
  						mat[h][w] = this.nextInt();
  					}
  				return mat;
  			}
  		 
  			public double[][] nextDoubleMatrix(int height, int width) {
  				double[][] mat = new double[height][width];
  				for (int h = 0; h < height; h++)
  					for (int w = 0; w < width; w++) {
  						mat[h][w] = this.nextDouble();
  					}
  				return mat;
  			}
  		 
  			public char[][] nextCharMatrix(int height, int width) {
  				char[][] mat = new char[height][width];
  				for (int h = 0; h < height; h++) {
  					String s = this.next();
  					for (int w = 0; w < width; w++) {
  						mat[h][w] = s.charAt(w);
  					}
  				}
  				return mat;
  			}
  		}
  		
  	
  	}