Chuck Norris just created a universe. He has already started the space-time continuum. Now he needs to fill the universe with matter and antimatter for the avatar cycle to start.
He created $N$ distinct pairs of elementary matter and their corresponding antimatter particles. Annihilations happen only when a matter particle is placed adjacent to its corresponding antimatter particle and not when it is placed adjacent to any other matter or antimatter particle. Thus for every distinct particle of matter in the universe there exist one and only one antimatter particle that can cause its annihilation.
Chuck Norris wants to arrange all the particles in a 2-D circular pattern such that a matter particle is placed adjacent only to antimatter particles and vice versa. In how many distinct ways can he arrange them, regardless of the orientation of the arrangement, such that total annihilation of ALL particles doesn't take place i.e., $at least$ $one$ pair remain unannihilated after he arranges them in a circular pattern.
Since the total number of distinct ways can be very large, print the result modulo $1000000007$.

-----Input:-----
- First line has single integer $T$, i.e., the number of test cases
- The first and only line of each test case has a single integer $N$ i.e., number of distinct pairs of matter-antimatter particles.

-----Output:-----
- For of each test case print a single line, i.e., total number of distinct ways.

-----Constraints :-----
- $1 \leq T \leq 1000$
- $0 \leq N \leq 10^7$

-----Subtasks-----
- 
Subtask 1 : 10 pts
- $1 \leq T \leq 100$
- $0 \leq N \leq 100$ 
- 
Subtask 2 : 90 pts
- Original Constraints

-----Sample input :-----
1
3

-----Sample output :-----
8

-----Explanation:-----
For 3 pairs of elementary matter and their corresponding  antimatter particles, Chuck Norris can arrange them in 8 ways such that at least one pair of matter antimatter particles survive annihilation.

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = 'import math\nfor i in range(int(input())):\n n=int(input())\n if(n<=2 or n>1000000007):\n  print("0")\n else:\n  print((math.factorial(n-1)*(math.factorial(n)-2))%1000000007)\n'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 12989