description: CQXYM is counting permutations length of 2n.
  
  A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
  
  A permutation p(length of 2n) will be counted only if the number of i satisfying p_i<p_{i+1} is no less than n. For example:
  
    * Permutation [1, 2, 3, 4] will count, because the number of such i that p_i<p_{i+1} equals 3 (i = 1, i = 2, i = 3).
    * Permutation [3, 2, 1, 4] won't count, because the number of such i that p_i<p_{i+1} equals 1 (i = 3). 
  
  
  
  CQXYM wants you to help him to count the number of such permutations modulo 1000000007 (10^9+7).
  
  In addition, [modulo operation](https://en.wikipedia.org/wiki/Modulo_operation) is to get the remainder. For example:
  
    * 7 mod 3=1, because 7 = 3 ⋅ 2 + 1, 
    * 15 mod 4=3, because 15 = 4 ⋅ 3 + 3. 
  
  Input
  
  The input consists of multiple test cases. 
  
  The first line contains an integer t (t ≥ 1) — the number of test cases. The description of the test cases follows.
  
  Only one line of each test case contains an integer n(1 ≤ n ≤ 10^5).
  
  It is guaranteed that the sum of n over all test cases does not exceed 10^5
  
  Output
  
  For each test case, print the answer in a single line.
  
  Example
  
  Input
  
  
  4
  1
  2
  9
  91234
  
  
  Output
  
  
  1
  12
  830455698
  890287984
  
  Note
  
  n=1, there is only one permutation that satisfies the condition: [1,2].
  
  In permutation [1,2], p_1<p_2, and there is one i=1 satisfy the condition. Since 1 ≥ n, this permutation should be counted. In permutation [2,1], p_1>p_2. Because 0<n, this permutation should not be counted.
  
  n=2, there are 12 permutations: [1,2,3,4],[1,2,4,3],[1,3,2,4],[1,3,4,2],[1,4,2,3],[2,1,3,4],[2,3,1,4],[2,3,4,1],[2,4,1,3],[3,1,2,4],[3,4,1,2],[4,1,2,3].
solution: import java.util.*;
  import java.io.*;
  import java.math.*;
  public class A {
  	
  	public static void main(String[] args) {
  		PrintWriter out = new PrintWriter(System.out);
  		FastScanner fs=new FastScanner();
  		int T=fs.nextInt();
  		// 1, 2, 3, 4, 5, 6
  		// 1,4,5
  		// 2,3,6
  		
  		for (int tt=0; tt < T; tt++) {
  			int n=fs.nextInt();
  			long s=1;
  			long mod=1_000_000_000+7;
  			for(int i=0;i<2*n;i++) {
  				s*=(i+1);
  				s%=mod;
  			}
  			s = s * modpow(2, mod-2, mod) % mod;
  			out.println(s);
  		}
  		out.close();
  	}
  	static long modpow(long x, long y, long M) {
  		long res=1;
  		while(y>0) {
  			if((y&1)==1)
  				res=res*x%M;
  			x=x*x%M;
  			y >>= 1;
  		}
  		return res;
  	}
  	static class RMQ {
  		int n, lg;
  		int lift[][];
  		public RMQ(int n) {
  			this.n = n;
  			lg = (int)(Math.log(n)/Math.log(2)) + 1;
  			lift = new int[n][lg];
  		}
  		
  		public void build(int a[]) {
  			assert(a.length==n);
  			for(int i = 0; i < n; ++i) {
  				lift[i][0]=a[i];
  			}
  			for(int step = 1; (1<<step) <= n; ++step) {
  				for(int i = 0; i + (1<<step) <= n; i++) {
  					lift[i][step] = Math.min(lift[i][step - 1], lift[i + (1<<step-1)][step - 1]);
  				}
  			}
  		}
  		
  		public int query(int l, int r) {
  			int cnt = (int)(Math.log(r-l+1) / Math.log(2));
  			return Math.min(lift[l][cnt], lift[r-(1<<cnt)+1][cnt]);
  		}
  	}
  	static class prefix_sum_2d {
  		int p[][];
  		int n;
  		prefix_sum_2d (int s, int q, int g[][]) {
  			n = 2 * Math.max(s, q) + 1;
  			p = new int[n+1][n+1];
  			for(int i = 0; i < s; ++i)
  				for(int j = 0; j < n; ++j)
  					if(j<q)
  						p[i][j+1]=p[i][j]+g[i][j];
  					else
  						p[i][j+1]=p[i][j];
  			for(int i = 0; i < n; ++i)
  				for(int j = 0; j <= n; ++j)
  					p[i+1][j]+=p[i][j];
  			int pp[][]=new int[n+2][n+1];
  			for(int i =0 ; i <= n; ++i)
  				for(int j = 0; j <= n; ++j)
  					pp[i+1][j]=p[i][j];
  			p=pp;
  		}
  		
  		public int query (int x1, int y1, int x2, int y2) {
  			// 0, 0
  			// 1, 1
  			// 1, 1
  			// 2, 2
  			x1++;
  			x2++;
  			y1++;
  			y2++;
  			return p[x1-1][y1-1]+p[x2][y2]-p[x2][y1-1]-p[x1-1][y2];
  		}
  	}
  	
  	static class HopcroftKarp {
          int[] match;
          int[] dist;
          ArrayList<Integer>[] graph;
          int N;
          int M;
          int T;
          int INF = 1000000000;
     
          HopcroftKarp (int N, int M) {
              this.N=N;
              this.M=M;
              T = N+M+1;
              match = new int[T];
              dist = new int[T];
              graph = new ArrayList[T];
              for (int i = 0; i < T; i++)
                  graph[i] = new ArrayList<Integer>();
          }
     
          //1 indexed
          void addEdge (int u, int v) {
              graph[u].add(v);
              graph[v].add(u);
          }
     
          boolean BFS () {
              ArrayDeque<Integer> q = new ArrayDeque<Integer>();
              for (int u = 1; u <= N; u++) {
                  if (match[u]==0) {
                      dist[u] = 0;
                      q.add(u);
                  } else {
                      dist[u] = INF;
                  }
              }
              dist[0] = INF;
              while (!q.isEmpty()) {
                  int u = q.pollFirst();
                  if (dist[u]<dist[0]) {
                      for (int v: graph[u]) {
                          if (dist[match[v]] == INF) {
                              dist[match[v]] = dist[u]+1;
                              q.push(match[v]);
                          }
                      }
                  }
              }
              return dist[0]<INF;
          }
     
          boolean DFS (int u) {
              if (u > 0) {
                  for (int v: graph[u]) {
                      if (dist[match[v]]==dist[u]+1 && DFS(match[v])) {
                          match[v] = u;
                          match[u] = v;
                          return true;
                      }
                  }
                  dist[u] = INF;
                  return false;
              }
              return true;
          }
     
          ArrayList<int[]> run () {
              int m = 0;
              while (BFS()) {
                  for (int u = 1; u <= N; u++) {
                      if (match[u]==0 && DFS(u)) m++;
                  }
              }
              ArrayList<int[]> ans = new ArrayList<>();
              for (int v = N+1; v <= N+M; v++) {
                  if (match[v]>0)
                      ans.add(new int[]{match[v],v});
              }
              return ans;
          }
      }
  	static class FastScanner 
      { 
          BufferedReader br; 
          StringTokenizer st; 
   
          public FastScanner() 
          { 
              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 ni() {
          	return nextInt();
          }
          int nextInt() 
          { 
              return Integer.parseInt(next()); 
          } 
          long nl() {
          	return nextLong();
          }
          long nextLong() 
          { 
              return Long.parseLong(next()); 
          } 
          double nd() 
          {
          	return nextDouble();
          }
   
          double nextDouble() 
          { 
              return Double.parseDouble(next()); 
          } 
   
          String nextLine() 
          { 
              String str = ""; 
              try
              { 
                  str = br.readLine(); 
              } 
              catch (IOException e) 
              { 
                  e.printStackTrace(); 
              } 
              return str; 
          }
          public int[] nextArray(int n) {
              int a[] = new int[n];
              for(int i =0; i < n; i++) a[i]=this.nextInt();
              return a;
          }
          public int max(int a[]) {
              int mx = Integer.MIN_VALUE;
              for(int i : a)
                  mx = Math.max(i, mx);
              return mx;
          }
          public int count(int a[], int val) {
              int ans =0;
              for(int i : a)
                  ans += val == i ? 1 : 0;
              return ans;
          }
          public int min(int a[]) {
              int mn = Integer.MAX_VALUE;
              for(int i : a)
                  mn = Math.min(i, mn);
              return mn;
          }
          public void randomShuffleSort(int []a) {
              Random r = new Random();
              for(int i =0; i < (a.length)/2; i++) {
                  int temp=a[i],p=r.nextInt(a.length);
                  a[i]=a[p];
                  a[p]=temp;
              }
              Arrays.sort(a);
          }
          public void fine_sort(int a[]) {
              ArrayList<Integer> A = new ArrayList<>();
              for(int i : a) A.add(i);
              Collections.sort(A);
              for(int i=0; i < a.length; i++) {
                  a[i]=A.get(i);
              }
          } 
      }
  }
  