#ifndef __INTMOD_H__0001__ #define __INTMOD_H__0001__ #include #include #include #include /* Modulus must be less than 0x80000000, and not be 0. */ template class IntMod { typedef int32_t Int; typedef uint32_t UInt; typedef long long Long; typedef uint64_t ULong; public: template friend bool operator==(const IntMod& left, const IntMod& right); template friend bool operator!=(const IntMod& left, const IntMod& right); template friend bool operator<(const IntMod& left, const IntMod& right); template friend bool operator<=(const IntMod& left, const IntMod& right); template friend bool operator>(const IntMod& left, const IntMod& right); template friend bool operator>=(const IntMod& left, const IntMod& right); private: UInt value_m; public: IntMod() { value_m = 0; } IntMod(UInt value) { value_m = value % Modulus; } IntMod(ULong value) { value_m = value % Modulus; } IntMod(Int value) { Int tmp = value % (Int)Modulus; value_m = tmp >= 0 ? tmp : Modulus - (unsigned int)(-tmp); } IntMod(Long value) { Int tmp = value % (Long)Modulus; value_m = tmp >= 0 ? tmp : Modulus - (unsigned int)(-tmp); } IntMod(const IntMod& other) : value_m(other.value_m) {} IntMod& operator=(const IntMod& other) { value_m = other.value_m; return *this; } const IntMod& operator+() const { return *this; } IntMod operator-() const { return IntMod(Modulus - value_m); } IntMod& operator++() { ++value_m; if (value_m == Modulus) value_m = 0; return *this; } IntMod& operator--() { if (value_m == 0) value_m = Modulus; --value_m; return *this; } IntMod operator++(int dummy) { IntMod tmp(*this); ++(*this); return tmp; } IntMod operator--(int dummy) { IntMod tmp(*this); --(*this); return tmp; } IntMod& operator+=(const IntMod& right) { value_m += right.value_m; // value_m < 0x80000000 if (value_m >= Modulus) value_m -= Modulus; return *this; } IntMod& operator-=(const IntMod& right) { if (value_m < right.value_m) value_m += Modulus; value_m -= right.value_m; return *this; } IntMod& operator*=(const IntMod& right) { value_m = ((ULong)value_m * right.value_m) % Modulus; return *this; } IntMod& operator/=(const IntMod& right) { (*this) *= (right.Inverse()); return *this; } // for power IntMod operator[](unsigned int exp) const { return Pow(exp); } /* Modulus must be a prime. */ IntMod Inverse() const { return (*this).Pow(Modulus - 2); } IntMod Pow(UInt exp) const { IntMod product = 1; IntMod factor(*this); while (exp > 0) { if (exp & 1) product *= factor; factor *= factor; exp >>= 1; } return product; } UInt Get_value() const { return value_m; } static IntMod Fact(UInt num) { static std::vector table(1, 1); if (table.size() > num) return table[num]; int old_size = table.size(); table.resize(num + 1); for (int i = old_size; i <= num; i++) { table[i] = table[i - 1] * i; } return table[num]; } static IntMod Combi(UInt n, UInt r) { if (n < r) throw "okashii"; return IntMod::Fact(n) / (IntMod::Fact(n - r) * IntMod::Fact(r)); } static std::vector Inverse_list(int size) { assert(size < Modulus); std::vector ret_arr(size + 1); ret_arr[1] = 1; for (int i = 2; i <= size; ++i) { ret_arr[i] = ((ULong)(Modulus - Modulus / i) * ret_arr[Modulus % i].Get_value()) % Modulus; } return ret_arr; } }; template IntMod operator+(const IntMod& left, const IntMod& right) { IntMod ret(left); ret += right; return ret; } template IntMod operator-(const IntMod& left, const IntMod& right) { IntMod ret(left); ret -= right; return ret; } template IntMod operator*(const IntMod& left, const IntMod& right) { IntMod ret(left); ret *= right; return ret; } template IntMod operator/(const IntMod& left, const IntMod& right) { IntMod ret(left); ret /= right; return ret; } template bool operator==(const IntMod& left, const IntMod& right) { return left.value_m == right.value_m; } template bool operator!=(const IntMod& left, const IntMod& right) { return left.value_m != right.value_m; } /* for set/map */ template bool operator<(const IntMod& left, const IntMod& right) { return left.value_m < right.value_m; } template bool operator<=(const IntMod& left, const IntMod& right) { return left.value_m <= right.value_m; } template bool operator>(const IntMod& left, const IntMod& right) { return left.value_m > right.value_m; } template bool operator>=(const IntMod& left, const IntMod& right) { return left.value_m >= right.value_m; } template IntMod operator+(const IntMod& left, Integer right) { return left + IntMod(right); } template IntMod operator+(Integer left, const IntMod& right) { return IntMod(left) + right; } template IntMod operator-(const IntMod& left, Integer right) { return left - IntMod(right); } template IntMod operator-(Integer left, const IntMod& right) { return IntMod(left) - right; } template IntMod operator*(const IntMod& left, Integer right) { return left * IntMod(right); } template IntMod operator*(Integer left, const IntMod& right) { return IntMod(left) * right; } template IntMod operator/(const IntMod& left, Integer right) { return left / IntMod(right); } template IntMod operator/(Integer left, const IntMod& right) { return IntMod(left) / right; } template std::istream& operator<<(std::istream& ist, const IntMod& val) { uint64_t tmp; ist >> tmp; val = tmp; return ist; } template std::ostream& operator<<(std::ostream& ost, const IntMod& val) { ost << val.Get_value(); return ost; } typedef IntMod<1000000007> MInt; #if 1 MInt operator"" _m(unsigned long long num) { return MInt((uint64_t)num); } #endif #endif #define _CRT_SECURE_NO_WARNINGS #define _SCL_SECURE_NO_WARNINGS #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; typedef unsigned int uint; typedef long long LL; typedef unsigned long long ULL; typedef pair PP; #define REP(i, a, n) for(LL i = (a), i##_max = (n); i < i##_max; ++i) #define REM(i, a, n) for(LL i = (LL)(n) - 1, i##min = (a); i >= i##min; --i) #define ALL(arr) (arr).begin(), (arr).end() #define FLOAT fixed << setprecision(16) #define SPEEDUP {cin.tie(NULL); ios::sync_with_stdio(false);} const int INF = 0x3FFFFFFF; const LL INFLL = 0x3FFFFFFF3FFFFFFF; const double INFD = 1.0e+308; const string INFSTR = "\x7f"; const double EPS = 1.0e-9; void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; } void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; } template istream& operator>>(istream& ist, pair& right) { return ist >> right.first >> right.second; } template ostream& operator<<(ostream& ost, const pair& right) { return ost << right.first << ' ' << right.second; } template void Fill(T(&dest)[N], const TCompatible& val) { fill(dest, dest + N, val); } template void Fill(T(&dest)[M][N], const TCompatible& val) { for (int i = 0; i < M; ++i) Fill(dest[i], val); } template T Compare(T left, T right) { return left > right ? 1 : (left < right ? -1 : 0); } istream& Ignore(istream& ist) { string s; ist >> s; return ist; } bool Inside(int i, int j, int h, int w) { return i >= 0 && i < h && j >= 0 && j < w; } template T Next() { T buf; cin >> buf; return buf; } #ifdef ONLY_MY_ENVIR #include "IntMod.h" #include "Union_Find.h" #include "Graph.h" #include "Range.h" #include "Global.h" #include "Flow_Solver.h" #include "Tree.h" #include "Suffix_Array.h" #include "Geometry.h" #include "Matrix.h" #include "Segment_Tree.h" #include "Rational.h" #include "Position.h" #endif #ifdef __GNUC__ typedef __int128 LLL; istream& operator>> (istream& ist, __int128& val) { LL tmp; ist >> tmp; val = tmp; return ist; } ostream& operator<< (ostream& ost, __int128 val) { LL tmp = val; ost << tmp; return ost; } #endif #if 1234567891 #include #include #include #include template using PriorityQ = priority_queue, greater >; // コスト小を優先 template auto Is(const T& value) { return [value](const auto& comparand) -> bool { return comparand == value; }; } #endif MInt DP[100001]; int main() { REP(i, 1, 100001) { DP[i] = DP[i - 1] * (i + 1) + MInt::Fact(i); } int T; cin >> T; REP(i, 0, T) { LL N; cin >> N; cout << N * N << endl; cout << MInt(N * N * N + N * N - N) << endl; cout << T << endl; cout << 4 * N * N + 17 << endl; cout << MInt(N)[N * N * N] << endl; cout << N << endl; cout << DP[N - 1] * N << endl; cout << endl; } return 0; }