#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,m,n) for(int i=(m);i<(n);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
using ll = long long;
constexpr int INF = 0x3f3f3f3f;
constexpr long long LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr double EPS = 1e-8;
constexpr int MOD = 998244353;
constexpr int DY[]{1, 0, -1, 0}, DX[]{0, -1, 0, 1};
constexpr int DY8[]{1, 1, 0, -1, -1, -1, 0, 1}, DX8[]{0, -1, -1, -1, 0, 1, 1, 1};
template <typename T, typename U> inline bool chmax(T &a, U b) { return a < b ? (a = b, true) : false; }
template <typename T, typename U> inline bool chmin(T &a, U b) { return a > b ? (a = b, true) : false; }
struct IOSetup {
  IOSetup() {
    std::cin.tie(nullptr);
    std::ios_base::sync_with_stdio(false);
    std::cout << fixed << setprecision(20);
  }
} iosetup;

template <int M>
struct MInt {
  unsigned int val;
  MInt(): val(0) {}
  MInt(long long x) : val(x >= 0 ? x % M : x % M + M) {}
  static constexpr int get_mod() { return M; }
  static void set_mod(int divisor) { assert(divisor == M); }
  static void init(int x = 10000000) { inv(x, true); fact(x); fact_inv(x); }
  static MInt inv(int x, bool init = false) {
    // assert(0 <= x && x < M && std::__gcd(x, M) == 1);
    static std::vector<MInt> inverse{0, 1};
    int prev = inverse.size();
    if (init && x >= prev) {
      // "x!" and "M" must be disjoint.
      inverse.resize(x + 1);
      for (int i = prev; i <= x; ++i) inverse[i] = -inverse[M % i] * (M / i);
    }
    if (x < inverse.size()) return inverse[x];
    unsigned int a = x, b = M; int u = 1, v = 0;
    while (b) {
      unsigned int q = a / b;
      std::swap(a -= q * b, b);
      std::swap(u -= q * v, v);
    }
    return u;
  }
  static MInt fact(int x) {
    static std::vector<MInt> f{1};
    int prev = f.size();
    if (x >= prev) {
      f.resize(x + 1);
      for (int i = prev; i <= x; ++i) f[i] = f[i - 1] * i;
    }
    return f[x];
  }
  static MInt fact_inv(int x) {
    static std::vector<MInt> finv{1};
    int prev = finv.size();
    if (x >= prev) {
      finv.resize(x + 1);
      finv[x] = inv(fact(x).val);
      for (int i = x; i > prev; --i) finv[i - 1] = finv[i] * i;
    }
    return finv[x];
  }
  static MInt nCk(int n, int k) {
    if (n < 0 || n < k || k < 0) return 0;
    if (n - k > k) k = n - k;
    return fact(n) * fact_inv(k) * fact_inv(n - k);
  }
  static MInt nPk(int n, int k) { return n < 0 || n < k || k < 0 ? 0 : fact(n) * fact_inv(n - k); }
  static MInt nHk(int n, int k) { return n < 0 || k < 0 ? 0 : (k == 0 ? 1 : nCk(n + k - 1, k)); }
  static MInt large_nCk(long long n, int k) {
    if (n < 0 || n < k || k < 0) return 0;
    inv(k, true);
    MInt res = 1;
    for (int i = 1; i <= k; ++i) res *= inv(i) * n--;
    return res;
  }
  MInt pow(long long exponent) const {
    MInt tmp = *this, res = 1;
    while (exponent > 0) {
      if (exponent & 1) res *= tmp;
      tmp *= tmp;
      exponent >>= 1;
    }
    return res;
  }
  MInt &operator+=(const MInt &x) { if((val += x.val) >= M) val -= M; return *this; }
  MInt &operator-=(const MInt &x) { if((val += M - x.val) >= M) val -= M; return *this; }
  MInt &operator*=(const MInt &x) { val = static_cast<unsigned long long>(val) * x.val % M; return *this; }
  MInt &operator/=(const MInt &x) { return *this *= inv(x.val); }
  bool operator==(const MInt &x) const { return val == x.val; }
  bool operator!=(const MInt &x) const { return val != x.val; }
  bool operator<(const MInt &x) const { return val < x.val; }
  bool operator<=(const MInt &x) const { return val <= x.val; }
  bool operator>(const MInt &x) const { return val > x.val; }
  bool operator>=(const MInt &x) const { return val >= x.val; }
  MInt &operator++() { if (++val == M) val = 0; return *this; }
  MInt operator++(int) { MInt res = *this; ++*this; return res; }
  MInt &operator--() { val = (val == 0 ? M : val) - 1; return *this; }
  MInt operator--(int) { MInt res = *this; --*this; return res; }
  MInt operator+() const { return *this; }
  MInt operator-() const { return MInt(val ? M - val : 0); }
  MInt operator+(const MInt &x) const { return MInt(*this) += x; }
  MInt operator-(const MInt &x) const { return MInt(*this) -= x; }
  MInt operator*(const MInt &x) const { return MInt(*this) *= x; }
  MInt operator/(const MInt &x) const { return MInt(*this) /= x; }
  friend std::ostream &operator<<(std::ostream &os, const MInt &x) { return os << x.val; }
  friend std::istream &operator>>(std::istream &is, MInt &x) { long long val; is >> val; x = MInt(val); return is; }
};
namespace std { template <int M> MInt<M> abs(const MInt<M> &x) { return x; } }
using ModInt = MInt<MOD>;

