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: from collections import deque
  import heapq
  from math import sqrt
  import operator
  from operator import itemgetter
  import sys
  
  import copy
  
   
  inf_var = 0
  if inf_var == 1:
      inf = open('input.txt', 'r')
  else:
      inf = sys.stdin
   
  input = inf.readline
  # sys.stdout = open('output.txt', 'w')
   
  def read_one_int():
      return int(input().rstrip('\n'))
  
  
  def read_one_float():
      return float(input().rstrip('\n'))
   
   
  def read_list_of_ints():
      res = [int(val) for val in (input().rstrip('\n')).split()]
      return res
  
  
  def read_list_of_ints_zero():
      return [int(val) - 1 for val in (input().rstrip('\n')).split()]
  
  
  def read_str():
      return input().rstrip()
  
  
  def bfs(q, graph, dist):
      while len(q):
          cur_v = q.popleft()
  
          for to in graph[cur_v]:
              if dist[to] == -1:
                  dist[to] = dist[cur_v] + 1
                  q.append(to)
  
  
  def sort_vert(n, graph):
      dist = [-1] * n
      q = deque()
      dist[0] = 0
  
      q.append(0)
      bfs(q, graph, dist)
  
      vertices = []
      for vert, dist in enumerste(dist):
          verticies.append((dist, vert))
  
      verticies.sort()
      res = [vert for (dist, vert) in verticies]
  
      return res
  
  
  def main():
      # tests = read_one_int()
  
      # for _ in range(tests):
      #     vert = read_one_int()
      #     v_w = []
      #     for _ in range(n):
      #         v_w.append(read_list_of_ints())
  
      #     graph = {}
      #     for _ in range(n - 1):
      #         u, v = read_list_of_ints_zero()
      #         if u not in graph:
      #             graph[u] = [v]
      #         else:
      #             graph[u].append(v)
      #         if v not in graph:
      #             graph[v] = [u]
      #         else:
      #             graph[v].append(u)
  
      #     vertices = sort_vertices(vert, graph)
  
      #     cache = [[None, None] for _ in range(n)]
  
      #     def f(prev_v, op):
      #         pass
  
  
      tests = read_one_int()
      mod = 10**9 + 7
  
      def mult(a, b, mod):
          return ((a % mod) * (b % mod)) % mod
  
      for _ in range(tests):
          n = read_one_int()
          n *= 2
  
          res = 1
          for i in range(3, n + 1):
              res = mult(res, i, mod)
  
          print(res)
  
  if __name__== '__main__':
      main()
  