#include <bits/stdc++.h>
 
using namespace std;
 
const int N = 1 << 18, mod = 998244353, o = 18, len = 1 << o;
int n, f[N], g[N], iv[N];
 
int add(int x, int y) { return x + y < mod ? x + y : x + y - mod; }
int sub(int x, int y) { return x < y ? x + mod - y : x - y; }
 
int power(int a, int n) {
  int tp = 1;
  while (n) {
    if (n & 1)
      tp = 1ll * tp * a % mod;
    a = 1ll * a * a % mod, n >>= 1;
  }
  return tp;
}
 
namespace poly {
typedef unsigned long long u64;
int I[N], w[len], r[len], up, l;
 
void init() {
  I[0] = 1;
  const int wo = power(3, (mod - 1) >> o);
  w[len >> 1] = 1;
  for (int i = (len >> 1) + 1; i != len; i++)
    w[i] = 1ll * w[i - 1] * wo % mod;
  for (int i = (len >> 1) - 1; i; i--)
    w[i] = w[i << 1];
  for (int i = 0; i != len; i++)
    r[i] = (r[i >> 1] >> 1) | ((i & 1) << (o - 1));
}
 
void ntt(int *a, int n, bool op) {
  static u64 t[len], x, y;
  for (int i = 0; i != n; i += 2) {
    x = a[r[i] >> (o - l)], y = a[r[i + 1] >> (o - l)];
    t[i] = x + y, t[i + 1] = x + mod - y;
  }
  for (int l = 2; l != n; l <<= 1) {
    if (l == (1 << 18))
      for (u64 *f = t; f != t + n; f++)
        *f %= mod;
    int *k = w + l;
    for (u64 *f = t; f != t + n; f += l)
      for (int *j = k; j != k + l; j++, f++) {
        u64 x = *f, y = f[l] * *j % mod;
        f[l] = x + mod - y, *f += y;
      }
  }
  if (op) {
    if (n == (1 << 18))
      for (u64 *f = t; f != t + n; f++)
        *f %= mod;
    for (int i = 0, x = mod - (mod >> l); i != n; i++)
      a[i] = t[i] * x % mod;
    reverse(a + 1, a + n);
  } else
    for (int i = 0; i != n; i++)
      a[i] = t[i] % mod;
}
 
int pre(int n) {
  l = 32 - __builtin_clz(n);
  return up = 1 << l;
}
 
void inv(int *a, int n, int *f) {
  static int x[len], y[len];
  if (n <= 16) {
    int x = f[0] = power(a[0], mod - 2);
    for (int i = 1; i <= n; i++) {
      u64 s = 0;
      for (int j = 0; j != i; j++)
        s += 1ll * f[j] * a[i - j];
      f[i] = (mod - s % mod) * x % mod;
    }
    return;
  }
 
  int lt = n >> 1;
  inv(a, lt, f);
  memcpy(x, f, (lt + 1) << 2), memcpy(y, a, (n + 1) << 2);
  pre(n);
  ntt(x, up, 0), ntt(y, up, 0);
  for (int i = 0; i != up; i++)
    y[i] = 1ll * y[i] * x[i] % mod;
  ntt(y, up, 1);
  memset(y, 0, (lt + 1) << 2);
  ntt(y, up, 0);
  for (int i = 0; i != up; i++)
    y[i] = 1ll * y[i] * x[i] % mod;
  ntt(y, up, 1);
  for (int i = lt + 1; i <= n; i++)
    f[i] = sub(0, y[i]);
  memset(x, 0, up << 2), memset(y, 0, up << 2);
}
 
vector<int> v[N];
 
void solve(int l, int r) {
  static int x[len];
  if (r - l <= 16) {
    for (int i = l; i != r; i++) {
      if (i == 0) {
        continue;
      }
      if (i == 1) {
        f[i] = 1;
        continue;
      }
      f[i] = (f[i] + 2ll * (i - 1) * f[i - 1] % mod * iv[i]) % mod;
      u64 s = 0;
      for (int j = l; j != i; j++) {
        s += (u64)f[j] * f[i - j];
      }
      s %= mod;
      if (l) {
        s *= 2;
      }
      f[i] = (f[i] + s) * iv[2] % mod;
    }
    return;
  }
 
  int mid = (l + r) >> 1;
  solve(l, mid);
  if (mid > n) {
    return;
  }
 
  pre(r - l - 1);
  int up = r - l;
  if (l == 0) {
    memcpy(x, f, mid << 2);
    poly::ntt(x, up, 0);
    v[up / 2].resize(up / 2);
    for (int i = 0; i != up / 2; i++) {
      v[up / 2][i] = x[i * 2];
    }
    for (int i = 0; i != up; i++) {
      x[i] = 1ll * x[i] * x[i] % mod;
    }
    poly::ntt(x, up, 1);
    for (int i = mid; i != r; i++) {
      f[i] = add(f[i], x[i]);
    }
    memset(x, 0, up << 2);
  } else {
    memcpy(x, f + l, up << 1);
    poly::ntt(x, up, 0);
    for (int i = 0; i != up; i++) {
      x[i] = 2ll * x[i] * v[up][i] % mod;
    }
    poly::ntt(x, up, 1);
    for (int i = mid; i != r; i++) {
      f[i] = add(f[i], x[i - l]);
    }
    memset(x, 0, up << 2);
  }
  solve(mid, r);
}
 
void calc(int n) {
  int m = 1;
  while (m <= n) {
    m <<= 1;
  }
  solve(0, m);
}
}  // namespace poly
 
int main() {
  cin >> n, poly::init();
  f[1] = iv[1] = 1;
  for (int i = 2; i <= n; i++) {
    int j = mod / i + 1;
    iv[i] = 1ll * j * iv[i * j - mod] % mod;
  }
 
  poly::calc(n);
 
  f[0] = 1;
  for (int i = 1; i <= n; i++) {
    f[i] = mod - f[i];
  }
  poly::inv(f, n, g);
  int ans = g[n];
  for (int i = 1; i <= n; i++) {
    ans = 1ll * ans * i % mod;
  }
  cout << ans << endl;
}