#if !__INCLUDE_LEVEL__ #include __FILE__ vector lldiv(ll n) { vector S; for (ll i = 1; 1LL*i*i <= n; i++) if (n%i == 0) { S.push_back(i); if (i*i != n) S.push_back(n / i); } sort(S.begin(), S.end()); return S; } //auto Div = lldiv(N); // 素因数分解 // 460 = 2^2 x 5 x 23 の場合 // 返り値は {{2, 2}, {5, 1}, {23, 1}} vector > prime_factorize(long long N) { // 答えを表す可変長配列 vector > res; // √N まで試し割っていく for (long long p = 2; p * p <= N; ++p) { // N が p で割り切れないならばスキップ if (N % p != 0) { continue; } // N の素因数 p に対する指数を求める int e = 0; while (N % p == 0) { // 指数を 1 増やす ++e; // N を p で割る N /= p; } // 答えに追加 res.emplace_back(p, e); } // 素数が最後に残ることがありうる if (N != 1) { res.emplace_back(N, 1); } return res; } int main() { ll N;cin >> N; vl Div = lldiv(N); ll L = Div.size(); vector> Pri = prime_factorize(N); vl P; fore(p,Pri)P.emplace_back(p.first); unordered_map DP; unordered_map,ll> memo; DP[1]=1; rep(i,L){ range(j,i+1,L){ if(Div[j]%Div[i]!=0)continue; mint2 Add = 1; fore(p,P){ if(Div[j]%p!=0)continue; int inum = 0; if(memo.count({Div[i],p})==0){ ll ip = p; while(Div[i]%ip==0){ inum+=1; ip*=p; } memo[{Div[i],p}]=inum; } else inum = memo[{Div[i],p}]; int jnum = 0; if(memo.count({Div[j],p})==0){ ll jp = p; while(Div[j]%jp==0){ jnum+=1; jp*=p; } memo[{Div[j],p}]=jnum; } else jnum = memo[{Div[j],p}]; if(inumjnum)Add = 0; } //cout << Div[i] << " " << Div[j] << " " << Add << "\n"; DP[Div[j]]+=DP[Div[i]]*Add; } } /* fore(d,Div){ cout << d << " " << DP[d] << "\n"; } */ cout << DP[N] << "\n"; } #else //tie(a, b, c) = t //repをllにしているので時間ギリギリならintに変換 #include #include using namespace std; using namespace atcoder; #define rep(i, n) for(long long int i = 0; i < n; i++) #define rrep(i, n) for(long long int i = n-1; i >= 0; i--) #define range(i, m, n) for(long long int i = m; i < n; i++) #define fore(i,a) for(auto &i:a) #define all(v) v.begin(), v.end() #define rall(v) v.rbegin(), v.rend() #define Sum(v) accumulate(all(v),0LL) #define minv(v) *min_element(all(v)) #define maxv(v) *max_element(all(v)) typedef long long ll; typedef vector vl; typedef vector> vvl; const ll INF = 1e16; const ll MOD1 = 1000000007; const ll MOD2 = 998244353; template inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; } template inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; } ll SN(char s){return ll(s-'0');} ll SN(string s){return stoll(s);} int alpN(char s){return int(s-'a');} int AlpN(char s){return int(s-'A');} int Nalp(int n){return char(n+97);} int NAlp(int n){return char(n+65);} using mint = modint; using mint1 = modint1000000007; using mint2 = modint998244353; using pll = pair; template ostream &operator<<(ostream &o,const vector&v){for(int i=0;i<(int)v.size();i++)o<<(i>0?" ":"")< bool contain(const std::string& s, const T& v) { return s.find(v) != std::string::npos; } ll max(int x,ll y){return max((ll)x,y);} ll max(ll x,int y){return max(x,(ll)y);} ll min(int x,ll y){return min((ll)x,y);} ll min(ll x,int y){return min(x,(ll)y);} template struct edge { int src, to; T cost; edge(int to, T cost) : src(-1), to(to), cost(cost) {} edge(int src, int to, T cost) : src(src), to(to), cost(cost) {} edge& operator=(const int& x) { to = x; return *this; } operator int() const { return to; } }; template using Edges = vector >; template using WeightedGraph = vector >; using UnWeightedGraph = vector >; template using Matrix = vector >; //unorderd_mapの拡張…https://qiita.com/hamamu/items/4d081751b69aa3bb3557 template size_t HashCombine(const size_t seed,const T &v){ return seed^(std::hash()(v)+0x9e3779b9+(seed<<6)+(seed>>2)); } /* pair用 */ template struct std::hash>{ size_t operator()(const std::pair &keyval) const noexcept { return HashCombine(std::hash()(keyval.first), keyval.second); } }; /* vector用 */ template struct std::hash>{ size_t operator()(const std::vector &keyval) const noexcept { size_t s=0; for (auto&& v: keyval) s=HashCombine(s,v); return s; } }; /* tuple用 */ template struct HashTupleCore{ template size_t operator()(const Tuple &keyval) const noexcept{ size_t s=HashTupleCore()(keyval); return HashCombine(s,std::get(keyval)); } }; template <> struct HashTupleCore<0>{ template size_t operator()(const Tuple &keyval) const noexcept{ return 0; } }; template struct std::hash>{ size_t operator()(const tuple &keyval) const noexcept { return HashTupleCore>::value>()(keyval); } }; ll ceil(ll a, ll b){ return (a + b - 1) / b; } struct string_converter { char start = 0; char type(const char &c) const { return (islower(c) ? 'a' : isupper(c) ? 'A' : isdigit(c) ? '0' : 0); } int convert(const char &c) { if(!start) start = type(c); return c - start; } int convert(const char &c, const string &chars) { return chars.find(c); } template auto convert(const T &v) { vector ret; ret.reserve(v.size()); for(auto &&e : v) ret.emplace_back(convert(e)); return ret; } template auto convert(const T &v, const string &chars) { vector ret; ret.reserve(v.size()); for(auto &&e : v) ret.emplace_back(convert(e, chars)); return ret; } int operator()(const char &v, char s = 0) { start = s; return convert(v); } int operator()(const char &v, const string &chars) { return convert(v, chars); } template auto operator()(const T &v, char s = 0) { start = s; return convert(v); } template auto operator()(const T &v, const string &chars) { return convert(v, chars); } } toint; #endif