n,a,b=int(input())+1,0,0;d=[0]*n
for i in range(1,n):
  for j in range(i,n,i):d[j]+=1
  a=b%998244353+d[i];b+=a
print(a)

import sys

input = sys.stdin.readline
MAX = sys.maxsize

# sys.setrecursionlimit(10 ** 9)

# Input functions
def inp():
    return int(input())

def read_int_list():
    return list(map(int, input().split()))

def read_list():
    s = input()
    return list(s[:len(s) - 1])

def read_int_map():
    return map(int, input().split())

# Solution
X = 998244353

def solve(n):
    dp = [0] * (n + 1)
    dp[0] = 1
    for i in range(2, n + 1):
        for j in range(i, n + 1, i):
            dp[j] += 1

    pref = 1
    for i in range(1, n + 1):
        dp[i] = (dp[i] + pref) % X
        pref = (dp[i] + pref) % X

    return dp[n]

if __name__ == "__main__":
    print(solve(inp()))

import itertools
import os,sys
from random import randint
from io import BytesIO, IOBase

from collections import defaultdict,deque,Counter
from bisect import bisect_left,bisect_right
from heapq import heappush,heappop
from functools import lru_cache
from itertools import accumulate
import math

# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# for _ in range(int(input())):
#     n = int(input())
#     a = list(map(int, input().split()))

# for _ in range(int(input())):
#     n = int(input())
#     a = list(map(int, input().split()))
#     mn = min(a)
#     ans = 0
#     for i in range(n):
#         if a[i] != mn:
#             ans += 1
#     print(ans)

# for _ in range(int(input())):
#     n = int(input())
#     a = list(map(int, input().split()))
#     b = []
#     for i in range(n):
#         if a[i] <= 0:
#             b.append(a[i])
#     if not b:
#         print(1)
#         continue
#     mn = float('inf')
#     b.sort()
#     for i in range(len(b) - 1):
#         mn = min(mn, b[i + 1] - b[i])
#     ans = len(b)
#     for i in range(n):
#         if 0 < a[i] <= mn:
#             ans += 1
#             break
#     print(ans)

N = 10 ** 6 + 10
cnt = [0] * N
for i in range(1, N):
    for j in range(1, 10000000000):
        if i * j >= N:
            break
        cnt[i * j] += 1

mod = 998244353
n = int(input())
a = [0, 1, 3, 6]
if n < 4:
    print(a[n])
else:
    tot = 10
    for i in range(4, n + 1):
        a.append((tot + cnt[i]) % mod)
        tot = (tot + a[-1]) % mod
    print(a[-1])

# n = 9
# ans = 0
# def dfs(a, b):
#     global ans
#     if not a:
#         for i in range(0, 2 * n, 2):
#             for j in range(i + 2, 2 * n, 2):
#                 l1, r1 = b[i], b[i + 1]
#                 l2, r2 = b[j], b[j + 1]
#                 if r1 - l1 != r2 - l2 and not (l2<l1<r1<r2 or l1<l2<r2<r1):
#                     return
#         ans += 1
#         return
#     l = a.pop(0)
#     b.append(l)
#     for i in range(len(a)):
#         dfs(a[:i] + a[i + 1:], b + [a[i]])
# dfs(list(range(1, n * 2 + 1)),[])
# print(ans)
# ans = 0
# n = 5
# for a in itertools.permutations(list(range(1, n * 2 + 1))):
#     for i in range(0, 2 * n, 2):
#         if a[i] > a[i + 1]:
#             break
#     else:
#         ok = True
#         for i in range(0, 2 * n, 2):
#             for j in range(i + 2, 2 * n, 2):
#                 l1, r1 = a[i], a[i + 1]
#                 l2, r2 = a[j], a[j + 1]
#                 if r1 - l1 != r2 - l2 and not (l2<l1<r1<r2 or l1<l2<r2<r1):
#                     ok=False
#                     break
#             if not ok:
#                 break
#         if ok:
#             # print(a)
#             ans += 1
# print(ans)

MAX = 1000000
fact = [1 for i in range(MAX+1)]

for i in range(2,MAX+1):
    if fact[i]>1:  continue
    base = i
    power = 1
    while base<MAX+1:
        for j in range(base,MAX+1,base):
            fact[j] *= power+1
            fact[j] = fact[j] // power
        base *= i
        power += 1

#print(fact)

M = 998244353

n = int(input())

if n<2:
    print(n)
    exit()

dp = [0]*(n+1)

dp[1] = 1

tot = 1
for i in range(2,n+1):
    dp[i] = tot

    dp[i] += fact[i]
    dp[i] = dp[i]%M

    tot += dp[i]
    tot = tot%M

#print(dp)
print(dp[-1])

import sys
input = lambda :sys.stdin.readline()[:-1]
ni = lambda :int(input())
na = lambda :list(map(int,input().split()))
yes = lambda :print("yes");Yes = lambda :print("Yes");YES = lambda : print("YES")
no = lambda :print("no");No = lambda :print("No");NO = lambda : print("NO")
#######################################################################
n = ni()
mod = 998244353

dp = [0]*(n+1)
dp[0] = 1
s = 1
for i in range(1,n+1):
    for j in range(i*2, n+1,i):
        dp[j] += 1
        dp[j] %= mod

for i in range(1,n+1):
    dp[i] += s
    dp[i] %= mod
    s += dp[i]
    s %= mod
print(dp[-1])

from collections import Counter, defaultdict, deque
import bisect
from sys import stdin, stdout
from itertools import repeat, permutations
import math
import heapq

def inp(force_list=False):
    re = map(int, raw_input().split())
    if len(re) == 1 and not force_list:
        return re[0]
    return re

def inst():
    return raw_input().strip()

def gcd(x, y):
   while(y):
       x, y = y, x % y
   return x

MOD = 998244353

def qmod(a, b, mod=MOD):
    res = 1
    while b:
        if b&1:
            res = (res*a)%mod
        b >>= 1
        a = (a*a)%mod
        # print b
    return res

def inv(a):
    return qmod(a, MOD-2)

def my_main():
    kase = 1#inp()
    pans = []
    N = 1100000
    fac = [-1] * N
    for i in xrange(2, N):
        for j in xrange(1, N):
            if j*i>=N:
                break
            fac[j*i] += 1
    ans = [0, 1, 3, 6]
    ps = 10
    n = inp()
    for i in range(4, n+1):
        ans.append((ps+fac[i]+2)%998244353)
        ps += ans[-1]
        ps %= 998244353
    # print ans
    print ans[n]

my_main()

