/*
lengli_QAQ
Hope there are no bugs!!!
*/
#include <bits/stdc++.h>
#define fastio std::ios::sync_with_stdio(0); std::cin.tie(0); std::cout.tie(0)
#define all(x) x.begin(),x.end()
#define pb push_back

template <unsigned M_> struct ModInt {
  static constexpr unsigned M = M_;
  unsigned x;
  constexpr ModInt() : x(0U) {}
  constexpr ModInt(unsigned x_) : x(x_ % M) {}
  constexpr ModInt(unsigned long long x_) : x(x_ % M) {}
  constexpr ModInt(int x_) : x(((x_ %= static_cast<int>(M)) < 0) ? (x_ + static_cast<int>(M)) : x_) {}
  constexpr ModInt(long long x_) : x(((x_ %= static_cast<long long>(M)) < 0) ? (x_ + static_cast<long long>(M)) : x_) {}
  ModInt &operator+=(const ModInt &a) { x = ((x += a.x) >= M) ? (x - M) : x; return *this; }
  ModInt &operator-=(const ModInt &a) { x = ((x -= a.x) >= M) ? (x + M) : x; return *this; }
  ModInt &operator*=(const ModInt &a) { x = (static_cast<unsigned long long>(x) * a.x) % M; return *this; }
  ModInt &operator/=(const ModInt &a) { return (*this *= a.inv()); }
  ModInt pow(long long e) const {
    if (e < 0) return inv().pow(-e);
    ModInt a = *this, b = 1U; for (; e; e >>= 1) { if (e & 1) b *= a; a *= a; } return b;
  }
  ModInt inv() const {
    unsigned a = M, b = x; int y = 0, z = 1;
    for (; b; ) { const unsigned q = a / b; const unsigned c = a - q * b; a = b; b = c; const int w = y - static_cast<int>(q) * z; y = z; z = w; }
    assert(a == 1U); return ModInt(y);
  }
  ModInt operator+() const { return *this; }
  ModInt operator-() const { ModInt a; a.x = x ? (M - x) : 0U; return a; }
  ModInt operator+(const ModInt &a) const { return (ModInt(*this) += a); }
  ModInt operator-(const ModInt &a) const { return (ModInt(*this) -= a); }
  ModInt operator*(const ModInt &a) const { return (ModInt(*this) *= a); }
  ModInt operator/(const ModInt &a) const { return (ModInt(*this) /= a); }
  template <class T> friend ModInt operator+(T a, const ModInt &b) { return (ModInt(a) += b); }
  template <class T> friend ModInt operator-(T a, const ModInt &b) { return (ModInt(a) -= b); }
  template <class T> friend ModInt operator*(T a, const ModInt &b) { return (ModInt(a) *= b); }
  template <class T> friend ModInt operator/(T a, const ModInt &b) { return (ModInt(a) /= b); }
  explicit operator bool() const { return x; }
  bool operator==(const ModInt &a) const { return (x == a.x); }
  bool operator!=(const ModInt &a) const { return (x != a.x); }
  bool operator<(const ModInt &a) const { return (x < a.x); }
  bool operator>(const ModInt &a) const { return (x > a.x); }
  bool operator<=(const ModInt &a) const { return (x <= a.x); }
  bool operator>=(const ModInt &a) const { return (x >= a.x); }
  friend std::ostream &operator<<(std::ostream &os, const ModInt &a) { return os << a.x; }
  friend std::istream &operator>>(std::istream &is, ModInt &a) {int v;is >> v;a = ModInt(v);return is;}
};
constexpr unsigned MO = 998244353;
using Mint = ModInt<MO>;

#define i64 long long

constexpr int N=2000010;

namespace min25{
    i64 n,idx,D;
    i64 w[N],id1[N],id2[N];
    i64 prime[N],st[N],cnt;
    std::vector<std::vector<Mint>> g,sum;

    i64 id(i64 x){
        if(x<=D) return id1[x];
        return id2[n/x];
    }

    void init(i64 nn){
        n=nn;
        g.clear(),sum.clear();
        idx=0,cnt=0;
        D=std::sqrt(n);

        for(i64 l=1,r;l<=n;l=r+1){
            r=n/(n/l),w[++idx]=n/l;
            if(w[idx]<=D) id1[w[idx]]=idx;
            else id2[n/w[idx]]=idx;
        }

        for(i64 i=2;i<=D;i++){
            if(!st[i]) prime[++cnt]=i;
            for(i64 j=1;prime[j]*i<=D;j++){
                st[i*prime[j]]=1;
                if(i%prime[j]==0) break;
            }
        }
    }

    void insert(std::function<Mint(i64)> f,std::function<Mint(i64)> presum){
        std::vector<Mint> ng(idx+2),nsum(cnt+2);
        for(int i=1;i<=idx;i++) ng[i]=presum(w[i])-1;
        for(int i=1;i<=cnt;i++) nsum[i]=(nsum[i-1]+f(prime[i]));
        for(int i=1;i<=cnt;i++){
            for(int j=1;j<=idx and prime[i]*prime[i]<=w[j];j++){
                ng[j]=ng[j]-f(prime[i])*(ng[id(w[j]/prime[i])]-nsum[i-1]);
            }
        }
        g.pb(ng),sum.pb(nsum);
    }

    Mint jxf(i64 x){
        return Mint(x)*x-x;
    }

    Mint S(i64 x,int j){
        if(prime[j]>x) return 0;
        Mint res=(g[0][id(x)]-sum[0][j])-(g[1][id(x)]-sum[1][j]);
        for(int i=j+1;i<=cnt and prime[i]*prime[i]<=x;i++){
            for(i64 e=1,sp=prime[i];sp<=x;sp*=prime[i],e++){
                res+=jxf(sp)*(S(x/sp,i)+(e>1));
            }
        }
        return res;
    }
}

void solve(){
    i64 n;
    std::cin>>n;
    Mint sum=Mint(n-1)*(n+2)/2;
    Mint res=sum*sum;
    res-=Mint(2*n+1)*(n+1)*n/6;
    res+=1;
    res/=2;

    Mint ans=0;
    Mint d=0;

    {
        std::function<Mint(i64)> f=[&](i64 x){
            return x;
        };
        std::function<Mint(i64)> pre=[&](i64 x){
            return Mint(x+1)*x/2;
        };
        min25::init(n);
        min25::insert(f,pre);
        Mint t=min25::g[0][1]-min25::g[0][min25::id(n/2)];

        d=t*t;
        res-=t*sum;
    }

    {
        std::function<Mint(i64)> f=[&](i64 x){
            return Mint(x)*x;
        };
        std::function<Mint(i64)> pre=[&](i64 x){
            return Mint(2*x+1)*Mint(x+1)*x/6;
        };
        min25::init(n);
        min25::insert(f,pre);
        Mint t=min25::g[0][1]-min25::g[0][min25::id(n/2)];
        d+=t;
        d/=2;
        res+=d;
    }

    std::cout<<res<<"\n";
}

signed main(){
    fastio;
    
    int T;
    T=1;
    while(T--) solve();
    
    return 0;
}