很容易想到最優策略是2*3*4一直乘到字首和小於n的最靠後的位置，設這個位置為p

當segma（2,p）==n時明顯答案就是mul（2,p）

但是當segma(2,p) != n時會有一個餘項，設為need，need=n-segma(2,p)，顯然現在項數不會再增加了，我們只能把need按照一定的策略分配給前面的元素才能使結果更大，按照直覺我們應該將need平攤給前面所有的元素，但是要注意need有可能會分配多1個，這時要給最後一項分配2

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
const int INF = 1e9;
const int mod = 1e9 + 7;
typedef long long ll;
ll sum[maxn], mul[maxn], inv[maxn];
int cnt;
ll mpow(ll x, int y) {
    ll ans = 1;
    while (y) {
        if (y & 1) ans = ans * x % mod;
        x = x * x % mod;
        y >>= 1;
    }
    return ans;
}
void init() {
    sum[0] = sum[1] = 0;
    mul[0] = mul[1] = 1;
    for (int i = 2; i < maxn; i++) {
        sum[i] = sum[i-1]+i;
        mul[i] = mul[i-1]*i % mod;
        if (sum[i] >= INF) break;
        cnt = i;
    }
    inv[cnt] = mpow(mul[cnt], mod-2);
    inv[0] = inv[1] = 0;
    for (int i = cnt-1; i >= 2; i--) inv[i] = inv[i+1]*(i+1)%mod;
}
int main() {
    init();
    int T; scanf("%d", &T);
    while (T--) {
        int n; scanf("%d", &n);
        if (n <= 4) {
            printf("%d\n", n); continue;
        }
        int p = upper_bound(sum+1, sum+1+cnt, n)-sum-1;
        ll need = n - sum[p], ans = 0;
        if (need == 0) {
            ans = mul[p];
        }
        else if (need == p) {
            ans = mul[p]*inv[2]%mod*(p+2)%mod;
        }
        else {
            ans = mul[p-need]*mul[p+1]%mod*inv[p-need+1]%mod;
        }
        printf("%lld\n", ans%mod);
    }
    return 0;
}