#include <math.h>
#include <stdio.h>
#include <string.h>

#include <vector>
#include <algorithm>
#include <unordered_map>

#define LOG(FMT...) fprintf(stderr, FMT)

#define eb emplace_back

using namespace std;

typedef long long LL;
constexpr int N = 2000005, PC = 271234;
constexpr int mod = 998244353;

char gc() {
	static char buf[1 << 21], *p1 = buf, *p2 = buf;
	return (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? -1 : *p1++);
}
int read() {
	int x = 0; char c = gc();
	while (c < 48 || c > 57) {
		c = gc();
	}
	for (; c > 47 && c < 58; c = gc()) {
		x = x * 10 + (c ^ 48);
	}
	return x;
}

int pr[PC], cnt;
bool was[N];
int c[N];

void sieve() {
	for (int x = 2; x < N; ++x) {
		if (!was[x]) {
			pr[cnt++] = x;
		}
		for (int k = 0; x * pr[k] < N; ++k) {
			was[x * pr[k]] = true;
			if (!(x % pr[k])) {
				break;
			}
		}
	}
	for (int i = 2; i < N; ++i) {
		c[i] = c[i - 1] + !was[i];
	}
}

constexpr int inv(int x, int k = mod - 2) {
	int r = 1;
	while (k) {
		if (k & 1) {
			r = x * (LL)r % mod;
		}
		x = x * (LL)x % mod;
		k >>= 1;
	}
	return r;
}

LL sqr(int x) {
	return x * (LL)x;
}

LL vs[N]; int szv;
LL g[N];

int id(LL v) {
	int k = lower_bound(vs, vs + szv, v) - vs;
	if (k < 0 || k >= szv || vs[k] != v) {
		LOG("ERR\n");
		while (true);
	}
	return k;
}

void min25(LL n) {
	for (LL l = 1, r; l <= n; l = r + 1) {
		r = n / (n / l);
		vs[szv++] = n / r;
	}
	reverse(vs, vs + szv);
	for (int i = 0; i < szv; ++i) {
		g[i] = vs[i] - 1;
	}
	LL B;
	for (int i = 0; (B = sqr(pr[i])) <= n; ++i) {
		for (int j = szv - 1; vs[j] >= B; --j) {
			g[j] += i - g[id(vs[j] / pr[i])];
		}
	}
}

LL calc(LL x) {
	return g[id(x)];
}

constexpr int f(LL x) {
	if (x == 1) {
		return 1;
	}
	if (x == 2) {
		return 1;
	}
	if (x == 3) {
		return 3;
	}
	LL y = calc(x) - calc(x / 2);
	return (x - y - 1) % mod * inv(x % mod, y % (mod - 1)) % mod;
}

int main() {
	// LOG("%.3lf\n", (sizeof c + sizeof was + sizeof pr) / 1048576.0);
	sieve();
	LL n;
	scanf("%lld", &n);
	min25(n);
	int res = 1;
	for (LL l = 1, r; l <= n; l = r + 1) {
		r = n / (n / l);
		res = res * (LL)inv(f(n / r), (r - l + 1) % (mod - 1)) % mod;
	}
	printf("%d\n", res);
	return 0;
}