Combinatorics Template

#include <bits/stdc++.h>
using namespace std;

template<int MOD>
struct modint {
    int val;

    modint(long long v = 0) {
        if (v < 0) v = v % MOD + MOD;
        if (v >= MOD) v %= MOD;
        val = v;
    }

    modint operator+ (const modint &other) const {
        int res = val + other.val;
        if (res >= MOD) res -= MOD;
        return modint(res);
    }

    modint operator- (const modint &other) const {
        int res = val - other.val;
        if (res < 0) res += MOD;
        return modint(res);
    }

    modint operator* (const modint &other) const {
        return modint((long long)val * other.val % MOD);
    }

    modint operator/ (const modint &other) const {
        return *this * other.inv();
    }

    modint pow(long long exp) const {
        modint base = *this, result = 1;
        while (exp) {
            if (exp & 1) result = result * base;
            base = base * base;
            exp >>= 1;
        }
        return result;
    }

    modint inv() const {
        return pow(MOD - 2);
    }

    modint& operator+= (const modint &other) { return *this = *this + other; }
    modint& operator-= (const modint &other) { return *this = *this - other; }
    modint& operator*= (const modint &other) { return *this = *this * other; }
    modint& operator/= (const modint &other) { return *this = *this / other; }

    friend ostream& operator<<(ostream &os, const modint &m) {
        return os << m.val;
    }
    friend istream& operator>>(istream &is, modint &m) {
        long long x; is >> x; m = modint(x);
        return is;
    }
};

const int nax = 2e5 + 10;
const int mod = 1e9 + 7;
using mint = modint<mod>;
#warning update constant values


mint fact[nax], invfact[nax];
void precompute() {
    fact[0] = invfact[0] = 1;
    for (int i = 1; i < nax; ++i) fact[i] = fact[i-1] * i;
    invfact[nax-1] = fact[nax-1].inv();
    for (int i = nax-2; i >= 1; --i) invfact[i] = invfact[i+1] * (i+1);
}
mint nCr(int n, int r) {
    if (r < 0 || r > n) return 0;
    return fact[n] * invfact[r] * invfact[n - r];
}

void PlayGround() {

}
int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    int t; cin>>t;
    while(t--) PlayGround();
}