#line 2 "library/other/template.hpp" #define _CRT_SECURE_NO_WARNINGS #pragma target("avx2") #pragma optimize("O3") #pragma optimize("unroll-loops") #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<(n);i++) #define REP(i,n) for(int i=1;i<=(n);i++) #define all(V) V.begin(),V.end() typedef unsigned int uint; typedef long long lint; typedef unsigned long long ulint; typedef std::pair P; typedef std::pair LP; 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 bool chmax(T& lhs, const U& rhs) { if (lhs < rhs) { lhs = rhs; return 1; } return 0; } template inline bool chmin(T& lhs, const U& rhs) { if (lhs > rhs) { lhs = rhs; return 1; } return 0; } inline lint gcd(lint a, lint b) { while (b) { lint c = a; a = b; b = c % b; } return a; } inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; } bool isprime(lint n) { if (n == 1)return false; for (int i = 2; i * i <= n; i++) { if (n % i == 0)return false; } return true; } template T mypow(T a, lint b) { T res(1); while(b){ if(b&1)res*=a; a*=a; b>>=1; } return res; } lint modpow(lint a, lint b, lint m) { lint res(1); while(b){ if(b&1){ res*=a;res%=m; } a*=a;a%=m; b>>=1; } return res; } template void printArray(std::vector& vec) { rep(i, vec.size()){ std::cout << vec[i]; std::cout<<(i==(int)vec.size()-1?"\n":" "); } } template void printArray(T l, T r) { T rprev = std::prev(r); for (T i = l; i != rprev; i++) { std::cout << *i << " "; } std::cout << *rprev << std::endl; } LP extGcd(lint a,lint b) { 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) { lint p=extGcd(m1,m2).first; lint tmp=(b2-b1)*p%m2; lint r=(b1+m1*tmp+m1*m2)%(m1*m2); return std::make_pair(r,m1*m2); } template inline constexpr decltype(auto) lambda_fix(F&& f){ return [f=std::forward(f)](auto&&... args){ return f(f,std::forward(args)...); }; } #line 3 "library/algebraic/DynamicModInt.hpp" class DynamicModInt { lint value; public: static unsigned int modulo; DynamicModInt() : value(0) {} template DynamicModInt(T value = 0) : value(value) { if (value < 0)value = -(lint)(-value % modulo) + modulo; this->value = value % modulo; } static inline void setMod(const unsigned int& mod){modulo=mod;} inline DynamicModInt inv()const{return mypow(*this,modulo-2);} inline operator int()const { return value; } inline DynamicModInt& operator+=(const DynamicModInt& x) { 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 = 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)); } }; unsigned int DynamicModInt::modulo=1000000007; std::istream& operator>>(std::istream& ist, DynamicModInt& x) { lint a; ist >> a; x = a; return ist; } #line 4 "library/algebraic/StaticModInt.hpp" template class StaticModInt { lint value; public: static constexpr unsigned int mod_value = modulo; StaticModInt() : value(0) {} template StaticModInt(T value = 0) : value(value) { if (value < 0)value = -(lint)(-value % modulo) + modulo; this->value = value % modulo; } inline StaticModInt inv()const{return mypow(*this,modulo-2);} inline operator int()const { return value; } inline StaticModInt& operator+=(const StaticModInt& x) { value += x.value; if (value >= modulo)value -= modulo; return *this; } inline StaticModInt& operator++() { if (value == modulo - 1)value = 0; else value++; return *this; } inline StaticModInt operator++(int){ StaticModInt res=*this; --*this; return res; } inline StaticModInt operator-()const { return StaticModInt(0) -= *this; } inline StaticModInt& operator-=(const StaticModInt& x) { value -= x.value; if (value < 0)value += modulo; return *this; } inline StaticModInt& operator--() { if (value == 0)value = modulo - 1; else value--; return *this; } inline StaticModInt operator--(int){ StaticModInt res=*this; --*this; return res; } inline StaticModInt& operator*=(const StaticModInt& x) { value = value * x.value % modulo; return *this; } inline StaticModInt& operator/=(const StaticModInt& rhs) { return *this*=rhs.inv(); } template StaticModInt operator+(const T& rhs)const { return StaticModInt(*this) += rhs; } template StaticModInt& operator+=(const T& rhs) { return operator+=(StaticModInt(rhs)); } template StaticModInt operator-(const T& rhs)const { return StaticModInt(*this) -= rhs; } template StaticModInt& operator-=(const T& rhs) { return operator-=(StaticModInt(rhs)); } template StaticModInt operator*(const T& rhs)const { return StaticModInt(*this) *= rhs; } template StaticModInt& operator*=(const T& rhs) { return operator*=(StaticModInt(rhs)); } template StaticModInt operator/(const T& rhs)const { return StaticModInt(*this) /= rhs; } template StaticModInt& operator/=(const T& rhs) { return operator/=(StaticModInt(rhs)); } }; template std::istream& operator>>(std::istream& ist, StaticModInt& x) { lint a; ist >> a; x = a; return ist; } #line 5 "library/algebraic/Combinatorics.hpp" template class Combinatorics{ protected: std::vector factorial; void append(int n)noexcept{ while(factorial.size()<=n){ factorial.emplace_back(factorial.back()*factorial.size()); } } public: Combinatorics()noexcept:factorial(1,1){} Combinatorics(int n)noexcept:factorial(1,1){append(n);} virtual T getComb(int a,int b)noexcept{ append(a); return factorial[a]/factorial[a-b]/factorial[b]; } virtual T getDcomb(int a,int b)noexcept{ return getComb(a+b-1,b); } }; template class ModCombinatorics:Combinatorics{ static_assert(std::is_same>::value ||std::is_same::value); using Combinatorics::factorial; std::vector inv; void append(int n)noexcept{ int tmp=factorial.size(); if(n::append(n); inv.resize(n+1); inv[n]=T(1)/factorial.back(); for(int i=n;i>tmp;i--)inv[i-1]=inv[i]*i; } public: ModCombinatorics()noexcept:Combinatorics(),inv(1,1){} ModCombinatorics(int n)noexcept:Combinatorics(n),inv(1,1){append(n);} T getComb(int a,int b)noexcept override{ append(a); return factorial[a]*inv[a-b]*inv[b]; } T getDcomb(int a,int b)noexcept override{ return getComb(a+b-1,b); } T perm(int a,int b)noexcept{ append(a); return factorial[a]*inv[a-b]; } }; #line 4 "main.cpp" using ModInt=StaticModInt<1000000007>; lint N; int main(){ std::cin>>N; lint M=std::sqrt(N); ModInt ans=0; for(int i=2;i<=M;i++){ lint a=N; while(a){ ans+=a%i; a/=i; } } REP(i,M-1){ lint l=N/(i+1)+1,r=N/i; ans+=i*(r-l+1)+ModInt(2*N-i*l-i*r)*(r-l+1)/2; } std::cout<