#include #include using namespace std; namespace my{ using ml=atcoder::modint1000000007; auto&operator>>(istream&i,ml&x){int t;i>>t;x=t;return i;} auto&operator<<(ostream&o,const ml&x){return o<<(int)x.val();} #define eb emplace_back #define LL(...) ll __VA_ARGS__;lin(__VA_ARGS__) #define FO(n) for(ll ij=n;ij-->0;) #define FOR(i,...) for(auto[i,i##stop,i##step]=range(0,__VA_ARGS__);i=i##stop;i+=i##step) #define fe(a,i,...) for(auto&&__VA_OPT__([)i __VA_OPT__(,__VA_ARGS__]):a) #define single_testcase void solve();}int main(){my::io();my::solve();}namespace my{ void io(){cin.tie(nullptr)->sync_with_stdio(0);cout<>(istream&i,ulll&x){ull t;i>>t;x=t;return i;} ostream&operator<<(ostream&o,const ulll&x){return(x<10?o:o<>(istream&i,lll&x){ll t;i>>t;x=t;return i;} ostream&operator<<(ostream&o,const lll&x){return o<0?x:-x);} constexpr auto range(bool s,auto...a){arrayr{0,0,1};ll I=0;((r[I++]=a),...);if(!s&&I==1)swap(r[0],r[1]);r[0]-=s;if(s)r[2]*=-1;return r;} constexpr char newline=10; constexpr char space=32; constexpr auto abs(auto x){return x<0?-x:x;} lll pow(lll x,ll n){assert(n>=0);lll r=1;while(n)n&1?r*=x:r,x*=x,n>>=1;return r;} templatecommon_type_tgcd(T a,U b){return b?gcd(b,a%b):abs(a);} auto gcd(auto...a){common_type_tr=0;((r=gcd(r,a)),...);return r;} templatestruct pair{ A a;B b; pair()=default; pair(A a,B b):a(a),b(b){} pair(const std::pair&p):a(p.first),b(p.second){} auto operator<=>(const pair&)const=default; pair operator+(const pair&p)const{return{a+p.a,b+p.b};} friend istream&operator>>(istream&i,pair&p){return i>>p.a>>p.b;} friend ostream&operator<<(ostream&o,const pair&p){return o<>auto&sort(auto&a,F f={}){ranges::sort(a,f);return a;} templateauto pack_kth(const auto&...a){return get(make_tuple(a...));} templateauto pack_slice(const auto&...a){return[&](index_sequence){return array{get(forward_as_tuple(a...))...};}(make_index_sequence{});} templateconcept vectorial=is_base_of_v,V>; templateistream&operator>>(istream&i,vector&v){fe(v,e)i>>e;return i;} templateostream&operator<<(ostream&o,const vector&v){fe(v,e)o<?newline:space);return o;} templatestruct vec; templatestruct tensor_helper{using type=vec::type>;}; templatestruct tensor_helper<0,T>{using type=T;}; templateusing tensor=typename tensor_helper::type; templatestruct vec:vector{ using vector::vector; vec(const vector&v){vector::operator=(v);} templaterequires(sizeof...(A)>=3)vec(A...a){const ll n=sizeof...(a)-1;auto t=pack_slice(a...);ll s[n];fo(i,n)s[i]=t[i];*this=make_vec(s,pack_kth(a...));} templatestatic auto make_vec(const ll(&s)[n],T x){if constexpr(i==n-1)return vec(s[i],x);else{auto X=make_vec(s,x);return vec(s[i],X);}} vec&operator^=(const vec&u){this->insert(this->end(),u.begin(),u.end());return*this;} vec operator^(const vec&u)const{return vec{*this}^=u;} vec&operator+=(const vec&u){vec&v=*this;assert(v.size()==u.size());fo(i,v.size())v[i]+=u[i];return v;} vec&operator-=(const vec&u){vec&v=*this;assert(v.size()==u.size());fo(i,v.size())v[i]-=u[i];return v;} vec operator+(const vec&u)const{return vec{*this}+=u;} vec operator-(const vec&u)const{return vec{*this}-=u;} vec&operator++(){fe(*this,e)++e;return*this;} vec&operator--(){fe(*this,e)--e;return*this;} vec operator-()const{vec v=*this;fe(v,e)e=-e;return v;} vec&operator%=(auto M){vec&v=*this;fe(v,e)e%=M;return v;} vec operator%(auto M)const{return vec{*this}%=M;} ll size()const{return vector::size();} template>auto sort(F f={})const{vec v=*this;ranges::sort(v,f);return v;} }; templaterequires(sizeof...(A)>=2)vec(A...a)->vec(declval>()))>>>; vec(ll)->vec; void lin(auto&...a){(cin>>...>>a);} templatevoid pp(const auto&...a){ll n=sizeof...(a);((cout<0,c)),...);cout<auto rle(const vec&a){vec>r;fe(a,e)r.size()&&e==r.back().a?++r.back().b:r.eb(e,1).b;return r;} templateauto rce(veca){return rle(sort(a));} ll rand(auto...a){arrayv{};ll I=0;((v[I++]=a),...);auto[l,r]=v;if(I==1)swap(l,r);static ll t=495;t^=t<<7,t^=t>>9;return lconcept modulary=requires(T t){t.mod();}; templatestruct factorial{ ll M; vecfa,fa_inv; factorial(ll M):M(M),fa(M+1){ fa[0]=1; fo(i,1,M+1)fa[i]=fa[i-1]*i; if constexpr(modulary){ fa_inv.resize(M+1); fa_inv.back()=fa.back().inv(); of(i,M)fa_inv[i]=fa_inv[i+1]*(i+1); } } T operator()(ll n)const{assert(n<=M);return fa[n];} T inv(ll n)const{assert(n<=M);return fa_inv[n];} }; struct montgomery64{ using modular=montgomery64; using i64=__int64_t; using u64=__uint64_t; using u128=__uint128_t; static inline u64 N; static inline u64 N_inv; static inline u64 R2; static int set_mod(u64 N){ if(modular::N==N)return 0; assert(N<(1ULL<<63)); assert(N&1); modular::N=N; R2=-u128(N)%N; N_inv=N; fo(5)N_inv*=2-N*N_inv; assert(N*N_inv==1); return 0; } static inline int init=set_mod(998244353); static u64 mod(){return N;} u64 a; montgomery64(const i64&a=0):a(reduce((u128)(a%(i64)N+N)*R2)){} static u64 reduce(const u128&T){ u128 r=(T+u128(u64(T)*-N_inv)*N)>>64; return r>=N?r-N:r; } auto&operator+=(const modular&b){if((a+=b.a)>=N)a-=N;return*this;} auto&operator-=(const modular&b){if(i64(a-=b.a)<0)a+=N;return*this;} auto&operator*=(const modular&b){a=reduce(u128(a)*b.a);return*this;} auto&operator/=(const modular&b){*this*=b.inv();return*this;} friend auto operator+(const modular&a,const modular&b){return modular{a}+=b;} friend auto operator-(const modular&a,const modular&b){return modular{a}-=b;} friend auto operator*(const modular&a,const modular&b){return modular{a}*=b;} friend auto operator/(const modular&a,const modular&b){return modular{a}/=b;} friend bool operator==(const modular&a,const modular&b){return a.a==b.a;} auto operator-()const{return modular{}-modular{*this};} modular pow(u128 n)const{ modular r{1},x{*this}; while(n){ if(n&1)r*=x; x*=x; n>>=1; } return r; } modular inv()const{u64 a=val(),b=N,u=1,v=0;assert(gcd(a,b)==1);while(b)swap(u-=a/b*v,v),swap(a-=a/b*b,b);return u;} u64 val()const{return reduce(a);} friend istream&operator>>(istream&i,montgomery64&b){ll t;i>>t;b=t;return i;} friend ostream&operator<<(ostream&o,const montgomery64&b){return o<as){ ll d=n-1; while(~d&1)d>>=1; using modular=montgomery64; auto pre_mod=modular::mod(); modular::set_mod(n); modular one=1,minus_one=n-1; fe(as,a){ if(a%n==0)continue; ll t=d; modular y=modular(a).pow(t); while(t!=n-1&&y!=one&&y!=minus_one)y*=y,t<<=1; if(y!=minus_one&&~t&1)return modular::set_mod(pre_mod),0; } return modular::set_mod(pre_mod),1; } bool is_prime(ll n){ if(~n&1)return n==2; if(n<=1)return 0; if(n<4759123141LL)return miller_rabin(n,{2,7,61}); return miller_rabin(n,{2,325,9375,28178,450775,9780504,1795265022}); } ll pollard_rho(ll n){ if(~n&1)return 2; if(is_prime(n))return n; using modular=montgomery64; auto pre_mod=modular::mod(); modular::set_mod(n); modular R,one=1; auto f=[&](const modular&x){return x*x+R;}; while(1){ modular x,y,ys,q=one; R=rand(2,n),y=rand(2,n); ll g=1; constexpr ll m=128; for(ll r=1;g==1;r<<=1){ x=y; fo(r)y=f(y); for(ll k=0;g==1&&k0); auto f=[](auto&f,ll m){ if(m==1)return vec{}; ll d=pollard_rho(m); return d==m?vec{d}:f(f,d)^f(f,m/d); }; return rce(f(f,n)); } templatestruct combination_small_K{ ll M; factorialfa; combination_small_K(ll M):M(M),fa(M){} inline T operator()(ll n,ll k)const{return c(n,k);} T c(ll n,ll k)const{ if(n<0||k<0||nM)k=n-k; assert(k<=M); T r=1; fo(i,n-k+1,n+1)r*=i; if constexpr(modulary)return r*fa.inv(k); else return r/fa(k); } T p(ll n,ll k)const{return c(n,k)*fa(k);} T h(ll n,ll k)const{return c(n+k-1,k-1);} }; single_testcase void solve(){ LL(N,K); combination_small_Kcomb(100); ml ans=1; fe(factorize(N),p,b)ans*=comb.h(b,K+1); pp(ans); }}