ra (数论 , 莫比乌斯反演 , 整点统计)

#include <bits/stdc++.h>
#define For(i, l, r) for (register ll i = (ll)(l), i##end = (ll)(r); i <= i##end; ++ i)
#define Fordown(i, r, l) for (register ll i = (ll)(r), i##end = (ll)(l); i >= i##end; -- i)
#define Set(a, v) memset(a, v, sizeof(a))
using namespace std;

typedef long long ll;
inline bool chkmin(ll &a, ll b) { return b < a ? a = b, 1 : 0; }
inline bool chkmax(ll &a, ll b) { return b > a ? a = b, 1 : 0; }

inline ll read() {
    ll x = 0, fh = 1; char ch = getchar();
    for (; !isdigit(ch); ch = getchar()) if (ch == ‘-‘) fh = -1;
    for (; isdigit(ch); ch = getchar()) x = (x * 10) + (ch ^ 48);
    return x * fh;
}

void File() {
    freopen ("ra.in", "r", stdin);
    freopen ("ra.out", "w", stdout);
}

const ll Mod = 1e9 + 7;

const ll N = 1e6 + 1e3;
ll mu[N], prime[N], cnt = 0; bitset<N> is_prime;
void Init(ll maxn) {
    is_prime.set(); is_prime[0] = is_prime[1] = false; mu[1]= 1;
    For (i, 2, maxn) {
        if (is_prime[i]) 
            prime[++ cnt] = i, mu[i] = -1;
        For (j, 1, cnt) {
            ll res = prime[j] * i;
            if (res > maxn) break ;
            is_prime[res] = false;
            if (i % prime[j]) mu[res] = - mu[i];
            else { mu[res] = 0; break ; }
        }
    }
}

/*inline ll SumDown(ll a) {
    ll res = M[a]; if (res) return res;
    For (i, 1, a) {
        register ll now = a / i, Nexti = a / now;
        res += now * (Nexti - i + 1); i = Nexti;
    }
    return (M[a] = res % Mod);
}*/

typedef unsigned long long uLL;
typedef unsigned long long ull;
typedef unsigned int uint;

unordered_map<ull, uLL> M;
namespace ds {
    namespace stac {
        const int N = 100005;
        uint qu[N][2]; int qr;
        inline void pop () { qr --; }
        inline void push (uint x, uint y) { qr ++; qu[qr][0] = x; qu[qr][1] = y; }
        inline void top (uint &x, uint &y) { x = qu[qr][0]; y = qu[qr][1]; }
    }
    using stac :: push;
    using stac :: pop;
    using stac :: top;
 
    inline uLL solve (ull n) {
        uLL ret = M[n];
        if (ret) return ret;
        ull w = pow (n, 0.38), v = sqrtl (n), x, y;
        uint dx, dy, ux, uy, mx, my;
        while (v * v <= n) v ++; while (v * v > n) v --;
        x = n / v, y = n / x + 1;
        push (1, 0); push (1, 1);
        auto outside = [&] (ull x, ull y) { return x * y > n; };
        auto cut_off = [&] (ull x, uint dx, uint dy) { return (uLL)x * x * dy >= (uLL)n * dx; };
        while (stac :: qr) {
            top (dx, dy);
            while (outside (x + dx, y - dy)) {
                ret += x * dy + ull(dy + 1) * (dx - 1) / 2;
                x += dx, y -= dy;
            }
            if (y <= w) break;
            while (true) {
                pop (), ux = dx, uy = dy, top (dx, dy);
                if (outside (x + dx, y - dy)) break;
            }
            while (true) {
                mx = ux + dx, my = uy + dy;
                if (!outside (x + mx, y - my)) {
                    if (cut_off (x + mx, dx, dy)) break;
                    ux = mx, uy = my;
                } else push (dx = mx, dy = my);
            }
        }
        for (y --; y; y --) ret += n / y;
        return stac :: qr = 0, (M[n] = ret * 2 - v * v);
    }
}


int main() {
    File();
    ll n = read(), res = 0;
    Init(1e6);

    For (x, 1, sqrt(n)) if (mu[x]) {
        register ll Lim = n / (x * x), tot = 0;;
        For (d, 1, Lim) {
            register ll now = Lim / d, Nextd = Lim / now;
            tot += ds :: solve(now) * (Nextd - d + 1); d = Nextd;
        }
        (res += Mod + tot % Mod * mu[x]) %= Mod;
    }

    res = ((n % Mod) * (n % Mod) % Mod - res + Mod) % Mod;

    cout << res << endl;

#ifdef zjp_shadow
    cerr << (double) clock() / CLOCKS_PER_SEC << endl;
#endif

    return 0;
}