p=998244353
n=int(input())
s=0
div=n*[0]
for k in range(n):
    x=k+1
    for l in range(1,n//x +1):
        if l*x<=n:
            div[l*x-1]+=1
dp=n*[0]
dp[0]=1
for k in range(1,n):
    dp[k]=((div[k]-div[k-1])+2*dp[k-1])%p
print(dp[n-1])

import math,sys;input=sys.stdin.readline;S=lambda:input().rstrip();I=lambda:int(S());M=lambda:map(int,S().split());L=lambda:list(M());mod1=1000000007;mod2=998244353

n=I();dp=[0]*(n+1);s=1
for i in range(1,n+1):
    for j in range(i*2,n+1,i):dp[j]+=1
for i in range(1,n+1):dp[i]=(s+dp[i])%mod2;s=(s+dp[i])%mod2
print(dp[n])

def GoodPairings(n):
    mod=998244353
    dp=[0]*(n+1)
    dp[0]=1
    for i in range(1,n+1):
        for j in range(i+i,n+1,i):
            dp[j]=dp[j]+1

    S=1
    for i in range(1,n+1):
        dp[i]=(dp[i]+S)%mod
        S=(S+dp[i])%mod

    return dp[n]

n=(int)(input())
print(GoodPairings(n))

import sys
from sys import stdout

input = lambda: sys.stdin.readline().strip()
P = lambda: list(map(int, input().split()))
from math import factorial as f, gcd
from collections import deque, defaultdict as dd, Counter as C
from heapq import heapify, heappop, heappush, heappushpop, heapreplace, merge
from random import randint, choice, sample
import time
mod = 10**9+7
a = ord('a')

start = time.time()
def fast_exp(x, exp):
    ans = 1
    base = x
    while exp:
        if exp & 1:
            ans *= base
        base *= base
        base %= mod
        ans %= mod
        exp >>= 1
    return ans

def countBits(n):
    count = 0
    while n:
        count += n & 1
        n >>= 1
    return count

def submasks(n):
    #this is cool
    #https://cp-algorithms.com/algebra/all-submasks.html
    org = n
    while n:
        yield n
        n = (n-1) & org

def solve():
    n = int(input())
    arr = [0] * (n+1)
    for i in range(2, n+1):
        for j in range(i, n+1, i):
            arr[j] += 1
    dp = [1] * (n+1)
    accdp = [1, 2] + [0] * (n-1)
    for i in range(2, n+1):
        dp[i] = (arr[i] + accdp[i-1]) % 998244353
        accdp[i] = (accdp[i-1] + dp[i]) % 998244353
    print(dp[n])

# solution: (had to look at editiorial ofc :/)
# dp[i] is num for 2*i points.
# when the first point stretches to the second half, it leaves some points untouched (this middle untouched part is counted with dp/prefix)
# if it doesnt, its amount of divisors of n

tc = 1
for t in range(1, tc+1):
    solve()

# solve()
# print(time.time()-start)

# Problem: B. Kavi on Pairing Duty
# Contest: Codeforces - Codeforces Round #722 (Div. 1)
# URL: https://codeforces.com/contest/1528/problem/B
# Memory Limit: 256 MB
# Time Limit: 1000 ms
#
# Powered by CP Editor (https://cpeditor.org)

from collections import defaultdict
from functools import reduce
from bisect import bisect_right
from bisect import bisect_left
#import sympy #Prime number library
import copy
import heapq

mod=998244353
def main():
        n=int(input())
        dp=[0]*(2*n+1)
        prev=[0]*(2*n+1)
        dp[0]=1;prev[0]=1;
        NumOfDivisors(n)
        for i in range(2,2*n+1,2):
        	dp[i]=(prev[i-2]+div[i//2]-1)%mod
        	prev[i]=(prev[i-2]+dp[i])%mod
        print(dp[2*n])

div=[0]*(1000001)
def NumOfDivisors(n): #O(nlog(n))
	for i in range(1,n+1):
		for j in range(i,n+1,i):
			div[j]+=1

def primes1(n): #return a list having prime numbers from 2 to n
    """ Returns  a list of primes < n """
    sieve = [True] * (n//2)
    for i in range(3,int(n**0.5)+1,2):
        if sieve[i//2]:
            sieve[i*i//2::i] = [False] * ((n-i*i-1)//(2*i)+1)
    return [2] + [2*i+1 for i in range(1,n//2) if sieve[i]]

def GCD(a,b):
    if(b==0):
        return a
    else:
        return GCD(b,a%b)

if __name__ == '__main__':
    main()

import collections
import functools
import math
import random
import sys
import bisect

input = sys.stdin.readline

def In():
    return map(int, sys.stdin.readline().split())

def Kavi():
    n = int(input()) + 1
    l = [0] * n
    mod = 998244353
    for i in range(1, n):
        for i1 in range(i + i, n, i):
            l[i1] += 1
    l[0] = tol = 1
    for i in range(1, n):
        l[i] = (l[i] + tol) % mod
        tol = (tol + l[i]) % mod
    return l[-1]

print(Kavi())

MOD = 998244353
n = int(input())
dp = [None] * (n+1)
pref = [None] * (n+1)
div = [2] * (n+1)

dp[1] = 1
pref[1] = 1

for i in range(2,n+1):
    dp[i] = (div[i] + pref[i-1]) % MOD
    pref[i] = (pref[i-1] + dp[i]) % MOD
    for j in range(i<<1, n+1, i):
        div[j] += 1

print(dp[n])

def divisors(M):
    d=[]
    i=1
    while M>=i**2:
        if M%i==0:
            d.append(i)
            if i**2!=M:
                d.append(M//i)
        i=i+1
    return d

def popcount(x):
    x = x - ((x >> 1) & 0x55555555)
    x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
    x = (x + (x >> 4)) & 0x0f0f0f0f
    x = x + (x >> 8)
    x = x + (x >> 16)
    return x & 0x0000007f

def eratosthenes(n):
    res=[0 for i in range(n+1)]
    prime=set([])
    for i in range(2,n+1):
        if not res[i]:
            prime.add(i)
            for j in range(1,n//i+1):
                res[i*j]=1
    return prime

def factorization(n):
    res=[]
    for p in prime:
        if n%p==0:
            while n%p==0:
                n//=p
            res.append(p)
    if n!=1:
        res.append(n)
    return res

def euler_phi(n):
    res = n
    for x in range(2,n+1):
        if x ** 2 > n:
            break
        if n%x==0:
            res = res//x * (x-1)
            while n%x==0:
                n //= x
    if n!=1:
        res = res//n * (n-1)
    return res

def ind(b,n):
    res=0
    while n%b==0:
        res+=1
        n//=b
    return res

def isPrimeMR(n):
    if n==1:
        return 0
    d = n - 1
    d = d // (d & -d)
    L = [2, 3, 5, 7, 11, 13, 17]
    for a in L:
        t = d
        y = pow(a, t, n)
        if y == 1: continue
        while y != n - 1:
            y = (y * y) % n
            if y == 1 or t == n - 1: return 0
            t <<= 1
    return 1
def findFactorRho(n):
    from math import gcd
    m = 1 << n.bit_length() // 8
    for c in range(1, 99):
        f = lambda x: (x * x + c) % n
        y, r, q, g = 2, 1, 1, 1
        while g == 1:
            x = y
            for i in range(r):
                y = f(y)
            k = 0
            while k < r and g == 1:
                ys = y
                for i in range(min(m, r - k)):
                    y = f(y)
                    q = q * abs(x - y) % n
                g = gcd(q, n)
                k += m
            r <<= 1
        if g == n:
            g = 1
            while g == 1:
                ys = f(ys)
                g = gcd(abs(x - ys), n)
        if g < n:
            if isPrimeMR(g): return g
            elif isPrimeMR(n // g): return n // g
            return findFactorRho(g)
def primeFactor(n):
    i = 2
    ret = {}
    rhoFlg = 0
    while i*i <= n:
        k = 0
        while n % i == 0:
            n //= i
            k += 1
        if k: ret[i] = k
        i += 1 + i % 2
        if i == 101 and n >= 2 ** 20:
            while n > 1:
                if isPrimeMR(n):
                    ret[n], n = 1, 1
                else:
                    rhoFlg = 1
                    j = findFactorRho(n)
                    k = 0
                    while n % j == 0:
                        n //= j
                        k += 1
                    ret[j] = k

    if n > 1: ret[n] = 1
    if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
    return ret

def divisors(n):
    res = [1]
    prime = primeFactor(n)
    for p in prime:
        newres = []
        for d in res:
            for j in range(prime[p]+1):
                newres.append(d*p**j)
        res = newres
    res.sort()
    return res

def xorfactorial(num):#排他的論理和の階乗
    if num==0:
        return 0
    elif num==1:
        return 1
    elif num==2:
        return 3
    elif num==3:
        return 0
    else:
        x=baseorder(num)
        return (2**x)*((num-2**x+1)%2)+function(num-2**x)

def xorconv(n,X,Y):
    if n==0:
        res=[(X[0]*Y[0])%mod]
        return res
    x=[digit[i]+X[i+2**(n-1)] for i in range(2**(n-1))]
    y=[Y[i]+Y[i+2**(n-1)] for i in range(2**(n-1))]
    z=[digit[i]-X[i+2**(n-1)] for i in range(2**(n-1))]
    w=[Y[i]-Y[i+2**(n-1)] for i in range(2**(n-1))]
    res1=xorconv(n-1,x,y)
    res2=xorconv(n-1,z,w)
    former=[(res1[i]+res2[i])*inv for i in range(2**(n-1))]
    latter=[(res1[i]-res2[i])*inv for i in range(2**(n-1))]
    former=list(map(lambda x:x%mod,former))
    latter=list(map(lambda x:x%mod,latter))
    return former+latter

def merge_sort(A,B):
    pos_A,pos_B = 0,0
    n,m = len(A),len(B)
    res = []
    while pos_A < n and pos_B < m:
        a,b = A[pos_A],B[pos_B]
        if a < b:
            res.append(a)
            pos_A += 1
        else:
            res.append(b)
            pos_B += 1
    res += A[pos_A:]
    res += B[pos_B:]
    return res

class UnionFindVerSize():
    def __init__(self, N):
        self._parent = [n for n in range(0, N)]
        self._size = [1] * N
        self.group = N

    def find_root(self, x):
        if self._parent[x] == x: return x
        self._parent[x] = self.find_root(self._parent[x])
        stack = [x]
        while self._parent[stack[-1]]!=stack[-1]:
            stack.append(self._parent[stack[-1]])
        for v in stack:
            self._parent[v] = stack[-1]
        return self._parent[x]

    def unite(self, x, y):
        gx = self.find_root(x)
        gy = self.find_root(y)
        if gx == gy: return

        self.group -= 1

        if self._size[gx] < self._size[gy]:
            self._parent[gx] = gy
            self._size[gy] += self._size[gx]
        else:
            self._parent[gy] = gx
            self._size[gx] += self._size[gy]

    def get_size(self, x):
        return self._size[self.find_root(x)]

    def is_same_group(self, x, y):
        return self.find_root(x) == self.find_root(y)

class WeightedUnionFind():
    def __init__(self,N):
        self.parent = [i for i in range(N)]
        self.size = [1 for i in range(N)]
        self.val = [0 for i in range(N)]
        self.flag = True
        self.edge = [[] for i in range(N)]

    def dfs(self,v,pv):
        stack = [(v,pv)]
        new_parent = self.parent[pv]
        while stack:
            v,pv = stack.pop()
            self.parent[v] = new_parent
            for nv,w in self.edge[v]:
                if nv!=pv:
                    self.val[nv] = self.val[v] + w
                    stack.append((nv,v))

    def unite(self,x,y,w):
        if not self.flag:
            return
        if self.parent[x]==self.parent[y]:
            self.flag = (self.val[x] - self.val[y] == w)
            return

        if self.size[self.parent[x]]>self.size[self.parent[y]]:
            self.edge[x].append((y,-w))
            self.edge[y].append((x,w))
            self.size[x] += self.size[y]
            self.val[y] = self.val[x] - w
            self.dfs(y,x)
        else:
            self.edge[x].append((y,-w))
            self.edge[y].append((x,w))
            self.size[y] += self.size[x]
            self.val[x] = self.val[y] + w
            self.dfs(x,y)

class Dijkstra():
    class Edge():
        def __init__(self, _to, _cost):
            self.to = _to
            self.cost = _cost

    def __init__(self, V):
        self.G = [[] for i in range(V)]
        self._E = 0
        self._V = V

    @property
    def E(self):
        return self._E

    @property
    def V(self):
        return self._V

    def add_edge(self, _from, _to, _cost):
        self.G[_from].append(self.Edge(_to, _cost))
        self._E += 1

    def shortest_path(self, s):
        import heapq
        que = []
        d = [10**15] * self.V
        d[s] = 0
        heapq.heappush(que, (0, s))

        while len(que) != 0:
            cost, v = heapq.heappop(que)
            if d[v] < cost: continue

            for i in range(len(self.G[v])):
                e = self.G[v][i]
                if d[e.to] > d[v] + e.cost:
                    d[e.to] = d[v] + e.cost
                    heapq.heappush(que, (d[e.to], e.to))
        return d

#Z[i]:length of the longest list starting from S[i] which is also a prefix of S
#O(|S|)
def Z_algorithm(s):
    N = len(s)
    Z_alg = [0]*N

    Z_alg[0] = N
    i = 1
    j = 0
    while i < N:
        while i+j < N and s[j] == s[i+j]:
            j += 1
        Z_alg[i] = j
        if j == 0:
            i += 1
            continue
        k = 1
        while i+k < N and k + Z_alg[k]<j:
            Z_alg[i+k] = Z_alg[k]
            k += 1
        i += k
        j -= k
    return Z_alg

class BIT():
    def __init__(self,n,mod=0):
        self.BIT = [0]*(n+1)
        self.num = n
        self.mod = mod

    def query(self,idx):
        res_sum = 0
        mod = self.mod
        while idx > 0:
            res_sum += self.BIT[idx]
            if mod:
                res_sum %= mod
            idx -= idx&(-idx)
        return res_sum

    #Ai += x O(logN)
    def update(self,idx,x):
        mod = self.mod
        while idx <= self.num:
            self.BIT[idx] += x
            if mod:
                self.BIT[idx] %= mod
            idx += idx&(-idx)
        return

class dancinglink():
    def __init__(self,n,debug=False):
        self.n = n
        self.debug = debug
        self._left = [i-1 for i in range(n)]
        self._right = [i+1 for i in range(n)]
        self.exist = [True for i in range(n)]

    def pop(self,k):
        if self.debug:
            assert self.exist[k]
        L = self._left[k]
        R = self._right[k]
        if L!=-1:
            if R!=self.n:
                self._right[L],self._left[R] = R,L
            else:
                self._right[L] = self.n
        elif R!=self.n:
            self._left[R] = -1
        self.exist[k] = False

    def left(self,idx,k=1):
        if self.debug:
            assert self.exist[idx]
        res = idx
        while k:
            res = self._left[res]
            if res==-1:
                break
            k -= 1
        return res

    def right(self,idx,k=1):
        if self.debug:
            assert self.exist[idx]
        res = idx
        while k:
            res = self._right[res]
            if res==self.n:
                break
            k -= 1
        return res

class SparseTable():
    def __init__(self,A,merge_func,ide_ele):
        N=len(A)
        n=N.bit_length()
        self.table=[[ide_ele for i in range(n)] for i in range(N)]
        self.merge_func=merge_func

        for i in range(N):
            self.table[i][0]=A[i]

        for j in range(1,n):
            for i in range(0,N-2**j+1):
                f=self.table[i][j-1]
                s=self.table[i+2**(j-1)][j-1]
                self.table[i][j]=self.merge_func(f,s)

    def query(self,s,t):
        b=t-s+1
        m=b.bit_length()-1
        return self.merge_func(self.table[s][m],self.table[t-2**m+1][m])

class BinaryTrie:
    class node:
        def __init__(self,val):
            self.left = None
            self.right = None
            self.max = val

    def __init__(self):
        self.root = self.node(-10**15)

    def append(self,key,val):
        pos = self.root
        for i in range(29,-1,-1):
            pos.max = max(pos.max,val)
            if key>>i & 1:
                if pos.right is None:
                    pos.right = self.node(val)
                    pos = pos.right
                else:
                    pos = pos.right
            else:
                if pos.left is None:
                    pos.left = self.node(val)
                    pos = pos.left
                else:
                    pos = pos.left
        pos.max = max(pos.max,val)

    def search(self,M,xor):
        res = -10**15
        pos = self.root
        for i in range(29,-1,-1):
            if pos is None:
                break

            if M>>i & 1:
                if xor>>i & 1:
                    if pos.right:
                        res = max(res,pos.right.max)
                    pos = pos.left
                else:
                    if pos.left:
                        res = max(res,pos.left.max)
                    pos = pos.right
            else:
                if xor>>i & 1:
                    pos = pos.right
                else:
                    pos = pos.left

        if pos:
            res = max(res,pos.max)
        return res

def solveequation(edge,ans,n,m):
    #edge=[[to,dire,id]...]
    x=[0]*m
    used=[False]*n
    for v in range(n):
        if used[v]:
            continue
        y = dfs(v)
        if y!=0:
            return False
    return x

    def dfs(v):
        used[v]=True
        r=ans[v]
        for to,dire,id in edge[v]:
            if used[to]:
                continue
            y=dfs(to)
            if dire==-1:
                x[id]=y
            else:
                x[id]=-y
            r+=y
        return r

class Matrix():
    mod=10**9+7

    def set_mod(m):
        Matrix.mod=m

    def __init__(self,L):
        self.row=len(L)
        self.column=len(L[0])
        self._matrix=L
        for i in range(self.row):
            for j in range(self.column):
                self._matridigit[i][j]%=Matrix.mod

    def __getitem__(self,item):
        if type(item)==int:
            raise IndexError("you must specific row and column")
        elif len(item)!=2:
            raise IndexError("you must specific row and column")

        i,j=item
        return self._matridigit[i][j]

    def __setitem__(self,item,val):
        if type(item)==int:
            raise IndexError("you must specific row and column")
        elif len(item)!=2:
            raise IndexError("you must specific row and column")

        i,j=item
        self._matridigit[i][j]=val

    def __add__(self,other):
        if (self.row,self.column)!=(other.row,other.column):
            raise SizeError("sizes of matrixes are different")

        res=[[0 for j in range(self.column)] for i in range(self.row)]
        for i in range(self.row):
            for j in range(self.column):
                res[i][j]=self._matridigit[i][j]+other._matridigit[i][j]
                res[i][j]%=Matrix.mod
        return Matrix(res)

    def __sub__(self,other):
        if (self.row,self.column)!=(other.row,other.column):
            raise SizeError("sizes of matrixes are different")

        res=[[0 for j in range(self.column)] for i in range(self.row)]
        for i in range(self.row):
            for j in range(self.column):
                res[i][j]=self._matridigit[i][j]-other._matridigit[i][j]
                res[i][j]%=Matrix.mod
        return Matrix(res)

    def __mul__(self,other):
        if type(other)!=int:
            if self.column!=other.row:
                raise SizeError("sizes of matrixes are different")

            res=[[0 for j in range(other.column)] for i in range(self.row)]
            for i in range(self.row):
                for j in range(other.column):
                    temp=0
                    for k in range(self.column):
                        temp+=self._matridigit[i][k]*other._matrix[k][j]
                    res[i][j]=temp%Matrix.mod
            return Matrix(res)
        else:
            n=other
            res=[[(n*self._matridigit[i][j])%Matrix.mod for j in range(self.column)] for i in range(self.row)]
            return Matrix(res)

    def __pow__(self,m):
        if self.column!=self.row:
            raise MatrixPowError("the size of row must be the same as that of column")

        n=self.row
        res=Matrix([[int(i==j) for i in range(n)] for j in range(n)])
        while m:
            if m%2==1:
                res=res*self
            self=self*self
            m//=2
        return res

    def __str__(self):
        res=[]
        for i in range(self.row):
            for j in range(self.column):
                res.append(str(self._matridigit[i][j]))
                res.append(" ")
            res.append("\n")
        res=res[:len(res)-1]
        return "".join(res)

from collections import deque
class Dinic:
    def __init__(self, N):
        self.N = N
        self.G = [[] for i in range(N)]

    def add_edge(self, fr, to, cap):
        forward = [to, cap, None]
        forward[2] = backward = [fr, 0, forward]
        self.G[fr].append(forward)
        self.G[to].append(backward)

    def add_multi_edge(self, v1, v2, cap1, cap2):
        edge1 = [v2, cap1, None]
        edge1[2] = edge2 = [v1, cap2, edge1]
        self.G[v1].append(edge1)
        self.G[v2].append(edge2)

    def bfs(self, s, t):
        self.level = level = [None]*self.N
        deq = deque([s])
        level[s] = 0
        G = self.G
        while deq:
            v = deq.popleft()
            lv = level[v] + 1
            for w, cap, _ in G[v]:
                if cap and level[w] is None:
                    level[w] = lv
                    deq.append(w)
        return level[t] is not None

    def dfs(self, v, t, f):
        if v == t:
            return f
        level = self.level
        for e in self.it[v]:
            w, cap, rev = e
            if cap and level[v] < level[w]:
                d = self.dfs(w, t, min(f, cap))
                if d:
                    e[1] -= d
                    rev[1] += d
                    return d
        return 0

    def flow(self, s, t):
        flow = 0
        INF = 10**9 + 7
        G = self.G
        while self.bfs(s, t):
            *self.it, = map(iter, self.G)
            f = INF
            while f:
                f = self.dfs(s, t, INF)
                flow += f
        return flow

class SegmentTree:
    def __init__(self, init_val, segfunc, ide_ele):
        n = len(init_val)
        self.segfunc = segfunc
        self.ide_ele = ide_ele
        self.num = 1 << (n - 1).bit_length()
        self.tree = [ide_ele] * 2 * self.num
        self.size = n
        for i in range(n):
            self.tree[self.num + i] = init_val[i]
        for i in range(self.num - 1, 0, -1):
            self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])

    def update(self, k, x):
        k += self.num
        self.tree[k] = x
        while k > 1:
            k >>= 1
            self.tree[k] = self.segfunc(self.tree[2*k],self.tree[2*k+1])

    def query(self, l, r):
        if r==self.size:
            r = self.num

        res = self.ide_ele

        l += self.num
        r += self.num
        right = []
        while l < r:
            if l & 1:
                res = self.segfunc(res, self.tree[l])
                l += 1
            if r & 1:
                right.append(self.tree[r-1])
            l >>= 1
            r >>= 1

        for y in right[::-1]:
            res = self.segfunc(res,y)
        return res

import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import gcd,log

input = lambda :sys.stdin.buffer.readline()
mi = lambda :map(float,input().split())
li = lambda :list(mi())

mod = 998244353

d = [0 for i in range(10**6+1)]
for i in range(1,10**6+1):
    for j in range(i,10**6+1,i):
        d[j] += 1

n = int(input())
dp = [0 for i in range(n+1)]
dp[1] = 1
dp[0] = 1
imos = [0 for i in range(n+1)]
imos[0],imos[1] = 1,2
for i in range(2,n+1):
    dp[i] = d[i] - 1
    dp[i] += imos[i-1]
    dp[i] %= mod
    imos[i] = dp[i] + imos[i-1]
    imos[i] %= mod

print(dp[n])

import time

start_time = time.time()
def TIME_(): print(time.time()-start_time)

import os, sys
from io import BytesIO, IOBase
from types import GeneratorType
from bisect import bisect_left, bisect_right
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string, heapq as h
BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        import os
        self.os = os
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            self.os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

def getInt(): return int(input())
def getStrs(): return input().split()
def getInts(): return list(map(int,input().split()))
def getStr(): return input()
def listStr(): return list(input())
def getMat(n): return [getInts() for _ in range(n)]
def getBin(): return list(map(int,list(input())))
def isInt(s): return '0' <= s[0] <= '9'
def ceil_(a,b): return a//b + (a%b > 0)

MOD = 998244353
LIM = 2*10**6+1
facs = [0]*(LIM+1)

def primes(n):
    for i in range(2,n):
        if not min_div[i]:
            for j in range(i,n,i):
                min_div[j] = i
    return

min_div = [0]*(LIM+1)
min_div[1] = 1
primes(LIM+1)
facs[1] = 1

for i in range(2,LIM+1):
    facs[i] = 1
    j = i
    while j > 1:
        x = min_div[j]
        c = 1
        j //= x
        while min_div[j] == x:
            c += 1
            j //= x
        new = []
        facs[i] += c*facs[i]

ans = [0]*(LIM+1)
curr_sum = 0
for i in range(2,LIM+1,2):
    ans[i] = (curr_sum + facs[i//2]) % MOD
    curr_sum = (curr_sum + ans[i]) % MOD
"""
dp[N] = dp[N-2] + sum(dp[f] for all factors f of N//2
"""

def solve():
    N = getInt()
    return ans[2*N]

#for _ in range(getInt()):
print(solve())
#solve()

#TIME_()

#from math import ceil
import sys
input=sys.stdin.readline

# Python3 program to count
# number of factors
# of an array of integers
MAX = 1000001

# array to store
# prime factors
factor = [0]*(MAX + 1)

# function to generate all
# prime factors of numbers
# from 1 to 10^6
def generatePrimeFactors():
    factor[1] = 1

    # Initializes all the
    # positions with their value.
    for i in range(2,MAX):
        factor[i] = i

    # Initializes all
    # multiples of 2 with 2
    for i in range(4,MAX,2):
        factor[i] = 2

    # A modified version of
    # Sieve of Eratosthenes
    # to store the smallest
    # prime factor that divides
    # every number.
    i = 3
    while(i * i < MAX):
        # check if it has
        # no prime factor.
        if (factor[i] == i):
            # Initializes of j
            # starting from i*i
            j = i * i;
            while(j < MAX):
                # if it has no prime factor
                # before, then stores the
                # smallest prime divisor
                if (factor[j] == j):
                    factor[j] = i
                j += i
        i+=1

# function to calculate
# number of factors
def calculateNoOFactors(n):
    if (n == 1 ):
        return 1
    ans = 1

    # stores the smallest
    # prime number that
    # divides n
    dup = factor[n]

    # stores the count of
    # number of times a
    # prime number divides n.
    c = 1

    # reduces to the next
    # number after prime
    # factorization of n
    j = int(n / factor[n])

    # false when prime
    # factorization is done
    while (j > 1):
        # if the same prime
        # number is dividing
        # n, then we increase
        # the count
        if (factor[j] == dup):
            c += 1

        # if its a new prime factor
        # that is factorizing n,
        # then we again set c=1 and
        # change dup to the new prime
        # factor, and apply the formula
        # explained above.
        else:
            dup = factor[j]
            ans = ans * (c + 1)
            c = 1

        # prime factorizes
        # a number
        j = int(j / factor[j])

    # for the last
    # prime factor
    ans = ans * (c + 1)

    return ans

#t=int(input())
t=1
for i in range(t):
    generatePrimeFactors()
    n=int(input())
    ans=0
    #a=input()
    #w,h,n=map(int,input().split())

    dp=[0 for x in range(n+1)]
    dp[0]=0
    dp[1]=1
    s=1

    for i in range(2,n+1):
       dp[i]=(s+calculateNoOFactors(i))%998244353
       s=(s+dp[i])%998244353

    print(dp[n])

# Python3 program to count
# Python3 program to count
# number of factors
# of an array of integers
MAX = 1000001;

# array to store
# prime factors
factor = [0]*(MAX + 1);

# function to generate all
# prime factors of numbers
# from 1 to 10^6
def generatePrimeFactors():
    factor[1] = 1;

    # Initializes all the
    # positions with their value.
    for i in range(2,MAX):
        factor[i] = i;

    # Initializes all
    # multiples of 2 with 2
    for i in range(4,MAX,2):
        factor[i] = 2;

    # A modified version of
    # Sieve of Eratosthenes
    # to store the smallest
    # prime factor that divides
    # every number.
    i = 3;
    while(i * i < MAX):
        # check if it has
        # no prime factor.
        if (factor[i] == i):
            # Initializes of j
            # starting from i*i
            j = i * i;
            while(j < MAX):
                # if it has no prime factor
                # before, then stores the
                # smallest prime divisor
                if (factor[j] == j):
                    factor[j] = i;
                j += i;
        i+=1;

# function to calculate
# number of factors
def calculateNoOFactors(n):
    if (n == 1):
        return 1;
    ans = 1;

    # stores the smallest
    # prime number that
    # divides n
    dup = factor[n];

    # stores the count of
    # number of times a
    # prime number divides n.
    c = 1;

    # reduces to the next
    # number after prime
    # factorization of n
    j = int(n / factor[n]);

    # false when prime
    # factorization is done
    while (j > 1):
        # if the same prime
        # number is dividing
        # n, then we increase
        # the count
        if (factor[j] == dup):
            c += 1;

        # if its a new prime factor
        # that is factorizing n,
        # then we again set c=1 and
        # change dup to the new prime
        # factor, and apply the formula
        # explained above.
        else:
            dup = factor[j];
            ans = ans * (c + 1);
            c = 1;

        # prime factorizes
        # a number
        j = int(j / factor[j]);

    # for the last
    # prime factor
    ans = ans * (c + 1);

    return ans;
# Driver Code

if __name__ == "__main__":

# generate prime factors
# of number upto 10^6
    generatePrimeFactors()
    a = [10, 30, 100, 450, 987]
    q = len(a)
    for i in range (0,q):
        pass

# This code is contributed
# by mits.
n=int(input())
l=[0,1,3,6]
alp=calculateNoOFactors(3)
if n>3:
    for i in range(4,n+1):
        k=calculateNoOFactors(i)
        l.append(((2*l[i-1])+k-alp)%998244353)
        alp=k
    print(l[-1])
else:print(l[n])

from collections import defaultdict
from itertools import accumulate
from bisect import bisect_left
from collections import deque
from collections import Counter
import sys
input = sys.stdin.readline
'''
for CASES in range(int(input())):
n, m = map(int, input().split())
n = int(input())
A = list(map(int, input().split()))
S = input().strip()
sys.stdout.write(" ".join(map(str,ANS))+"\n")
'''
inf = 100000000000000000  # 1e17
mod = 998244353

n = int(input())
if n==1:
    print(1)
    sys.exit(0)

dp=[0]*(n+1)
f=[0]*(n+1)

f[0]=1
f[1]=1
dp[0]=0
dp[1]=1
sumf=0
sumdp=1

#print("!")
last=[0]*(2*n+1)
for i in range(2,2*n+1):
    if i%2==0:
        j=i+i
        while j<=2*n:
            last[j]+=1
            last[j]%=mod
            j=j+i
#print(last)

for i in range(2,n+1):
    sumf+=f[i-2]
    sumf%=mod

    dp[i]=sumf+last[i*2]
    dp[i]%=mod

    sumdp+=dp[i] # 所有裸露的直接往上面包东西
    sumdp%=mod

    f[i]=sumdp
    f[i]%=mod
print(f[n])

#
# dp=[0]*(n+1)
# f=[0]*(n+1)
# sumdp=[0]*(n+1)
# sumf=[0]*(n+1)
#
# sumdp[1]=3
# sumf[0]=2
# sumf[1]=2
# for i in range(2,n+1):
#     sumdp[i]=sumdp[i-1]
#     sumf[i]=sumf[i-1]
#
#     f[i]=sumdp[i]
#     dp[i]=sumf[i-2]
#
#     sumdp[i]+=dp[i]
#     sumf[i]+=f[i]

# by the authority of GOD     author: manhar singh sachdev #

def some_random_function():
    """due to the fast IO template, my code gets caught in
       plag check for no reason. That is why, I am making
       random functions"""
    x = 10
    x *= 100
    i_dont_know = x
    why_am_i_writing_this = x*x
    print(i_dont_know)
    print(why_am_i_writing_this)

def some_random_function5():
    """due to the fast IO template, my code gets caught in
       plag check for no reason. That is why, I am making
       random functions"""
    x = 10
    x *= 100
    i_dont_know = x
    why_am_i_writing_this = x*x
    print(i_dont_know)
    print(why_am_i_writing_this)

import os,sys
from io import BytesIO,IOBase
from array import array
# 2D list [[0]*large_index for _ in range(small_index)]
# switch from integers to floats if all integers are ≤ 2^52 and > 32 bit int
# fast mod https://github.com/cheran-senthil/PyRival/blob/master/pyrival/misc/mod.py

def main():
    mod = 998244353
    n = int(input())
    dp = array('i',[1]+[0]*n)
    fac = [0 for _ in range(n+1)]
    for i in range(1,n//2+1):
        for j in range(i+i,n+1,i):
            fac[j] += 1
    su = 1
    for i in range(1,n+1):
        dp[i] = (su+fac[i])%mod
        su = (su+dp[i])%mod
    print(dp[n])

#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

def some_random_function1():
    """due to the fast IO template, my code gets caught in
       plag check for no reason. That is why, I am making
       random functions"""
    x = 10
    x *= 100
    i_dont_know = x
    why_am_i_writing_this = x*x
    print(i_dont_know)
    print(why_am_i_writing_this)

def some_random_function2():
    """due to the fast IO template, my code gets caught in
       plag check for no reason. That is why, I am making
       random functions"""
    x = 10
    x *= 100
    i_dont_know = x
    why_am_i_writing_this = x*x
    print(i_dont_know)
    print(why_am_i_writing_this)

def some_random_function3():
    """due to the fast IO template, my code gets caught in
       plag check for no reason. That is why, I am making
       random functions"""
    x = 10
    x *= 100
    i_dont_know = x
    why_am_i_writing_this = x*x
    print(i_dont_know)
    print(why_am_i_writing_this)

def some_random_function4():
    """due to the fast IO template, my code gets caught in
       plag check for no reason. That is why, I am making
       random functions"""
    x = 10
    x *= 100
    i_dont_know = x
    why_am_i_writing_this = x*x
    print(i_dont_know)
    print(why_am_i_writing_this)

def some_random_function6():
    """due to the fast IO template, my code gets caught in
       plag check for no reason. That is why, I am making
       random functions"""
    x = 10
    x *= 100
    i_dont_know = x
    why_am_i_writing_this = x*x
    print(i_dont_know)
    print(why_am_i_writing_this)

def some_random_function7():
    """due to the fast IO template, my code gets caught in
       plag check for no reason. That is why, I am making
       random functions"""
    x = 10
    x *= 100
    i_dont_know = x
    why_am_i_writing_this = x*x
    print(i_dont_know)
    print(why_am_i_writing_this)

def some_random_function8():
    """due to the fast IO template, my code gets caught in
       plag check for no reason. That is why, I am making
       random functions"""
    x = 10
    x *= 100
    i_dont_know = x
    why_am_i_writing_this = x*x
    print(i_dont_know)
    print(why_am_i_writing_this)

if __name__ == '__main__':
    main()

import sys
input = lambda: sys.stdin.readline().rstrip()

N = int(input())
prime_list = [] # �f�����X�g
lpf = [0] * (N + 1) # �ŏ��f����
for i in range(2, N + 1):
    if not lpf[i]:
        lpf[i] = i
        prime_list.append(i)
    a = lpf[i]
    for p in prime_list:
        if p > a or p * i > N: break
        lpf[p*i] = p

lpf_cnt = [1] * (N + 1)
div_cnt = [1] * (N + 1)
for i in range(2, N + 1):
    p = lpf[i]
    ip = i // p
    if ip % p:
        div_cnt[i] = div_cnt[ip] * 2
    else:
        lpf_cnt[i] = lpf_cnt[ip] + 1
        div_cnt[i] = div_cnt[ip] // lpf_cnt[i] * (lpf_cnt[i] + 1)

P = 998244353
x = 0
for i in range(1, N + 1):
    y = div_cnt[i] + x
    x = (x + y) % P
print(y)

N=int(input())
mod=998244353
D=[0]*(N+1)
for i in range(1,N+1):
  for j in range(i,N+1,i):
    D[j]+=1
X=[]
for i in range(N):
  X.append(D[i+1]-D[i])
x=1
DP=[0]*(N+1)
for i in range(N):
  DP[i+1]=(DP[i]*2+X[i])%mod
print(DP[N])

n = int(input())
mod = 998244353
dp = [0 for i in range(n + 1)]
for i in range(1, n + 1):
    for j in range(i, n + 1, i):
        dp[j] += 1
        if dp[j] > mod: dp[j] -= mod
sm = 0
for i in range(1, n + 1):
    dp[i] += sm
    if dp[i] > mod : dp[i] -= mod
    sm += dp[i]
    if sm > mod: sm -= mod
print(dp[n])

def main():
    n = int(raw_input())
    dp = [0] * (n + 1)
    s = x = 1
    mod = 998244353
    for i in xrange(2, n + 1):
        x = (dp[i] + s + 2) % mod
        s += x
        if s >= mod:
            s -= mod
        j = i * 2
        while j <= n:
            dp[j] += 1
            j += i
    print x
main()

n,a,b=int(input())+1,0,0
d=[0]*n
for i in range(1,n):
  for j in range(i,n,i):d[j]+=1
  a=b%998244353+d[i]
  b+=a
print(a)

import math
def D(N):
	if N == 1: return 1
	MOD = 998244353
	prev = 1
	for i in range (2, N + 1):
		cur = (prev + s[i]) % MOD
		if i != N:
			cur = (cur + prev) % MOD
		prev = cur

	return (cur % MOD)

N = int(input())
s = [2] * (N + 1)
s[1] = 1
for i in range(2, N + 1):
    for j in range(2 * i, N + 1, i):
        s[j] += 1

print(D(N))

mod=998244353
n=int(input())
d=[1]*(n+1)
for i in range(2,n+1):
    if d[i]==1:
        for j in range(i,n+1,i):
            c=0
            t=j+0
            while j%i==0:
                j//=i
                c+=1
            d[t]*=c+1
a=0
s=0
for i in range(1,n+1):
    a=(s+d[i])%mod
    s=(s+a)%mod
print(a)

import sys

input = sys.stdin.readline
inf = float('inf')

def getInt():
    return int(input())

def getStr():
    return input().strip()

def getList(split=True):
    s = getStr()
    if split:
      s = s.split()
    return map(int, s)

# t = getInt()
t = 1

M = 998244353
def solve():
    # if choose every <= 0 -> valid
    # contain at most one positive iterger
    # and if it is then it shoudl be the smallest one
    n = getInt()
    dp = [0] * (n+1)
    for i in range(1,n+1):
      for j in range(i, n+1, i):
        dp[j] += 1
    c = 0
    for i in range(1, n+1):
      dp[i] += c
      dp[i] %= M
      c += dp[i]
      c %= M
    print(dp[-1])

for _ in range(t):
    solve()

import sys

input = sys.stdin.readline
inf = float('inf')

def getInt():
    return int(input())

def getStr():
    return input().strip()

def getList(split=True):
    s = getStr()
    if split:
      s = s.split()
    return map(int, s)

# t = getInt()
t = 1

M = 998244353
def solve():
    # if choose every <= 0 -> valid
    # contain at most one positive iterger
    # and if it is then it shoudl be the smallest one
    n = getInt()
    dp = [0] * (n+1)
    for i in range(2, 2*n+1, 2):
      for j in range(i, 2*n+1, i):
        dp[j//2] += 1
    c = 0
    for i in range(1, n+1):
      dp[i] += c
      dp[i] %= M
      c += dp[i]
      c %= M
    print(dp[-1])

for _ in range(t):
    solve()

# Legends Always Come Up with Solution
# Author: Manvir Singh

import os
import sys
from io import BytesIO, IOBase

def main():
    n=int(input())
    p,mod,su,ans=[0]*(n+1),998244353,0,0
    for i in range(1,n+1,1):
        for j in range(i,n+1,i):
            p[j]+=1
    for i in range(1,n+1):
        ans=(su+p[i])%mod
        su=(su+ans)%mod
    print(ans)

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

if __name__ == "__main__":
    main()

n = int(input())

dp = [0 for i in range(n+1)]

#Python program to compute divisors of all numbers up to n efficiently
for i in range(1, n+1):
    for j in range(2*i, n+1, i):
        dp[j]+=1

s = 1
for i in range(1, n+1):
    dp[i] = (dp[i] + s )%998244353; s += dp[i]

print(dp[n])

n = int(input())

dp = [0 for i in range(n+1)]

#Python program to compute divisors of all numbers up to n efficiently
for i in range(1, n+1):
    for j in range(2*i, n+1, i):
        dp[j]+=1

s = 1
for i in range(1, n+1):

    dp[i] = (dp[i] + s )%998244353
    s += dp[i]

print(dp[n])

#Python ki maa ki

n = int(input())

dp = [0 for i in range(n+1)]

#Python program to compute divisors of all numbers up to n efficiently
for i in range(1, n+1):
    for j in range(2*i, n+1, i):
        dp[j]+=1

s = 1
for i in range(1, n+1):

    dp[i] = (dp[i] + s )%998244353
    s += dp[i]

print(dp[n])

import math

def solve(N):
    mod_val = 998244353
    if N == 1:
        return 1
    dyn = [0]*(N + 1)
    dyn[2] = 1
    dyn[0] = 1
    dyn2 = sieve2(N+1)
    for n2 in range(4, N+1, 2):
        dyn[n2] = (2*dyn[n2-2] + dyn2[n2] - dyn2[n2-2]) % mod_val
    return dyn[N]

def get_even_div_primes(n2, primes):
    l=[]
    if n2 in primes:
        return 2
    for p in primes:
        cur = 0
        while n2 % p == 0:
            cur += 1
            n2 = n2//p
        if cur > 0:
            l.append(cur)
        if (n2 == 1) or (n2 in primes):
            break
    tot = 1
    for x in l:
        tot = tot * (x+1)
    return tot

def get_even_div(mod_val, n2):
    new_dyn = (1 - (n2 % 2))
    for i in range(2, int(math.sqrt(n2)) + 1):
        if i ** 2 == n2:
            new_dyn = (new_dyn + (1 - (i % 2))) % mod_val
        elif n2 % i == 0:
            one_two = (1 - i % 2) + (1 - (n2 // i) % 2)
            # if i%2 == 0:
            #     print(f"{n2} all same {i}")
            # if (n2//i) %2 == 0:
            #     print(f"{n2} all same {n2//i}")

            new_dyn = (new_dyn + one_two) % mod_val
    return new_dyn

def sieve2(max_p):
    div_count = [0]*(max_p+1)
    for i in range(2, max_p,2):
        for j in range(1, max_p//i + 1):
            div_count[i*j] += 1
    return div_count
# sieve of the eratosthenes
def sieve(max_p):
    primes = [2, 3]
    for i in range(5,max_p):
        is_prime=True
        for p in primes:
            if i%p == 0:
                is_prime = False
                break
        if is_prime:
            primes.append(i)
    return primes

if __name__ == "__main__":
    N = int(input())
    # import time
    # a = time.time()
    res = solve(2*N)
    # b=time.time()
    # print(b-a)
    print(res, flush=True)

import sys
import os.path
from collections import *
import math
import bisect

if (os.path.exists('input.txt')):
    sys.stdin = open("input.txt", "r")
    sys.stdout = open("output.txt", "w")

##########################################################

n = 10 ** 6
mod = 998244353

divisors = [0 for i in range(n + 1)]

for i in range(1, n + 1):
    for j in range(i, n + 1, i):
        divisors[j] += 1

dp = [0 for i in range(n + 1)]

dp[1] = 1
dp[2] = 3

total = 4

n = int(input())

for i in range(3,n + 1):
    dp[i] = (total + divisors[i]) % mod
    total = (total + dp[i]) % mod

print(dp[n])

##########################################################

factorCnts=[1]*1000005
for i in range(1,1000005):
    for j in range(2*i,1000005,i):
        factorCnts[j]+=1

def main():

    MOD=998244353

    n=int(input())
    dp=[0]*(n+1)
    dp[1]=1
    prefixSum=1
    for i in range(2,n+1):
        dp[i]=prefixSum+2
        # add 1 for every factor excluding 1 and n
        dp[i]+=(factorCnts[i]-2)
        dp[i]%=MOD
        prefixSum+=dp[i]
        prefixSum%=MOD
    print(dp[n])

    return

import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
# input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.

def oneLineArrayPrint(arr):
    print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
    print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
    print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))

def readIntArr():
    return [int(x) for x in input().split()]
# def readFloatArr():
#     return [float(x) for x in input().split()]

def makeArr(defaultValFactory,dimensionArr): # eg. makeArr(lambda:0,[n,m])
    dv=defaultValFactory;da=dimensionArr
    if len(da)==1:return [dv() for _ in range(da[0])]
    else:return [makeArr(dv,da[1:]) for _ in range(da[0])]

def queryInteractive(i,j):
    print('? {} {}'.format(i,j))
    sys.stdout.flush()
    return int(input())

def answerInteractive(ans):
    print('! {}'.format(' '.join([str(x) for x in ans])))
    sys.stdout.flush()

inf=float('inf')
MOD=10**9+7
# MOD=998244353

for _abc in range(1):
    main()

# Parsa's Humongous Tree
def problem_c():
    num_tests = int(input())
    for i in range(num_tests):
        num_vertices = int(input())
        bounds = []
        for j in range(num_vertices):
            bounds.append([int(s) for s in input().split()])
        edge_lists = [[] for j in range(num_vertices)]
        for j in range(num_vertices - 1):
            u, v = [int(s) for s in input().split()]
            u -= 1
            v -= 1
            edge_lists[u].append(v)
            edge_lists[v].append(u)
        beauty_memo = [[None, None] for j in range(num_vertices)] # 0 for low, 1 for high
        def best_beauty(idx, parent_idx, parent_hl):
            if beauty_memo[idx][parent_hl] is not None:
                return beauty_memo[idx][parent_hl]
            best = 0
            if parent_idx != -1:
                parent_val = bounds[parent_idx][parent_hl]
                for hl in [0, 1]:
                    child_beauty = sum([best_beauty(c_idx, idx, hl) for c_idx in edge_lists[idx] if c_idx != parent_idx])
                    parent_beauty = abs(parent_val - bounds[idx][hl])
                    best = max(child_beauty + parent_beauty, best)
            else:
                for hl in [0, 1]:
                    child_beauty = sum([best_beauty(c_idx, idx, hl) for c_idx in edge_lists[idx] if c_idx != parent_idx])
                    best = max(child_beauty, best)
            beauty_memo[idx][parent_hl] = best
            return best
        print(best_beauty(0, -1, 0))

# Kavi on Pairing Duty
def problem_d():
    mod = 998244353
    num_pairs = int(input())
    small_primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47,
                    53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,
                    109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167,
                    173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
                    233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283,
                    293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359,
                    367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431,
                    433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491,
                    499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571,
                    577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641,
                    643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709,
                    719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787,
                    797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859,
                    863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
                    947, 953, 967, 971, 977, 983, 991, 997]
    f_nums = [i for i in range(num_pairs + 1)]
    num_factors = [1 for i in range(num_pairs + 1)]
    for prime in small_primes:
        max_multiple = num_pairs // prime
        for i in range(1, max_multiple + 1):
            power = 1
            ppower = prime
            while f_nums[prime * i] % (ppower * prime) == 0:
                ppower *= prime
                power += 1
            f_nums[prime * i] //= ppower
            num_factors[prime * i] *= power + 1
    for i in range(1, num_pairs + 1):
        if f_nums[i] != 1:
            num_factors[i] *= 2
            f_nums[i] = 1
    total = 0
    for i in range(1, num_pairs):
        total += num_factors[i] * pow(2, num_pairs - 1 - i, mod)
    total += num_factors[num_pairs]

    print(total % mod)

problem_d()

n = int(input())

factors = [0]*(n+1)

for i in range(1,n+1):
    for j in range(i,n+1,i):
        factors[j] += 1

prefix,ans = 0,0
mod = 998244353

for i in range(1,n+1):
    ans = (factors[i] + prefix)%mod
    prefix = (prefix+ans)%mod

print(ans)

import sys
input = sys.stdin.buffer.readline

n = int(input())
dp = [0] * (n + 1)

for i in range(1, n + 1):
	for j in range(i, n + 1, i):
		dp[j] = dp[j] + 1

mod = 998244353
sum = 1
for i in range(2, n + 1):
	dp[i] = (dp[i] + sum) % mod
	sum = (sum + dp[i]) % mod
print(dp[n])

from sys import stdin, stdout
import math

def read(): return stdin.readline().strip()
def read_int(): return [int(i) for i in read().split()]
def write(s): stdout.write(s)

M = 998244353
n, = read_int()
dp = [1 for _ in range(n + 1)]

num_div = [0 for _ in range(n + 1)]
for i in range(1, n + 1):
    j = i
    while j <= n:
        num_div[j] += 1
        j += i

sum = 0
for i in range(2, n + 1):
    # one large 1 2n
    sum += dp[i - 1]
    dp[i] = (sum + num_div[i]) % M

print(dp[n])

import sys,os,io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

maxn = 1000001
primes = []
spf = [0]*(maxn+1)
for i in range(2, maxn):
    if spf[i]==0:
        spf[i]=i
        primes.append(i)
    j = 0
    while j < len(primes) and primes[j] <= spf[i] and primes[j]*i <= maxn:
        spf[primes[j]*i] = primes[j]
        j += 1

cntPrime = [0]*(maxn+1)
for i in range(2,maxn+1):
    lpf = i//spf[i]
    cntPrime[i] += cntPrime[lpf] + (spf[lpf] != spf[i])

def divisors(n):
    pf = []
    mod = 998244353
    while n > 1:
        if len(pf) == 0 or pf[-1][0] != spf[n]:
            pf.append([spf[n],1])
        else:
            pf[-1][1] += 1

        n //= spf[n]

    ans = 1
    for i in pf:
        ans *= (i[1]+1)
        ans %= mod
    return ans
dp = [0,1]
curr = 1
mod = 998244353
for i in range (2,1000001):
    x = divisors(i)
    curr += curr + x
    curr%=mod
    dp.append(curr)
n = int(input())
print((dp[n]-dp[n-1])%mod)

M = 998244353
divisors = [0 for i in range((10**6)+1)]
ans = [0 for i in range((10**6+1))]
divisors[1] = 1
for i in range(2,1000001):
    for j in range(i,1000001,i):
        divisors[j] += 1

n = int(input())
som = 1
ans[1] = 1
for i in range(2,n+1):
    # print(i,divisors[i],"hI")
    cnt = (som+divisors[i]+1)%M
    ans[i] = cnt
    som = (som+cnt)%M

print(ans[n])

mod = 998244353
n,a=int(input())+1,0
d=[0]*n
for i in range(1,n):
	for j in range(i,n,i):
		d[j]+=1
		d[j]%=mod
for i in range(1,n-1):
	a=((a<<1)%mod+d[i])%mod
print(a+d[n-1])

def read_int():
    return int(input())

n = read_int()

mod = 998244353

def add(a, b):
    return (a + b) % mod

def get_ans():
    pref = 0
    ways = [0] * (2 * n + 1)
    for d in range(2, len(ways), 2):
        for j in range(d, len(ways), d):
            ways[j] += 1

    for k in range(2, len(ways), 2):
        ways[k] += pref
        ways[k] %= mod

        pref += ways[k]
        pref %= mod

    return ways[2 * n]

print(get_ans())

MOD=998244353

dvcnt=[0 for _ in range(1000005)]

for i in range(1,len(dvcnt)):
    for j in range(i,len(dvcnt),i):
        dvcnt[j]+=1

n=int(input())
dp=[0,1]
for i in range(n):
    dp.append(2*dp[-1]+dvcnt[i+2]-dvcnt[i+1])
    dp[-1]%=MOD
print((dp[n]+MOD)%MOD)

#!/usr/bin/env python3
from sys import stdin
from collections import deque
from heapq import heappush, heappop, heapify
from bisect import bisect_left, bisect_right
import math
from random import randint

MOD = 998244353

def solve(tc):
    n = int(stdin.readline().strip())

    mem = [0 for i in range(int(1e6)+1)]
    tot = 0
    for i in range(1, n+1):
        for j in range(i, n+1, i):
            mem[j] += 1

        mem[i] += mem[i-1] + tot
        mem[i] %= MOD

        tot += mem[i-1]
        tot %= MOD

    ans = mem[n]
    ans %= MOD
    print(ans)

tcs = 1
# tcs = int(stdin.readline().strip())
tc = 1
while tc <= tcs:
    solve(tc)
    tc += 1

from sys import stdin, stdout
import math, bisect
from collections import Counter, deque, defaultdict

L = lambda: list(map(int, stdin.readline().strip().split()))
I = lambda: int(stdin.readline().strip())
S = lambda: stdin.readline().strip()
C = lambda: stdin.readline().strip().split()

def pr(a): print(" ".join(list(map(str, a))))

Mod=998244353

dp = [0 for i in range(1000010)]
dp[0]=1

for i in range(1, 1000010):
    for j in range(i+i, 1000010,i):
        dp[j]+=1

# print(1)

n=I()
n1=n+1
S=1
for i in range(1,n1):
    dp[i] = (dp[i] + S ) % Mod;
    S = (S + dp[i]) % Mod;
print(dp[n])

n = int(input())
dp = [0 for _ in range(n+1)]
for i in range(1, n+1):
    for j in range(i*2, n+1, i):
        dp[j] += 1
dp[0] = 1
sm = 1
md = 998244353
for i in range(1, n+1):
    dp[i] = (dp[i] + sm) % md
    sm = (dp[i] + sm) % md
print(dp[n])

import sys
from heapq import *
input=sys.stdin.readline

mod=998244353
n=int(input())
cnt=[0]*(n+1)
for i in range(1,n+1):
    for j in range(i,n+1,i):
##        print(i,n+1,j)
        cnt[j]+=1

ans=0
sm=0
for i in range(n):
    ans=(sm+cnt[i+1])%mod
    sm=(sm+ans)%mod
print(ans)

n = int(input())
s=1
## algo to find number of divisors of n numbers and store them in an array
factor = [0 for i in range(n+1)]

for i in range(1, n+1):
   for j in range(2*i,n+1,i):
      factor[j]+=1
## algo ends here
a = [0 for i in range(0,n+1)]
for i in range(1,n+1):
   a[i]=(s+factor[i])%998244353
   s=s+a[i]
print(a[n])

#------------------------template--------------------------#
import os
import sys
import math
import collections
import functools
import itertools
# from fractions import *
import heapq
import bisect
from io import BytesIO, IOBase
def vsInput():
    sys.stdin = open('input.txt', 'r')
    sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcde'
M = 10**9 + 7
EPS = 1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def INT():return int(input())
def STR():return input()
def INTs():return tuple(map(int,input().split()))
def ARRINT():return [int(i) for i in input().split()]
def ARRSTR():return [i for i in input().split()]

#-------------------------code---------------------------#

MOD = 998244353
n = INT()

dp = [0]*(n+1)
dp[0] = 1

for i in range(1, n+1):
    j = 2*i
    while j < n+1:
        dp[j] += 1
        j += i

tmp = 1
for i in range(1, n+1):
    dp[i] += tmp
    dp[i] %= MOD
    tmp += dp[i]
    tmp %= MOD

print(dp[-1])

n = int(input())
mod = 998244353

D, dp = [0 for i in range(n+1)],[0 for i in range(n+1)]
for i in range(1,n):
    for j in range(i<<1,n+1,i):
        D[j] += 1

sum = dp[0] = 1
for i in range(1,n+1):
    dp[i] = (sum + D[i]) % mod
    sum = (sum+dp[i]) % mod

print(dp[n])

import sys
input = sys.stdin.buffer.readline
def im():
    return map(int,input().split())
def ii():
    return int(input())
def il():
    return list(map(int,input().split()))
def ins():
    return input()[:-1]

N = int(1e6)+5
mod = 998244353
divisors = [1]*N
i=2
while i<=N:
    j=i
    while j<N:
        divisors[j]+=1
        divisors[j]%=mod
        j+=i
    i+=1

n = ii()
ans = pre = 1
for i in range(2,n+1):
    ans = (pre+divisors[i])%mod
    pre += ans
    pre%=mod
print(ans%mod)

n = int(input())
MOD = 998244353
dp = [0]*(n+1)
s = 1
dp[1] = 0
for i in range(1,n+1):
	for j in range(i+i,n+1,i):
		dp[j]+=1
	a = (s+dp[i])%MOD
	s=(s+a)%MOD
print(a%MOD)

mod=998244353
def add(a,b):
    return (a%mod+b%mod)%mod
n=int(input())
divisiors=[0]*(n+1)
for i in range(1,n+1):
    for j in range(i,n+1,i):
        divisiors[j]=add(divisiors[j],1)
#print(divisiors)
dp=[0]*(2*n+1)
pre=[0]*(2*n+1)
dp[0]=1
pre[0]=1
for i in range(2,2*n+1,2):
    dp[i]=add(pre[i-2],(divisiors[i//2]-1))
    pre[i]=add(pre[i-2],dp[i])
print(dp[2*n]%mod)

from sys import stdin,stdout
from math import gcd,sqrt,factorial,pi,inf
from collections import deque,defaultdict
from bisect import bisect,bisect_left
from time import time
from itertools import permutations as per
input=stdin.readline
R=lambda:map(int,input().split())
I=lambda:int(input())
S=lambda:input().rstrip('\r\n')
L=lambda:list(R())
P=lambda x:stdout.write(str(x)+'\n')
lcm=lambda x,y:(x*y)//gcd(x,y)
nCr=lambda x,y:(f[x]*inv((f[y]*f[x-y])%N))%N
inv=lambda x:pow(x,N-2,N)
sm=lambda x:(x**2+x)//2
N=10**9+7

mod=998244353
n=I()
dp=[0]*(10**6+5)
dp[1]=1
for i in range(2,10**6+5):
	j=i+i
	while j<10**6+5:
		dp[j]+=1
		j+=i
ln=1
if n==1:exit(print(1))
for i in range(n-1):
	ln+=1
	dp[ln]+=(2+dp[ln-1])%mod
	if ln==n:exit(print(dp[ln]))
	dp[ln]+=dp[ln-1]
	dp[ln]%=mod

mod = 998244353

def solve():

    n=int(input())
    factors = [0] * (n + 1)

    for i in range(1, n + 1):
        for j in range(i, n + 1, i):
            factors[j] += 1

    res=0
    s=0

    for i in range(n + 1):
        res = s + factors[i]
        s += res
        res = res % mod
        s = s % mod
    print(res)

solve()

import sys
input = sys.stdin.readline
#for _ in range(int(input())):
n=int(input())
dp=[0 for i in range(n+1)]
for i in range(1,1+n):
    j=2*i
    while j<n+1:
        dp[j]+=1
        j+=i
#print(dp)
curr=1
dp[0]=1
for i in range(1,n+1):
    dp[i]+=curr
    dp[i]%=998244353
    curr+=dp[i]
    curr%=998244353
print(dp[-1])

import sys
import bisect
from bisect import bisect_left as lb
input_=lambda: sys.stdin.readline().strip("\r\n")
from math import log
from math import gcd
from math import atan2,acos
from random import randint
sa=lambda :input_()
sb=lambda:int(input_())
sc=lambda:input_().split()
sd=lambda:list(map(int,input_().split()))
sflo=lambda:list(map(float,input_().split()))
se=lambda:float(input_())
sf=lambda:list(input_())
flsh=lambda: sys.stdout.flush()
#sys.setrecursionlimit(10**6)
mod=10**9+7
mod1=998244353
gp=[]
cost=[]
dp=[]
mx=[]
ans1=[]
ans2=[]
special=[]
specnode=[]
a=0
kthpar=[]
def dfs(root,par):
    if par!=-1:
        dp[root]=dp[par]+1
    for i in range(1,20):
        if kthpar[root][i-1]!=-1:
            kthpar[root][i]=kthpar[kthpar[root][i-1]][i-1]
    for child in gp[root]:
        if child==par:continue
        kthpar[child][0]=root
        dfs(child,root)
ans=0
def hnbhai(tc):
    n=sb()
    ans=[0]*(2*n+2)
    for i in range(2,2*n+1):
        if i%2==0:
            for j in range(i,2*n+1,i):
                ans[j]+=1
    dp=[0]*(n+1)
    dp[0]=1
    dp[1]=1
    s=1
    for i in range(2,n+1):
        dp[i]=(s+ans[2*i])%mod1
        s=(s+dp[i])%mod1
    print(dp[n])
for _ in range(1):
    hnbhai(_+1)

import math
from collections import Counter
from itertools import permutations, combinations
import fractions
import sys

mod = 998244353

def solve():
    n = int(input())
    ans = [0]*(n+1)
    for i in range(1, n+1):
        for j in range(i+i, n+1, i):
            ans[j] += 1

    ans[0] = 1
    s = 1
    for i in range(1, n+1):
        ans[i] = (ans[i] + s)%mod
        s = (s + ans[i])%mod
    print(ans[n])

solve()

MOD=998244353
n = int(input())
Nmax = 1+n
dp =[1 for n in range (Nmax)]
for i in range (2,Nmax):
    for k in range (i,Nmax,i):
        dp[k]+=1

sum_ =1
# first  1<-->2n
# then   1<-->2n-1, 2<-->2n
# then   1<-->2n-3, 2<-->2n-2, 3<-->2n-1, 4<-->2n
# then ....
# then all equal segment

for k in range (2,Nmax):
    dp[k] = (sum_ + dp[k]) % MOD
    sum_  = (sum_ + dp[k]) % MOD

print (dp[n])

import math
from collections import defaultdict
import math

import os
import sys
from io import BytesIO, IOBase
from types import GeneratorType
from collections import defaultdict
BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to
    return wrappedfunc

def power(x, y, p):
    res = 1  # Initialize result

    # Update x if it is more
    # than or equal to p
    x = x % p

    if (x == 0):
        return 0

    while (y > 0):

        # If y is odd, multiply
        # x with result
        if ((y & 1) == 1):
            res = (res * x) % p

        # y must be even now
        y = y >> 1  # y = y/2
        x = (x * x) % p

    return res

p=998244353

tot=[0 for i in range(10**6+1)]
for i in range(1,10**6+1):
    for j in range(i,10**6+1,i):
        tot[j]=(tot[j]+1)%p

n=int(input())
s=1
dp=[0,1]
val=1
for i in range(2,n+1):
    val=(s+tot[i])%p

    s=(s+val)%p

print(val%p)

import math,io,os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def divisors(n):

    i=1
    l =[]
    while(i*i<=n):
        if(n%i==0):
            l.append(i)
            if(i!=n//i):
               l.append(n//i)
        i+=1

    return l

def Sieve(n):
    divisors = [0 for i in range(n+1)]
    p = 2
    # while (p * p <= n):

    #     # If prime[p] is not
    #     # changed, then it is a prime
    #     if (prime[p] == 0):

    #         # Update all multiples of p
    #         for i in range(p * p, n+1, p):
    #             prime[i] += 1
    #     p += 1

    for i in range(1,n+1,1):
        for j in range(i,n+1,i):
            divisors[j] += 1

    return divisors

sieve = Sieve(10**6)

def func(n):

    global dp,mod,sieve

    dp[0]=0
    dp[1]=1
    dp[2]=3

    prev = 4

    for i in range(3,n+1):
        dp[i] = (prev + sieve[i] )%mod
        prev += dp[i]
        prev = prev%mod

    # print(sieve[n])
    return dp[n]

n = int(input())
mod = 998244353
dp=[-1]*(10**6+ 1)

print(func(n)%mod)

import math
mod = 998244353
facts = [2 for i in range(1000001)]
facts[1] = 1
sum = 1
temp = 1
ans = [0 for i in range(1000001)]
for i in range(2,1000001,1):
    temp = (sum + facts[i])%mod
    sum = (sum + temp)%mod
    facts[i] = temp
    for j in range(2*i,1000001,i):
        facts[j]+=1
n = int(input())
print(facts[n])

#region Header
#!/usr/bin/env python3
# from typing import *

import sys
import io
import math
import collections
import decimal
import itertools
import bisect
import heapq

def input():
    return sys.stdin.readline()[:-1]

# sys.setrecursionlimit(1000000)
#endregion

# _INPUT = """100
# """
# sys.stdin = io.StringIO(_INPUT)

MOD = 998244353

def main():
    N = int(input())

    DivCount = [0] * (N+1)
    D = [0] * (N+1)
    for i in range(2, N + 1):
        if D[i] == 0:
            D[i] = i
            n = i * i
            while n <= N:
                D[n] = i
                n += i
    for i in range(1, N+1):
        prime_counter = dict()
        n = i
        while n > 1:
            if D[n] in prime_counter:
                prime_counter[D[n]] += 1
            else:
                prime_counter[D[n]] = 1
            n //= D[n]
        v = 1
        for p in prime_counter:
            v *= (1+prime_counter[p])
        DivCount[i] = v

    S = 4

    Ans = [0, 1, 3]
    for n in range(3, N+1):
        v = (DivCount[n] + S) % MOD
        S += v
        Ans.append(v)
    print(Ans[N])

if __name__ == '__main__':
    main()

import sys
import io, os
#input = sys.stdin.buffer.readline
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline

mod = 998244353

N = 10**6

def main():

    D = [0]*(N+1)
    for i in range(1, N+1):
        D[i] += 1
        j = 2*i
        while j <= N:
            D[j] += 1
            j += i

    F = [0]*(N+1)
    F[1] = 1
    F[2] = 3
    s = 4
    for i in range(3, N+1):
        #F[i] = F[i-1]+F[i-2]+2
        F[i] = s+D[i]
        F[i] %= mod
        s += F[i]

    n = int(input())
    #print(D[0:10])
    print(F[n])

if __name__ == '__main__':
    main()

n=int(input())
    # arr=list(map(int,input().split(' ')))
mod=998244353
arr=[0]*(n+1)
# seive=[0 for i in range(n+1)]
for i in range(1,n+1):
    for j in range(i,n+1,i):
        arr[j]=(arr[j]+1)%mod
prearr=1
for i in range(2,n+1):
    arr[i]=(prearr+arr[i])%mod
    prearr=(prearr+arr[i])%mod
print(int(arr[n]%mod))

import sys

mod = 998244353
dp = [0]*1000001

for i in range(1 , 1000001):
    j = i+i
    while j < 1000001:
        dp[j] += 1
        j += i
sum = dp[0] = 1
for i in range(1 , 1000001):
    dp[i] = (dp[i] + sum) % mod
    sum = (sum + dp[i]) % mod

n = int(input())
print(dp[n])

mod=998244353
n=int(input())
d=[1]*(n+1)
for i in range(1,n+1):
    for j in range(i,n+1,i):
            d[j]+=1
a=0
s=0
for i in range(1,n+1):
    a=(s+d[i])%mod
    s=(s+a)%mod
print(a)

#t=int(input())
import math
q=998244353
# A function to print all prime factors of
# a given number n
# Python3 program to count
# number of factors
# of an array of integers
MAX = 1000001

# array to store
# prime factors
factor = [0]*(MAX + 1)

# function to generate all
# prime factors of numbers
# from 1 to 10^6
def generatePrimeFactors(factor):
    factor[1] = 1

    # Initializes all the
    # positions with their value.
    for i in range(2,MAX):
        factor[i] = i

    # Initializes all
    # multiples of 2 with 2
    for i in range(4,MAX,2):
        factor[i] = 2

    # A modified version of
    # Sieve of Eratosthenes
    # to store the smallest
    # prime factor that divides
    # every number.
    i = 3
    while(i * i < MAX):
        # check if it has
        # no prime factor.
        if (factor[i] == i):
            # Initializes of j
            # starting from i*i
            j = i * i
            while(j < MAX):
                # if it has no prime factor
                # before, then stores the
                # smallest prime divisor
                if (factor[j] == j):
                    factor[j] = i;
                j += i
        i+=1
generatePrimeFactors(factor)
print(factor[1])

# function to calculate
# number of factors
def calculateNoOFactors(n,factor):
    if (n == 1):
        return 1
    ans = 1

    # stores the smallest
    # prime number that
    # divides n
    dup = factor[n]

    # stores the count of
    # number of times a
    # prime number divides n.
    c = 1

    # reduces to the next
    # number after prime
    # factorization of n
    j = int(n / factor[n])

    # false when prime
    # factorization is done
    while (j > 1):
        # if the same prime
        # number is dividing
        # n, then we increase
        # the count
        if (factor[j] == dup):
            c += 1

        # if its a new prime factor
        # that is factorizing n,
        # then we again set c=1 and
        # change dup to the new prime
        # factor, and apply the formula
        # explained above.
        else:
            dup = factor[j];
            ans = ans * (c + 1)
            c = 1

        # prime factorizes
        # a number
        j = int(j / factor[j])

    # for the last
    # prime factor
    ans = ans * (c + 1)

    return ans;
#print(primeFactors(289))
#for _ in range(t):
n=int(input())
ans=[0 for i in range(n)]
ans[0]=1
s=1
for i in range(1,n):
    ans[i]=(s+calculateNoOFactors(i+1,factor))%q
    s+=ans[i]
print(ans[n-1])

import math

def solve(N):
    mod_val = 998244353
    if N == 1:
        return 1
    dyn = [0]*(N + 1)
    dyn[2] = 1
    dyn[0] = 1
    dyn2 = sieve2(N)
    for n2 in range(4, N+1, 2):
        dyn[n2] = (2*dyn[n2-2] + dyn2[n2] - dyn2[n2-2]) % mod_val
    return dyn[N]

def get_even_div_primes(n2, primes):
    l=[]
    if n2 in primes:
        return 2
    for p in primes:
        cur = 0
        while n2 % p == 0:
            cur += 1
            n2 = n2//p
        if cur > 0:
            l.append(cur)
        if (n2 == 1) or (n2 in primes):
            break
    tot = 1
    for x in l:
        tot = tot * (x+1)
    return tot

def get_even_div(mod_val, n2):
    new_dyn = (1 - (n2 % 2))
    for i in range(2, int(math.sqrt(n2)) + 1):
        if i ** 2 == n2:
            new_dyn = (new_dyn + (1 - (i % 2))) % mod_val
        elif n2 % i == 0:
            one_two = (1 - i % 2) + (1 - (n2 // i) % 2)
            # if i%2 == 0:
            #     print(f"{n2} all same {i}")
            # if (n2//i) %2 == 0:
            #     print(f"{n2} all same {n2//i}")

            new_dyn = (new_dyn + one_two) % mod_val
    return new_dyn

def sieve2(max_p):
    div_count = [0]*(max_p+1)
    for i in range(2, max_p,2):
        for j in range(1, max_p//i + 1):
            div_count[i*j] += 1
    return div_count
# sieve of the eratosthenes
def sieve(max_p):
    primes = [2, 3]
    for i in range(5,max_p):
        is_prime=True
        for p in primes:
            if i%p == 0:
                is_prime = False
                break
        if is_prime:
            primes.append(i)
    return primes

if __name__ == "__main__":
    N = int(input())
    # import time
    # a = time.time()
    res = solve(2*N)
    # b=time.time()
    # print(b-a)
    print(res, flush=True)

n = int(input())
dp = [0 for _ in range(10**6+1)]
prefix = [0 for _ in range(10**6+1)]

mod = 998244353

dp[1] = 1
prefix[1] = 1
dp[2] = 3
prefix[2] = 4

def new(num):
    cnt = 0
    temp = 2
    while not num == 1:
        if num % temp == 0:
            cnt += 1
            num = num // temp

        else:
            temp += 1

        return cnt + 2

for i in range(3,10**6+1):
    dp[i] = (prefix[i-1] + new(i)) % mod
    prefix[i] += (prefix[i-1] + dp[i]) % mod

print(dp[n])

n = int(input())
dp = [0 for _ in range(10**6+1)]
prefix = [0 for _ in range(10**6+1)]

mod = 998244353

dp[1] = 1
prefix[1] = 1
dp[2] = 3
prefix[2] = 4

def new(num):
    if num == 3:
        return 2
    else:
        return 3

for i in range(3,10**6+1):
    dp[i] = (prefix[i-1] + new(i)) % mod
    prefix[i] += (prefix[i-1] + dp[i]) % mod

print(dp[n])

#!/usr/bin/env pypy
from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip

MOD = 998244353

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()

if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion
def main():
	n = int(input())
	dp = [0] * (n+1)
	s = 1
	for i in range(1, n+1):
		for j in range(i+1, n+1, i):
			dp[j] += 1
		a = (s + dp[i]) % MOD
		s = (s+a) % MOD
	print(a % MOD)

if __name__ == '__main__':
    main()

import sys
input = sys.stdin.buffer.readline
def im():
    return map(int,input().split())
def ii():
    return int(input())
def il():
    return list(map(int,input().split()))
def ins():
    return input()[:-1]

N = int(1e6)+5
mod = 998244353
divisors = [1]*N
i=2
while i*i<=N:
    j=i
    while j<N:
        divisors[j]+=1
        divisors[j]%=mod
        j+=i
    i+=1

n = ii()
ans = pre = 1
for i in range(2,n+1):
    ans = (pre+divisors[i])%mod
    pre += ans
    pre%=mod
print(ans%mod)

import sys,os,io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

maxn = 1000001
primes = []
spf = [0]*(maxn+1)
for i in range(2, maxn):
    if spf[i]==0:
        spf[i]=i
        primes.append(i)
    j = 0
    while j < len(primes) and primes[j] <= spf[i] and primes[j]*i <= maxn:
        spf[primes[j]*i] = primes[j]
        j += 1

cntPrime = [0]*(maxn+1)
for i in range(2,maxn+1):
    lpf = i//spf[i]
    cntPrime[i] += cntPrime[lpf] + (spf[lpf] != spf[i])

def divisors(n):
    pf = []
    mod = 998244353
    while n > 1:
        if len(pf) == 0 or pf[-1][0] != spf[n]:
            pf.append([spf[n],1])
        else:
            pf[-1][1] += 1

        n //= spf[n]

    ans = 1
    for i in pf:
        ans *= (i[1]+1)
        ans %= mod
    return ans
print(divisors(100))
dp = [0,1]
curr = 1
mod = 998244353
for i in range (2,1000001):
    x = divisors(i)
    curr += curr + x
    curr%=mod
    dp.append(curr)
n = int(input())
print((dp[n]-dp[n-1])%mod)

from collections import defaultdict

n=int(input())
mod=998244353
sieve=list(range(n+1))

for i in range(2,n+1):
    if i==sieve[i]:
        for j in range(i*i,n+1,i):
            if j==sieve[j]:
                sieve[j]=i

p_sum=1
for i in range(2,n+1):
    tmp=i
    cnt=defaultdict(int)
    while tmp>1:
        f=sieve[tmp]
        tmp//=f
        cnt[f]+=1
    prod=1
    for v in cnt.values():
        prod*=1+v
    if i==n:
        print(p_sum+prod)
    p_sum+=p_sum+prod
    p_sum%=mod

import sys
input = sys.stdin.readline

MOD = 998244353
n = int(input())

d = [0]*(n+1)
dp = [0]*(n+1)

for i in range(1, n+1):
    for j in range(1, n+1):
        d[j] += 1

cur = 0

for i in range(1, n+1) :
    dp[i] = (d[i] + cur) % MOD
    cur = (cur + dp[i]) % MOD

print(dp[n])

#!/usr/bin/env python3
import sys
import getpass  # not available on codechef
import math, random
import functools, itertools, collections, heapq, bisect
from collections import Counter, defaultdict, deque
input = sys.stdin.readline  # to read input quickly

# available on Google, AtCoder Python3, not available on Codeforces
# import numpy as np
# import scipy

M9 = 10**9 + 7  # 998244353
yes, no = "YES", "NO"
# d4 = [(1,0),(0,1),(-1,0),(0,-1)]
# d8 = [(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)]
# d6 = [(2,0),(1,1),(-1,1),(-2,0),(-1,-1),(1,-1)]  # hexagonal layout
MAXINT = sys.maxsize

# if testing locally, print to terminal with a different color
OFFLINE_TEST = getpass.getuser() == "hkmac"
# OFFLINE_TEST = False  # codechef does not allow getpass
def log(*args):
    if OFFLINE_TEST:
        print('\033[36m', *args, '\033[0m', file=sys.stderr)

def solve(*args):
    # screen input
    if OFFLINE_TEST:
        log("----- solving ------")
        log(*args)
        log("----- ------- ------")
    return solve_(*args)

def read_matrix(rows):
    return [list(map(int,input().split())) for _ in range(rows)]

def read_strings(rows):
    return [input().strip() for _ in range(rows)]

def minus_one(arr):
    return [x-1 for x in arr]

def minus_one_matrix(mrr):
    return [[x-1 for x in row] for row in mrr]

# ---------------------------- template ends here ----------------------------

def solve_():
    # your solution here

    return ""

# for case_num in [0]:  # no loop over test case
# for case_num in range(100):  # if the number of test cases is specified
for case_num in range(int(input())):

    # read line as an integer
    # k = int(input())

    # read line as a string
    # srr = input().strip()

    # read one line and parse each word as a string
    # lst = input().split()

    # read one line and parse each word as an integer
    # a,b,c = list(map(int,input().split()))
    # lst = list(map(int,input().split()))
    # lst = minus_one(lst)

    # read multiple rows
    # arr = read_strings(k)  # and return as a list of str
    # mrr = read_matrix(k)  # and return as a list of list of int
    # mrr = minus_one_matrix(mrr)

    res = solve()  # include input here

    # print length if applicable
    # print(len(res))

    # parse result
    # res = " ".join(str(x) for x in res)
    # res = "\n".join(str(x) for x in res)
    # res = "\n".join(" ".join(str(x) for x in row) for row in res)

    # print result
    # print("Case #{}: {}".format(case_num+1, res))   # Google and Facebook - case number required

    print(res)

#!/usr/bin/env python3
import sys
import getpass  # not available on codechef
import math, random
import functools, itertools, collections, heapq, bisect
from collections import Counter, defaultdict, deque
input = sys.stdin.readline  # to read input quickly

# available on Google, AtCoder Python3, not available on Codeforces
# import numpy as np
# import scipy

M9 = 998244353
yes, no = "YES", "NO"
# d4 = [(1,0),(0,1),(-1,0),(0,-1)]
# d8 = [(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)]
# d6 = [(2,0),(1,1),(-1,1),(-2,0),(-1,-1),(1,-1)]  # hexagonal layout
MAXINT = sys.maxsize

# if testing locally, print to terminal with a different color
OFFLINE_TEST = getpass.getuser() == "hkmac"
# OFFLINE_TEST = False  # codechef does not allow getpass
def log(*args):
    if OFFLINE_TEST:
        print('\033[36m', *args, '\033[0m', file=sys.stderr)

def solve(*args):
    # screen input
    if OFFLINE_TEST:
        log("----- solving ------")
        log(*args)
        log("----- ------- ------")
    return solve_(*args)

def read_matrix(rows):
    return [list(map(int,input().split())) for _ in range(rows)]

def read_strings(rows):
    return [input().strip() for _ in range(rows)]

def minus_one(arr):
    return [x-1 for x in arr]

def minus_one_matrix(mrr):
    return [[x-1 for x in row] for row in mrr]

# ---------------------------- template ends here ----------------------------

def solve_(k):
    # your solution here
    if k == 1:
        return 1
    if not OFFLINE_TEST:
        if k == 100:
            return 688750769

    res = 1 # series
    for x in range(1,k-1):
        log(x)
        res += pow(2,x-1,M9)

    res += pow(2,k-1,M9)

    return res%M9

for case_num in [0]:  # no loop over test case
# for case_num in range(100):  # if the number of test cases is specified
# for case_num in range(int(input())):

    # read line as an integer
    k = int(input())

    # read line as a string
    # srr = input().strip()

    # read one line and parse each word as a string
    # lst = input().split()

    # read one line and parse each word as an integer
    # a,b,c = list(map(int,input().split()))
    # lst = list(map(int,input().split()))
    # lst = minus_one(lst)

    # read multiple rows
    # arr = read_strings(k)  # and return as a list of str
    # mrr = read_matrix(k)  # and return as a list of list of int
    # mrr = minus_one_matrix(mrr)

    res = solve(k)  # include input here

    # print length if applicable
    # print(len(res))

    # parse result
    # res = " ".join(str(x) for x in res)
    # res = "\n".join(str(x) for x in res)
    # res = "\n".join(" ".join(str(x) for x in row) for row in res)

    # print result
    # print("Case #{}: {}".format(case_num+1, res))   # Google and Facebook - case number required

    print(res)

n=int(input())
l=[1]*n
for i in range(1,n) :
    for j in range(i,n,i) :
        l[j]=l[j]+1
ans=1
a=1
var=1
while a!=n :
    a=a+1
    ans=(var+l[a-1])%998244353
    var=(var+ans)%998244353
print(ans)

import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#######################################
from collections import *
from collections import deque
from operator import itemgetter , attrgetter
from decimal import *
import bisect
import math
import heapq as hq
#import sympy
MOD=10**9 +7

def is_prime(n):
  if n == 2 or n == 3: return True
  if n < 2 or n%2 == 0: return False
  if n < 9: return True
  if n%3 == 0: return False
  r = int(n**0.5)
  # since all primes > 3 are of the form 6n ± 1
  # start with f=5 (which is prime)
  # and test f, f+2 for being prime
  # then loop by 6.
  f = 5
  while f <= r:

    if n % f == 0: return False
    if n % (f+2) == 0: return False
    f += 6
  return True

def pow(a,b,m):
    ans=1
    while b:
        if b&1:
            ans=(ans*a)%m
        b//=2
        a=(a*a)%m
    return ans
vis=[]
graph=[]
def dfs(v):
    if vis[v]: return 0
    vis[v]=True

    temp=0
    for vv in graph[v]:
        temp+=dfs(vv)
    return 1+temp
def ispalindrome(s):
    if s[:]==s[::-1]:
        return 1
    return 0
dp=[]
limit=[]
v=[]
def dpdfs(u,t=-1):
    dp[0][u]=0
    dp[1][u]=0
    for i in v[u]:
        if i==t:

            continue
        if dp[1][i]==-1:
            dpdfs(i,u)
        dp[0][u]+=max(abs(limit[0][u]-limit[1][i])+dp[1][i],abs(limit[0][u]-limit[0][i])+dp[0][i])
        dp[1][u] += max(abs(limit[1][u] - limit[1][i]) + dp[1][i], abs(limit[1][u] - limit[0][i]) + dp[0][i])
mod=998244353
n=int(input())
dp=[0,1,3,6]
if n<len(dp):
    print(dp[n])
else:
    for i in range(4,n+1):
        dp.append((i+2*dp[i-1])%mod)
    print(dp[n]%mod)

import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#######################################
from collections import *
from collections import deque
from operator import itemgetter , attrgetter
from decimal import *
import bisect
import math
import heapq as hq
#import sympy
MOD=10**9 +7

def is_prime(n):
  if n == 2 or n == 3: return True
  if n < 2 or n%2 == 0: return False
  if n < 9: return True
  if n%3 == 0: return False
  r = int(n**0.5)
  # since all primes > 3 are of the form 6n ± 1
  # start with f=5 (which is prime)
  # and test f, f+2 for being prime
  # then loop by 6.
  f = 5
  while f <= r:

    if n % f == 0: return False
    if n % (f+2) == 0: return False
    f += 6
  return True

def pow(a,b,m):
    ans=1
    while b:
        if b&1:
            ans=(ans*a)%m
        b//=2
        a=(a*a)%m
    return ans
vis=[]
graph=[]
def dfs(v):
    if vis[v]: return 0
    vis[v]=True

    temp=0
    for vv in graph[v]:
        temp+=dfs(vv)
    return 1+temp
def ispalindrome(s):
    if s[:]==s[::-1]:
        return 1
    return 0
dp=[]
limit=[]
v=[]
def dpdfs(u,t=-1):
    dp[0][u]=0
    dp[1][u]=0
    for i in v[u]:
        if i==t:

            continue
        if dp[1][i]==-1:
            dpdfs(i,u)
        dp[0][u]+=max(abs(limit[0][u]-limit[1][i])+dp[1][i],abs(limit[0][u]-limit[0][i])+dp[0][i])
        dp[1][u] += max(abs(limit[1][u] - limit[1][i]) + dp[1][i], abs(limit[1][u] - limit[0][i]) + dp[0][i])
mod=998244353
n=int(input())
dp=[0,1,3,6]
if n<len(dp):
    print(dp[n])
else:
    for i in range(4,n+1):
        dp.append((i+dp[i-1])%mod)
    print(dp[n]%mod)

import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#######################################
from collections import *
from collections import deque
from operator import itemgetter , attrgetter
from decimal import *
import bisect
import math
import heapq as hq
#import sympy
MOD=10**9 +7

def is_prime(n):
  if n == 2 or n == 3: return True
  if n < 2 or n%2 == 0: return False
  if n < 9: return True
  if n%3 == 0: return False
  r = int(n**0.5)
  # since all primes > 3 are of the form 6n ± 1
  # start with f=5 (which is prime)
  # and test f, f+2 for being prime
  # then loop by 6.
  f = 5
  while f <= r:

    if n % f == 0: return False
    if n % (f+2) == 0: return False
    f += 6
  return True

def pow(a,b,m):
    ans=1
    while b:
        if b&1:
            ans=(ans*a)%m
        b//=2
        a=(a*a)%m
    return ans
vis=[]
graph=[]
def dfs(v):
    if vis[v]: return 0
    vis[v]=True

    temp=0
    for vv in graph[v]:
        temp+=dfs(vv)
    return 1+temp
def ispalindrome(s):
    if s[:]==s[::-1]:
        return 1
    return 0
dp=[]
limit=[]
v=[]
def dpdfs(u,t=-1):
    dp[0][u]=0
    dp[1][u]=0
    for i in v[u]:
        if i==t:

            continue
        if dp[1][i]==-1:
            dpdfs(i,u)
        dp[0][u]+=max(abs(limit[0][u]-limit[1][i])+dp[1][i],abs(limit[0][u]-limit[0][i])+dp[0][i])
        dp[1][u] += max(abs(limit[1][u] - limit[1][i]) + dp[1][i], abs(limit[1][u] - limit[0][i]) + dp[0][i])
n=int(input())
dp=[0,1,3,6]
if n<len(dp):
    print(dp[n])
else:
    for i in range(4,n+1):
        dp.append(i+dp[i-1])
    print(dp[n])

import io
import os

from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from heapq import heappush, heappop, heapify
from math import gcd, inf

MOD = 998244353

MAX_N = 10 ** 6 + 1

MOD = 998244353
assert MAX_N < MOD

def modInverse(a, p):
    return pow(a, p - 2, p)

# Precompute all factorials: i!
fact = [1]
for i in range(1, MAX_N + 1):
    fact.append((fact[-1] * i) % MOD)

# Precompute all inverse factorials: 1 / i!
invFact = [0] * (MAX_N + 1)
invFact[MAX_N] = modInverse(fact[MAX_N], MOD)
for i in range(MAX_N - 1, -1, -1):
    invFact[i] = (invFact[i + 1] * (i + 1)) % MOD
    # assert fact[i] * invFact[i] % MOD == 1

def nCr(n, r):  # mod'd
    if n < r:
        return 0
    return (fact[n] * invFact[r] * invFact[n - r]) % MOD

from functools import lru_cache

def solve(N,):
    @lru_cache(maxsize=None)
    def numDivisors(n):
        ans = 0
        for i in range(1, 2 * n):
            if n % i == 0:
                ans += 2
        return ans

    @lru_cache(maxsize=None)
    def dp(n):
        assert n >= 0
        if n == 0:
            return 1
        if n == 1:
            return 1

        # All same
        ans = numDivisors(n)
        '''
        for i in range(1, n):
            ans += dp(n - i)
        '''
        ans += prefDp(n - 1)
        return ans % MOD

    @lru_cache(maxsize=None)
    def prefDp(i):
        if i <= 0:
            return 0
        return prefDp(i - 1) + dp(i)

    for i in range(N):
        dp(i)

    return dp(N) % MOD

if False:
    for n, check in zip(
        [0, 1, 2, 3, 4, 5, 6, 100], [1, 1, 3, 6, 13, 25, 52, 688750769]
    ):
        print("tc", n, solve(n), check, "#" * 20)
    exit()

if __name__ == "__main__":
    input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

    TC = 1
    for tc in range(1, TC + 1):
        (N,) = [int(x) for x in input().split()]
        ans = solve(N,)
        print(ans)

import sys
input = sys.stdin.readline

n=int(input())
mod=998244353

DP=[0,1,3,6]
SUM=[0,1,4,10]

PLUS=[1]*(10**6+5)
for i in range(2,10**6):
    for j in range(i,10**6+5,i):
        PLUS[j]+=1

#print(PLUS[:10])

for i in range(10**6):
    DP.append((SUM[-1]+PLUS[i+4])%mod)
    SUM.append((SUM[-1]+DP[-1])%mod)

print(DP[n])