#ifdef LOCAL
#include "stdafx.h"
#else
#include <bits/stdc++.h>
#define IL inline
#define LL long long
#define eb emplace_back
#define sz(v) ((int) (v).size())
#define me(f, x) memset(f, x, sizeof(f))
#define mc(f, g) memcpy(f, g, sizeof(f))
#define L(i, j, k) for (int i = (j); i <= (k); ++i)
#define R(i, j, k) for (int i = (j); i >= (k); --i)
#define FIO(FILE) freopen(FILE".in", "r", stdin), freopen(FILE".out", "w", stdout)
using namespace std;

using vi = vector<int>;
#endif

constexpr int P = 998244353;

IL void qm (int &x) {
  x += x >> 31 & P;
}

IL void pls (int &x, const LL &y) {
  x = (x + y) % P;
}

constexpr int SQ = 1 << 18;

template<int base>
struct gsm {
  int a[SQ + 3], b[SQ + 3];
  
  gsm () {
    a[0] = b[0] = 1;
    L (i, 1, SQ) {
      a[i] = (LL)base * a[i - 1] % P;
    }
    L (i, 1, SQ) {
      b[i] = (LL)a[SQ] * b[i - 1] % P;
    }
  }

  int operator () (LL k) const {
    return (LL)a[k & (SQ - 1)] * b[k >> 18] % P;
  }
};

gsm<2> p2;

constexpr int N = 2e6;
constexpr int M = 1e4;

LL n;

int mu[N + 3], p[N / 10 + 3], cnt;
bool np[N + 3];

int pmu[N + 3], smu[N + 3];
int f[N + 3], fp[N + 3];
int g[N + 3], gp[N + 3];
int h[N + 3], hp[N + 3];

int tot;
LL idx[M + 3];

IL int Mu (LL x) {
  return x <= N ? pmu[x] : smu[n / x];
}

IL int W (LL x) {
  return x & 1 ? (p2(x / 2) - 1) * 2 % P : (3LL * p2(x / 2 - 1) - 2) % P;
}

IL int F (LL x) {
  return x <= N ? f[x] : fp[n / x];
}

IL int G (LL x) {
  return x <= N ? g[x] : gp[n / x];
}

IL int H (LL x) {
  return x <= N ? h[x] : hp[n / x];
}

void init () {
  mu[1] = 1;
  L (i, 2, N) {
    if (!np[i]) {
      p[++cnt] = i;
      mu[i] = -1;
    }
    for (int j = 1; j <= cnt && i * p[j] <= N; ++j) {
      np[i * p[j]] = 1;
      if (i % p[j] == 0) {
        break;
      }
      mu[i * p[j]] = -mu[i];
    }
  }
  L (i, 1, N) {
    pmu[i] = (pmu[i - 1] + P + mu[i]) % P;
  }
  L (i, 1, N) {
    if (i > 1) {
      int x = f[i] + p2(i - 2);
      L (j, 1, N / i) if (mu[j]) {
        pls(g[i * j], (P + 6LL * mu[j]) * x);
        pls(h[i * j], (P + 3LL * mu[j]) * x);
      }
    }
    pls(g[i], (P - 2LL) * f[i] + P - p2(i - 1) + 2 * mu[i]);
    pls(h[i], (P - 2LL) * f[i] + P - p2(i - 1) + mu[i]);
    L (j, 2, N / i) {
      pls(f[i * j], h[i] + (p2(j / 2 - 1) - 1LL + P) * g[i]);
    }
  }
  L (i, 2, N) {
    qm(f[i] += f[i - 1] - P);
    qm(g[i] += g[i - 1] - P);
    qm(h[i] += h[i - 1] - P);
  }
  for (LL l = 1, r; l <= n; l = r + 1) {
    r = n / (n / l);
    if (n / l <= N) {
      break;
    }
    idx[++tot] = n / l;
  }
  reverse(idx + 1, idx + tot + 1);
  L (i, 1, tot) {
    LL x = idx[i];
    int k = n / x;
    smu[k] = 1;
    for (LL l = 2, r; l <= x; l = r + 1) {
      r = x / (x / l);
      pls(smu[k], (P - Mu(x / l)) * ((r - l + 1) % P));
    }
  }
  L (i, 1, tot) {
    LL x = idx[i];
    int k = n / x;
    for (LL l = 2, r; l <= x; l = r + 1) {
      r = x / (x / l);
      LL len = (r - l + 1) % P;
      pls(fp[k], H(x / l) * len + G(x / l) * (P - len + W(r) + P - W(l - 1)));
    }
    hp[k] = (fp[k] + p2(x - 1) - 1) % P;
    for (LL l = 2, r; l <= x; l = r + 1) {
      r = x / (x / l);
      int len = Mu(r) - Mu(l - 1);
      if (len < 0) {
        len += P;
      }
      pls(hp[k], len * (3LL * F(x / l) + 3LL * p2(x / l - 1) - 2));
    }
    gp[k] = ((hp[k] + fp[k]) * 2LL + p2(x) - 1) % P;
  }
}

int main () {
  // FIO("1");
  ios::sync_with_stdio(0), cin.tie(0);
  cin >> n;
  init();
  cout << (F(n) + p2(n - 1)) % P << '\n';
  // cerr << clock() << '\n';
}
// I love WHQ!