#line 2 "library/other/template.hpp" #define _CRT_SECURE_NO_WARNINGS #ifndef __clang__ #ifdef ONLINE_JUDGE #pragma GCC target("avx512f") #elif defined EVAL #else #pragma GCC target("avx2") #endif #pragma GCC optimize("O3") #pragma GCC optimize("unroll-loops") #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define rep(i, n) for (int i = 0; i < int(n); i++) #define REP(i, n) for (int i = 1; i <= int(n); i++) #define all(V) V.begin(), V.end() using i128 = __int128_t; using u128 = __uint128_t; using uint = unsigned int; using lint = long long; using ulint = unsigned long long; using IP = std::pair; using LP = std::pair; constexpr int INF = INT_MAX / 2; constexpr lint LINF = LLONG_MAX / 2; constexpr double eps = DBL_EPSILON; constexpr double PI = 3.141592653589793238462643383279; template class prique : public std::priority_queue, std::greater> { }; template inline constexpr decltype(auto) lambda_fix(F&& f) { return [f = std::forward(f)](auto&&... args) { return f(f, std::forward(args)...); }; } template constexpr std::vector make_vec(size_t n) { return std::vector(n); } template constexpr auto make_vec(size_t n, Args&&... args) { return std::vector(args...))>( n, make_vec(std::forward(args)...)); } template constexpr inline bool chmax(T& lhs, const U& rhs) noexcept { if (lhs < rhs) { lhs = rhs; return true; } return false; } template constexpr inline bool chmin(T& lhs, const U& rhs) noexcept { if (lhs > rhs) { lhs = rhs; return true; } return false; } constexpr inline lint gcd(lint a, lint b) noexcept { while (b) { lint c = a; a = b; b = c % b; } return a; } inline lint lcm(lint a, lint b) noexcept { return a / gcd(a, b) * b; } constexpr bool isprime(lint n) noexcept { if (n == 1) return false; for (int i = 2; i * i <= n; i++) { if (n % i == 0) return false; } return true; } template constexpr T mypow(T a, lint b) noexcept { T res(1); while (true) { if (b & 1) res *= a; b >>= 1; if (!b) break; a *= a; } return res; } constexpr lint modpow(lint a, lint b, lint m) noexcept { a %= m; lint res(1); while (b) { if (b & 1) { res *= a; res %= m; } a *= a; a %= m; b >>= 1; } return res; } template constexpr void printArray(const std::vector& vec, char split = ' ') { rep(i, vec.size()) { std::cout << vec[i]; std::cout << (i == (int)vec.size() - 1 ? '\n' : split); } } template constexpr void printArray(InputIter l, InputIter r, char split = ' ') { auto rprev = std::prev(r); for (auto i = l; i != r; i++) { std::cout << *i; std::cout << (i == rprev ? '\n' : split); } } LP extGcd(lint a, lint b) noexcept { if (b == 0) return {1, 0}; LP s = extGcd(b, a % b); std::swap(s.first, s.second); s.second -= a / b * s.first; return s; } LP ChineseRem(const lint& b1, const lint& m1, const lint& b2, const lint& m2) noexcept { auto p = extGcd(m1, m2); lint g = gcd(m1, m2), l = m1 / g * m2; lint tmp = (b2 - b1) / g * p.first % (m2 / g); lint r = (b1 + m1 * tmp + l) % l; return {r, l}; } int LCS(const std::string& a, const std::string& b) { auto dp = make_vec(a.size() + 1, b.size() + 1); rep(i, a.size()) { rep(j, b.size()) { chmax(dp[i + 1][j], dp[i][j]); chmax(dp[i][j + 1], dp[i][j]); if (a[i] == b[j]) chmax(dp[i + 1][j + 1], dp[i][j] + 1); } chmax(dp[i + 1][b.size()], dp[i][b.size()]); } rep(j, b.size()) chmax(dp[a.size()][j + 1], dp[a.size()][j]); return dp[a.size()][b.size()]; } template ::value, std::nullptr_t> = nullptr> void compress(std::vector& vec) { auto tmp = vec; std::sort(all(tmp)); tmp.erase(std::unique(all(tmp)), tmp.end()); for (T& i : vec) i = std::lower_bound(all(tmp), i) - tmp.begin(); } template void compress(T* l, T* r) { std::vector tmp(l, r); std::sort(all(tmp)); tmp.erase(std::unique(all(tmp)), tmp.end()); for (auto i = l; i < r; i++) { *i = std::lower_bound(all(tmp), *i) - tmp.begin(); } } template void compress(InputIter l, InputIter r) { std::vector tmp(l, r); std::sort(all(tmp)); tmp.erase(std::unique(all(tmp)), tmp.end()); for (auto i = l; i < r; i++) { *i = std::lower_bound(all(tmp), *i) - tmp.begin(); } } #line 3 "library/other/type_traits.hpp" class ModInt__Base {}; class StaticModInt__Base : ModInt__Base {}; class DynamicModInt__Base : ModInt__Base {}; template class is_ModInt : public std::is_base_of {}; template constexpr bool is_ModInt_v = is_ModInt::value; template class is_StaticModInt : public std::is_base_of {}; template constexpr bool is_StaticModInt_v = is_StaticModInt::value; template class is_DynamicModInt : public std::is_base_of {}; template constexpr bool is_DynamicModInt_v = is_DynamicModInt::value; #line 4 "library/algebraic/DynamicModInt.hpp" class DynamicModInt : DynamicModInt__Base { static uint modulo; int value; public: static void setMod(uint mod) { modulo = mod; } constexpr DynamicModInt() : value(0) {} template DynamicModInt(T value = 0) : value(value) { this->value = (value < 0 ? -(-value % modulo) + modulo : lint(value)) % modulo; } inline DynamicModInt inv() const { return mypow(*this, modulo - 2); } inline constexpr operator int() const { return value; } inline DynamicModInt& operator+=(const DynamicModInt& x) { value = value + x.value; if (value >= modulo) value -= modulo; return *this; } inline DynamicModInt& operator++() { if (value == modulo - 1) value = 0; else value++; return *this; } inline DynamicModInt operator++(int) { DynamicModInt res = *this; ++*this; return res; } inline DynamicModInt operator-() const { return DynamicModInt(0) -= *this; } inline DynamicModInt& operator-=(const DynamicModInt& x) { value -= x.value; if (value < 0) value += modulo; return *this; } inline DynamicModInt& operator--() { if (value == 0) value = modulo - 1; else value--; return *this; } inline DynamicModInt operator--(int) { DynamicModInt res = *this; --*this; return res; } inline DynamicModInt& operator*=(const DynamicModInt& x) { value = (lint)value * x.value % modulo; return *this; } inline DynamicModInt& operator/=(const DynamicModInt& rhs) { return *this *= rhs.inv(); } template DynamicModInt operator+(const T& rhs) const { return DynamicModInt(*this) += rhs; } template DynamicModInt& operator+=(const T& rhs) { return operator+=(DynamicModInt(rhs)); } template DynamicModInt operator-(const T& rhs) const { return DynamicModInt(*this) -= rhs; } template DynamicModInt& operator-=(const T& rhs) { return operator-=(DynamicModInt(rhs)); } template DynamicModInt operator*(const T& rhs) const { return DynamicModInt(*this) *= rhs; } template DynamicModInt& operator*=(const T& rhs) { return operator*=(DynamicModInt(rhs)); } template DynamicModInt operator/(const T& rhs) const { return DynamicModInt(*this) /= rhs; } template DynamicModInt& operator/=(const T& rhs) { return operator/=(DynamicModInt(rhs)); } static int primitive_root() { int p = 0; static std::random_device rd; static std::mt19937 mt(rd()); std::uniform_int_distribution<> uid(1, modulo - 1); // use naive factorize due to file size limit std::vector vec; int tmp = modulo - 1; for (int i = 2; i * i <= tmp; i++) { if (tmp % i == 0) { vec.emplace_back(i); do { tmp /= i; } while (tmp % i == 0); } } if (tmp != 1) vec.emplace_back(tmp); vec.erase(std::unique(all(vec)), vec.end()); while (true) { p = uid(mt); bool f = true; for (const auto& i : vec) { if (mypow(DynamicModInt(p), (modulo - 1) / i) == 1) { f = false; break; } } if (f) return p; } } }; uint DynamicModInt::modulo = 1000000007; #line 3 "main.cpp" using ModInt = DynamicModInt; int N, M; ModInt dp[210][110][10010]; int main() { std::cin >> N >> M; dp[0][0][0] = 1; rep(i, 2 * N) { rep(j, std::min(i, 2 * N - i) + 1) { rep(k, N * N) { dp[i + 1][j + 1][k + (i - j) / 2] += dp[i][j][k]; if (j) dp[i + 1][j - 1][k] += dp[i][j][k]; } } } rep(i, N * N + 1) std::cout << dp[2 * N][0][i] << std::endl; return 0; }