#pragma GCC optimize ("Ofast")
#include <bits/stdc++.h>
using namespace std;

template <class T> int sz(T&& a) { return int(size(forward<T>(a))); }

template <class T> using vc = vector<T>;
template <class T> using vvc = vc<vc<T>>;

using ll = int64_t;
using vi = vc<int>;

mt19937 mt(chrono::steady_clock::now().time_since_epoch().count());

template <class F>
struct ycr {
	F f;
	template <class T> explicit ycr(T&& f_) : f(forward<T>(f_)) {}

	template <class... Args> decltype(auto) operator()(Args&&... args) {
		return f(ref(*this), forward<Args>(args)...);
	}
};
template <class F> decltype(auto) yc(F&& f) {
	return ycr<decay_t<F>>(forward<F>(f));
}

int main() {
	ios_base::sync_with_stdio(false), cin.tie(nullptr);

	int N; cin >> N;
	const int n2 = int(sqrt(N));
	vector<int> vs;

	{
		int a = N;
		while (a) {
			vs.push_back(a);
			a = N / (N/a+1);
		}
	}

	const int s = int(vs.size());

	auto get_idx = [&](int a) -> int {
		return int(a <= n2 ? s-a : N/a-1);
	};
	assert(vs[s-1] == 1);

	const int M = 20210926;
	const int MOD = 998244353;
	const ll LMOD = ll(MOD) << 32;
	vector<int> f(s);
	for (int i = s-1; i >= 0; i--) {
		int a = vs[i];
		int n = N/a;
		ll v = 1;
		for (int k = 2; k <= M; ) {
			const int cur = n*k;
			if (cur > N) break;
			const int which = N / cur;
			// N / (N / cur)
			const int nxt = N / which;
			const int j = get_idx(which);
			const int nxt_k = min(M, nxt / n);
			v += ll(f[j]) * (nxt_k - k + 1);
			if (v >= LMOD) v -= LMOD;
			k = nxt_k+1;
		}
		f[i] = int(v % MOD);
	}
	cout << f[0] << '\n';
}