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.util.*; import java.io.*; import java.math.*;
  public class Main{
  	//見なくていいよ　ここから------------------------------------------
  	static class InputIterator{
  		ArrayList<String> inputLine = new ArrayList<>(buf);
  		int index = 0; int max; String read;
  		InputIterator(){
  			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  			try{
  				while((read = br.readLine()) != null){
  					inputLine.addAll(Arrays.asList(read.split(" ")));
  				}
  			}catch(IOException e){}
  			max = inputLine.size();
  		}
  		boolean hasNext(){return (index < max);}
  		String next(){
  			if(hasNext()){
  				return inputLine.get(index++);
  			}else{
  				throw new IndexOutOfBoundsException("There is no more input");
  			}
  		}
  	}
  	//入力バッファサイズのつもり。入力点数（スペース区切りでの要素数）が100万を超える場合はバッファサイズを100万にすること
  	static int buf = 1024;
  	static HashMap<Integer, String> CONVSTR = new HashMap<>();
  	static InputIterator ii = new InputIterator();//This class cannot be used in reactive problem.
  	static PrintWriter out = new PrintWriter(System.out);
  	static void flush(){out.flush();}
  	static void myout(Object t){out.println(t);}
  	static void myerr(Object t){System.err.print("debug:");System.err.println(t);}
  	static String next(){return ii.next();}
  	static boolean hasNext(){return ii.hasNext();}
  	static int nextInt(){return Integer.parseInt(next());}
  	static long nextLong(){return Long.parseLong(next());}
  	static double nextDouble(){return Double.parseDouble(next());}
  	static ArrayList<String> nextCharArray(){return myconv(next(), 0);}
  	static ArrayList<String> nextStrArray(int size){
  		ArrayList<String> ret = new ArrayList<>(size);
  		for(int i = 0; i < size; i++){
  			ret.add(next());
  		}
  		return ret;
  	}
  	static ArrayList<Integer> nextIntArray(int size){
  		ArrayList<Integer> ret = new ArrayList<>(size);
  		for(int i = 0; i < size; i++){
  			ret.add(Integer.parseInt(next()));
  		}
  		return ret;
  	}
  	static ArrayList<Long> nextLongArray(int size){
  		ArrayList<Long> ret = new ArrayList<>(size);
  		for(int i = 0; i < size; i++){
  			ret.add(Long.parseLong(next()));
  		}
  		return ret;
  	}
  	@SuppressWarnings("unchecked")
  	static String myconv(Object list, int no){//only join
  		StringBuilder sb = new StringBuilder("");
  		String joinString = CONVSTR.get(no);
  		if(list instanceof String[]){
  			return String.join(joinString, (String[])list);
  		}else if(list instanceof long[]){
  			long[] tmp = (long[])list;
  			if(tmp.length == 0){
  				return "";
  			}
  			sb.append(String.valueOf(tmp[0]));
  			for(int i = 1; i < tmp.length; i++){
  				sb.append(joinString).append(String.valueOf(tmp[i]));
  			}
  			return sb.toString();
  		}else if(list instanceof int[]){
  			int[] tmp = (int[])list;
  			if(tmp.length == 0){
  				return "";
  			}
  			sb.append(String.valueOf(tmp[0]));
  			for(int i = 1; i < tmp.length; i++){
  				sb.append(joinString).append(String.valueOf(tmp[i]));
  			}
  			return sb.toString();
  		}else if(list instanceof ArrayList){
  			ArrayList tmp = (ArrayList)list;
  			if(tmp.size() == 0){
  				return "";
  			}
  			sb.append(tmp.get(0));
  			for(int i = 1; i < tmp.size(); i++){
  				sb.append(joinString).append(tmp.get(i));
  			}
  			return sb.toString();
  		}else{
  			throw new ClassCastException("Don't join");
  		}
  	}
  	static ArrayList<String> myconv(String str, int no){//only split
  		String splitString = CONVSTR.get(no);
  		return new ArrayList<String>(Arrays.asList(str.split(splitString)));
  	}
  	static ArrayList<String> myconv(String str, String no){
  		return new ArrayList<String>(Arrays.asList(str.split(no)));
  	}
  	public static void main(String[] args){
  		CONVSTR.put(8, " "); CONVSTR.put(9, "\n"); CONVSTR.put(0, "");
  		solve();flush();
  	}
  	//見なくていいよ　ここまで------------------------------------------
  	//このコードをコンパイルするときは、「-encoding UTF-8」を指定すること
  	static void solve(){//ここがメイン関数
  		int t = nextInt();
  		TreeSet<Integer> set = new TreeSet<>(sieveOfEratos(100000));
  		while(hasNext()){
  			int N = nextInt();
  			ArrayList<Integer> list = new ArrayList<>();
  			for(int a : set){
  				if(list.size() < N){
  					list.add(a);
  				}else{
  					break;
  				}
  			}
  			myout(myconv(list, 8));
  		}
  	}
  	//メソッド追加エリア　ここから
  
  static HashSet<Integer> sieveOfEratos(int val){
      HashSet<Integer> primes = new HashSet<>();
      HashSet<Integer> nums = new HashSet<>();
      int[] used = {2, 3, 5, 7, 11};
      int underPrime = 13;
      if(val <= 1){
          return nums;
      }
      for(int i = 0; i < used.length; i++){
          if(used[i] <= val){
              nums.add(used[i]);
          }
      }
      for(int i = underPrime; i <= val; i += 2){
          boolean continued = false;
          for(int j = 0; j < used.length; j++){
              if(i % used[j] == 0){
                  continued = true;
                  break;
              }
          }
          if(continued){
              continue;
          }
          nums.add(i);
      }
      int i = 2;
      while(i <= Math.sqrt(val)){
          if(!nums.contains(i)){
              if(i == 2){
                  i++;
              }else{
                  i += 2;
              }
              continue;
          }
          int count = 1;
          while(i * count <= val){
              if(i <= 11 && Arrays.asList(used).contains(i)){
                  break;
              }
              if(count == 1){
                  primes.add(i);
              }
              nums.remove(i * count);
              count++;
          }
          if(i == 2){
              i++;
          }else{
              i += 2;
          }
      }
      Iterator<Integer> it = primes.iterator();
      while(it.hasNext()){
          nums.add(it.next());
      }
      return nums;
  }
  
  
  	//メソッド追加エリア　ここまで
  }