#include <bits/stdc++.h>
using namespace std;

struct Residue {
    using ll = long long;
    ll val = 0;
    static constexpr ll MOD = 998244353;

    Residue() {}

    Residue(ll _val): val(_val % MOD) {}

    Residue operator+=(const Residue& other) {
        val += other.val;
        val %= MOD;
        return *this;
    }

    Residue operator-=(const Residue& other) {
        val -= other.val;
        val %= MOD;
        return *this;
    }

    Residue operator*=(const Residue& other) {
        val *= other.val;
        val %= MOD;
        return *this;
    }

    Residue operator/=(const Residue& other) {
        *this *= other.mod_inverse();
        return *this;
    }

    friend Residue operator*(const Residue& a, const Residue& b) {
        return Residue(a.val * b.val % MOD);
    }

    friend Residue operator+(const Residue& a, const Residue& b) {
        return Residue((a.val + b.val) % MOD);
    }

    friend Residue operator-(const Residue& a, const Residue& b) {
        return Residue((a.val - b.val) % MOD);
    }

    friend Residue operator/(const Residue& a, const Residue& b) {
        return a * b.mod_inverse();
    }

    ll operator()() const {
        return (val + MOD) % MOD;
    }

    static Residue fast_exponentiate(Residue base, ll exp) {
        if (exp == 0) {
            return 1;
        } else if (exp == 1) {
            return base;
        }

        Residue half = fast_exponentiate(base, exp / 2);
        if (exp % 2 == 0) {
            return half * half;
        } else {
            return half * half * base;
        }
    }

    inline static unordered_map<ll, ll> inverses;

    Residue mod_inverse() const {
        ll v = (*this)();
        auto it = inverses.find(v);
        if (it != inverses.end()) {
            return it->second;
        }
        
        Residue this_inv = fast_exponentiate(*this, MOD - 2);
        inverses.insert({v, this_inv()});
        return this_inv;
    }
};

int main() {
    int n;
    cin >> n;

    Residue num_factors[n + 1];
    for (int i = 1; i <= n; ++i) {
        for (int j = i; j <= n; j += i) {
            num_factors[j] += 1;
        }
    }

    Residue sum = 0;
    for (int i = 1; i < n; ++i) {
        Residue curr_val = sum + num_factors[i];
        sum += curr_val;
    }

    Residue ans = sum + num_factors[n];
    cout << ans() << endl;
}