//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 #include #include #include #include #include #include using namespace std; // typedef //------------------------------------------ typedef long long LL; typedef vector VI; typedef vector VB; typedef vector VC; typedef vector VD; typedef vector VS; typedef vector VLL; typedef vector VVI; typedef vector VVB; typedef vector VVS; typedef vector VVLL; typedef vector VVVI; typedef vector VVVLL; typedef pair PII; typedef pair PLL; typedef pair PIS; typedef pair PSI; typedef pair PSS; typedef vector VPII; typedef vector VPLL; typedef vector VVPII; typedef vector VVPLL; typedef vector VVS; typedef map MII; typedef map MLL; typedef map MSI; typedef map MIS; // container util //------------------------------------------ #define ALL(a) (a).begin(),(a).end() #define SZ(a) int((a).size()) #define EACH(i, arr) for(typeof((arr).begin()) i=(arr).begin(); i!=(arr).end(); ++i) #define EXIST(str, e) ((str).find(e)!=(str).end()) #define COUNT(arr, v) count((arr).begin(), (arr).end(), v) #define SEARCH(v, w) search((v).begin(), (v).end(), (w).begin(), (w).end()) #define SORT(c) sort((c).begin(),(c).end()) #define RSORT(c) sort((c).rbegin(),(c).rend()) #define REVERSE(c) reverse((c).begin(), (c).end()) #define ROTATE_LEFT(arr, c) rotate((arr).begin(), (arr).begin()+(c), (arr).end()) #define ROTATE_RIGHT(arr, c) rotate((arr).rbegin(), (arr).rbegin() + (c), (arr).rend()) #define SUMI(arr) accumulate((arr).begin(), (arr).end(), 0) #define SUMD(arr) accumulate((arr).begin(), (arr).end(), 0.) #define SUMLL(arr) accumulate((arr).begin(), (arr).end(), 0LL) #define MULD(arr) accumulate((arr).begin(), (arr).end(), 1., multiplies()) #define UB(arr, n) upper_bound((arr).begin(), (arr).end(), n) #define LB(arr, n) lower_bound((arr).begin(), (arr).end(), n) #define PB push_back #define MP make_pair #define ft first #define sd second // input output //------------------------------------------ #define GL(s) getline(cin, (s)) #define INIT() std::ios::sync_with_stdio(false);std::cin.tie(0) #define OUT(d) std::cout<<(d) #define OUT_L(d) std::cout<<(d)< istream &operator>>(istream &in, pair &p) { in >> p.first >> p.second; return in; } template istream &operator>>(istream &in, vector &v) { for (auto &x: v) in >> x; return in; } template ostream &operator<<(ostream &out, const std::pair &p) { out << "[" << p.first << ", " << p.second << "]" << "\n"; return out; } template inline bool chmin(T1 &a, T2 b) { if (a > b) { a = b; return true; } return false; } template inline bool chmax(T1 &a, T2 b) { if (a < b) { a = b; return true; } return false; } //repetition //------------------------------------------ #define FOR(i, a, b) for(int i=(a);i<(b);++i) #define RFOR(i, a, b) for(int i=(b)-1;i>=(a);--i) #define REP(i, n) FOR(i,0,n) #define RREP(i, n) for(int i = n-1;i >= 0;i--) #define FORLL(i, a, b) for(LL i=LL(a);i=LL(a);--i) #define REPLL(i, n) for(LL i=0;i=0;--i) #define FOREACH(x, arr) for(auto &(x) : (arr)) // Option + Control + K Terminal // Command + Control + K Run // Command + b EOF //------------------------------------------ //------------------------------------------ template class ModInt { using u64 = int_fast64_t; public: u64 x; constexpr ModInt() : x(0) {} constexpr ModInt(int_fast64_t v) : x((v % Modulas + Modulas) % Modulas) {} constexpr ModInt operator+(const ModInt rhs) const noexcept { return ModInt(*this) += rhs; } constexpr ModInt operator-(const ModInt rhs) const noexcept { return ModInt(*this) -= rhs; } constexpr ModInt operator*(const ModInt rhs) const noexcept { return ModInt(*this) *= rhs; } constexpr ModInt operator/(const ModInt rhs) const noexcept { return ModInt(*this) /= rhs; } constexpr ModInt operator/(const long long rhs) const noexcept { return ModInt(*this) /= rhs; } constexpr ModInt operator+=(const ModInt rhs) noexcept { x += rhs.x; if (x >= Modulas) x -= Modulas; return *this; } constexpr ModInt operator+=(const long long rhs) noexcept { auto hs = ModInt(rhs); (*this) += hs; return *this; } constexpr ModInt operator-=(const ModInt rhs) noexcept { if (x < rhs.x) x += Modulas; x -= rhs.x; return *this; } constexpr ModInt operator-=(const long long rhs) noexcept { auto hs = ModInt(rhs); (*this) -= hs; return *this; } constexpr ModInt operator*=(const ModInt rhs) noexcept { x = x * rhs.x % Modulas; return *this; } constexpr ModInt operator*=(const long long rhs) noexcept { auto hs = ModInt(rhs); (*this) *= hs; return *this; } constexpr ModInt &operator/=(ModInt rhs) noexcept { u64 exp = Modulas - 2; while (exp > 0) { if (exp & 1ul) *this *= rhs; rhs *= rhs; exp >>= 1ul; } return *this; } constexpr ModInt &operator/=(long long rhs) noexcept { auto hs = ModInt(rhs); (*this) /= hs; return *this; } constexpr ModInt &operator++() noexcept { x++; if (x >= Modulas) x -= Modulas; return *this; } constexpr ModInt &operator--() noexcept { if (x == 0) x += Modulas; x--; return *this; } constexpr bool operator<(const ModInt rhs) const noexcept { return x < rhs.x; } constexpr bool operator==(const ModInt rhs) const noexcept { return this->x == rhs.x; } constexpr bool operator!=(const ModInt rhs) const noexcept { return !(*this == rhs); } friend istream &operator>>(istream &in, ModInt &m) { in >> m.x; if (m.x < 0) m.x += Modulas; m.x %= Modulas; return in; } friend ostream &operator<<(ostream &out, const ModInt &p) { out << p.x; return out; } constexpr ModInt pow(u64 p) const { ModInt ret(1); ModInt mul(x); while (p > 0) { if (p & 1ul) ret *= mul; mul *= mul; p >>= 1ul; } return ret; } constexpr ModInt operator~() const noexcept { u64 exp = Modulas - 2; return pow(exp); } constexpr static ModInt arith_sum(ModInt a, ModInt d, ModInt n) noexcept { return (a * ModInt(2) + (n - 1) * d) * n / ModInt(2); } }; template using Matrix = vector>; template Matrix mat_add(const Matrix A, const Matrix B) { int m = A.size(); int n = B[0].size(); Matrix C(m, vector(n)); for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { C[i][j] = A[i][j] + B[i][j]; } } return C; } template Matrix mat_sub(const Matrix A, const Matrix B) { int m = A.size(); int n = B[0].size(); Matrix C(m, vector(n)); for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { C[i][j] = A[i][j] - B[i][j]; } } return C; } template Matrix mat_mul(const Matrix A, const Matrix B) { int m = A.size(); int l = B.size(); int n = B[0].size(); Matrix C(m, vector(n)); for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < l; k++) { C[i][j] += A[i][k] * B[k][j]; } } } return C; } template Matrix mat_pow(Matrix A, LL p) { Matrix ret(A.size(), vector(A.size(), 0)); for (int i = 0; i < A.size(); i++) ret[i][i] = 1; while (p > 0) { if (p & 1) ret = mat_mul(ret, A); A = mat_mul(A, A); p >>= 1; } return ret; } int main() { LL M, K; cin >> M >> K; Matrix> A(M, vector>(M, 1)); for (LL i = 0; i < M; i++) { for (LL j = 0; j < M; j++) { LL to = (i * j) % M; A[i][to] += 1; } } auto B = mat_pow(A, K); Matrix> ori(M, vector>(1, 0)); ori[0][0] = 1; auto C = mat_mul(B, ori ); cout << C[0][0] << endl; }