std::vector<int> mobius_mu_init(const int n) {
  std::vector<int> is_prime(n + 1, true);
  is_prime[0] = false;
  if (n >= 1) {
    is_prime[1] = false;
  }
  std::vector<int> mu(n + 1, 1);
  mu[0] = 0;
  for (int i = 2; i <= n; ++i) {
    if (is_prime[i]) {
      mu[i] = -mu[i];
      for (int j = i * 2; j <= n; j += i) {
        is_prime[j] = false;
        mu[j] = ((j / i) % i == 0 ? 0 : -mu[j]);
      }
    }
  }
  return mu;
}

template <typename T>
std::vector<T> lcm_convolution(std::vector<T> a, std::vector<T> b) {
  const int n = (a.size() - 1) * (b.size() - 1);
  a.resize(n + 1, 0);
  b.resize(n + 1, 0);
  const auto transform = [n](std::vector<T> &v) -> void {
    for (int i = n; i >= 1; --i) {
      for (int j = i << 1; j <= n; j += i) {
        v[j] += v[i];
      }
    }
  };
  transform(a);
  transform(b);
  for (int i = 1; i <= n; ++i) {
    a[i] *= b[i];
  }
  for (int i = 1; i <= n; ++i) {
    for (int j = i << 1; j <= n; j += i) {
      a[j] -= a[i];
    }
  }
  return a;
}

int main() {
  // int ans[N]{};
  // auto f = [&](auto&& f, int i, int a, int b) -> void {
  //   if (a == 1 && b == 1) ++ans[i - 1];
  //   if (i == N) return;
  //   f(f, i + 1, a, b);
  //   f(f, i + 1, gcd(a, i), b);
  //   f(f, i + 1, a, gcd(b, i));
  // };
  // f(f, 1, 0, 0);
  // REP(i, N) cout << ans[i] << " \n"[i == N];

  // ModInt dp[N + 1][N + 1]{};
  // for (int a = N; a >= 1; --a) for (int b = N; b >= 1; --b) {
  //   for (int c = a; c <= N; c += a) for (int d = b; d <= N; d += b) {
  //     dp[a][b] -= dp[c][d];
  //   }
  //   const int z = N / lcm(a, b), x = N / a - z, y = N / b - z;
  //   dp[a][b] += ModInt(3).pow(z) * ModInt(2).pow(x + y)
  //               - ModInt(2).pow(x + z)
  //               - ModInt(2).pow(y + z)
  //               + 1;
  // }
  // cout << dp[1][1] << '\n';

  // const vector<int> mu = mobius_mu_init(N);
  // ModInt ans = 0;
  // for (int a = 1; a <= N; ++a) for (int b = 1; b <= N; ++b) {
  //   const int z = N / lcm(a, b), x = N / a - z, y = N / b - z;
  //   const ModInt g = ModInt(3).pow(z) * ModInt(2).pow(x + y)
  //                    - ModInt(2).pow(x + z)
  //                    - ModInt(2).pow(y + z)
  //                    + 1;
  //   ans += g * mu[a] * mu[b];
  // }


  int n; cin >> n;
  vector<ModInt> p2(n + 1, 1);
  REP(i, n) p2[i + 1] = p2[i] * 2;
  const vector<int> mu = mobius_mu_init(n);
  ModInt ans = 0;
  FOR(i, 1, n + 1) ans += (-p2[n / i] + 1) * mu[i];
  ans *= accumulate(ALL(mu), ModInt(0));
  ModInt tmp = 0;
  FOR(i, 1, n + 1) tmp += p2[n / i] * mu[i];
  ans -= tmp * accumulate(ALL(mu), ModInt(0));

  // 1. O(n^2 log{n})
  // FOR(i, 1, n + 1) FOR(j, 1, n + 1) {
  //   ans += p2[n / i] * p2[n / j] * (ModInt(3) / 4).pow(n / lcm(i, j)) * mu[i] * mu[j];
  // }

  vector<ModInt> u(n + 1, 0);
  FOR(i, 1, n + 1) u[i] = p2[n / i] * mu[i];
  // 2. 添え字 lcm での畳み込み
  // const vector<ModInt> v = lcm_convolution(u, u);
  // FOR(i, 1, v.size()) ans += v[i] * (ModInt(3) / 4).pow(n / i);
  // 3. 想定解
  ans += accumulate(ALL(u), ModInt(0)) * accumulate(ALL(u), ModInt(0));
  for (int i = n; i >= 1; --i) {
    for (int j = i << 1; j <= n; j += i) {
      u[j] += u[i];
    }
  }
  REP(i, n + 1) u[i] *= u[i];
  FOR(i, 1, n + 1) for (int j = i << 1; j <= n; j += i) u[j] -= u[i];
  FOR(i, 1, n + 1) ans += u[i] * (ModInt(3) / 4).pow(n / i);
  ans -= accumulate(ALL(u), ModInt(0));
  cout << ans << '\n';
  return 0;
}