#include <vector>
#include <cassert>
#include <iostream>
#include <algorithm>
using namespace std;

const int MOD = 998244353;

class modint {
private:
	int x;
public:
	modint() : x(0) {}
	modint(long long x_) : x(x_ >= 0 ? x_ % MOD : (x_ + 1) % MOD + (MOD - 1)) {}
	int val() const { return x; }
	modint operator-() const { return modint(-x); }
	modint& operator+=(const modint& m) { x = (x + m.x < MOD ? x + m.x : x + m.x - MOD); return *this; }
	modint& operator-=(const modint& m) { x = (x >= m.x ? x - m.x : x - m.x + MOD); return *this; }
	modint& operator*=(const modint& m) { x = 1LL * x * m.x % MOD; return *this; }
	modint operator+(const modint& m) const { return modint(*this) += m; }
	modint operator-(const modint& m) const { return modint(*this) -= m; }
	modint operator*(const modint& m) const { return modint(*this) *= m; }
	modint pow(long long b) const {
		modint ans(1), a(*this);
		while (b > 0) {
			if (b & 1) {
				ans *= a;
			}
			a *= a;
			b >>= 1;
		}
		return ans;
	}
	modint inv() const { return pow(MOD - 2); }
};

namespace comber {
	int N;
	vector<modint> fact, factinv, Z;
	void initialize(int N_) {
		N = N_;
		fact.resize(N + 1);
		fact[0] = 1;
		for (int i = 1; i <= N; i++) {
			fact[i] = fact[i - 1] * i;
		}
		factinv.resize(N + 1);
		factinv[N] = fact[N].inv();
		for (int i = N; i >= 1; i--) {
			factinv[i - 1] = factinv[i] * i;
		}
		Z.resize(N + 1);
		for (int i = 0; i <= N; i++) {
			Z[i] = modint(2).pow(1LL * i * (i - 1) / 2);
		}
	}
	modint comb(int x, int y) {
		assert(0 <= y && y <= x && x <= N);
		return fact[x] * factinv[y] * factinv[x - y];
	}
}

const modint base = 3;

vector<modint> ntt(vector<modint> v, int typ) {
	modint root = (typ == 1 ? base : base.inv());
	int size = v.size();
	vector<modint> dat(size, 0);
	for (int i = 0; i < size; i++) {
		int r1 = 1, r2 = size / 2, cur = 0;
		while (r2 >= 1) {
			if ((i & r1) != 0) {
				cur += r2;
			}
			r1 <<= 1;
			r2 >>= 1;
		}
		dat[cur] = v[i];
	}
	for (int b = 2; b <= size; b *= 2) {
		vector<modint> pows(b, 1);
		pows[1] = root.pow((MOD - 1) / b);
		for (int i = 2; i < b; i++) {
			pows[i] = pows[i - 1] * pows[1];
		}
		for (int stt = 0; stt < size; stt += b) {
			for (int i = 0; i < b / 2; i++) {
				modint r1 = dat[stt + i] + pows[i + 0 * b / 2] * dat[stt + i + b / 2];
				modint r2 = dat[stt + i] + pows[i + 1 * b / 2] * dat[stt + i + b / 2];
				dat[stt + i + 0 * b / 2] = r1;
				dat[stt + i + 1 * b / 2] = r2;
			}
		}
	}
	if (typ == 2) {
		modint mult = modint(size).inv();
		for (int i = 0; i < size; i++) {
			dat[i] *= mult;
		}
	}
	return dat;
}

vector<modint> convolve(vector<modint> a, vector<modint> b) {
	int n = a.size(), m = b.size();
	assert(n >= 1 && m >= 1);
	if (min(n, m) <= 32) {
		vector<modint> c(n + m - 1);
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				c[i + j] += a[i] * b[j];
			}
		}
		return c;
	}
	int size = 1 << (32 - __builtin_clz(n + m - 2));
	a.resize(size);
	b.resize(size);
	a = ntt(a, 1);
	b = ntt(b, 1);
	for (int i = 0; i < size; i++) {
		a[i] *= b[i];
	}
	a = ntt(a, 2);
	a.resize(n + m - 1);
	return a;
}

class online_convolution {
private:
	int n;
	vector<modint> a;
	vector<modint> b;
	vector<modint> c;
public:
	online_convolution() : n(0), a(), b(), c() {}
	modint add(modint sa, modint sb) {
		n++;
		a.push_back(sa);
		b.push_back(sb);
		c.push_back(modint(0));
		if (n >= 2) {
			c.push_back(modint(0));
		}
		int level = __builtin_ctz(~n) + 1;
		if ((1 << level) > n) {
			level--;
		}
		for (int i = 0; i < level; i++) {
			vector<modint> suba1(a.begin() + (1 << i) - 1, a.begin() + (2 << i) - 1);
			vector<modint> subb1(b.begin() + n - (1 << i), b.begin() + n);
			vector<modint> subc1 = convolve(suba1, subb1);
			for (int j = 0; j < (2 << i) - 1; j++) {
				c[n - 1 + j] += subc1[j];
			}
			if (n != (2 << i) - 1) {
				vector<modint> suba2(a.begin() + n - (1 << i), a.begin() + n);
				vector<modint> subb2(b.begin() + (1 << i) - 1, b.begin() + (2 << i) - 1);
				vector<modint> subc2 = convolve(suba2, subb2);
				for (int j = 0; j < (2 << i) - 1; j++) {
					c[n - 1 + j] += subc2[j];
				}
			}
		}
		return c[n - 1];
	}
};

vector<modint> connected_graphs(int N) {
	online_convolution conv;
	vector<modint> C(N + 1);
	C[1] = modint(1);
	for (int i = 2; i <= N; i++) {
		modint a = C[i - 1] * comber::factinv[i - 2];
		modint b = comber::Z[i - 1] * comber::factinv[i - 1];
		modint res = conv.add(a, b);
		C[i] = comber::Z[i] - comber::fact[i - 1] * res;
	}
	return C;
}

modint solve(int N) {
	if (N == 1) {
		return modint(0);
	}
	vector<modint> C = connected_graphs(N);
	vector<modint> A(N + 1);
	for (int i = 1; i <= N; i++) {
		A[i] = C[i] * comber::factinv[i - 1];
	}
	vector<modint> B = convolve(A, A);
	modint ans = 0;
	for (int i = 1; i <= N; i++) {
		ans += B[i] * comber::fact[N - 2] * comber::factinv[N - i] * comber::Z[N - i];
	}
	return ans;
}

int main() {
	int N;
	cin >> N;
	comber::initialize(N);
	modint ans = solve(N);
	cout << (ans * modint(1LL * N * (N - 1) / 2)).val() << endl;
	return 0;
}