Kavi has $$$2n$$$ points lying on the $$$OX$$$ axis, $$$i$$$-th of which is located at $$$x = i$$$.Kavi considers all ways to split these $$$2n$$$ points into $$$n$$$ pairs. Among those, he is interested in good pairings, which are defined as follows:Consider $$$n$$$ segments with ends at the points in correspondent pairs. The pairing is called good, if for every $$$2$$$ different segments $$$A$$$ and $$$B$$$ among those, at least one of the following holds:  One of the segments $$$A$$$ and $$$B$$$ lies completely inside the other.  $$$A$$$ and $$$B$$$ have the same length. Consider the following example:  $$$A$$$ is a good pairing since the red segment lies completely inside the blue segment.$$$B$$$ is a good pairing since the red and the blue segment have the same length.$$$C$$$ is not a good pairing since none of the red or blue segments lies inside the other, neither do they have the same size.Kavi is interested in the number of good pairings, so he wants you to find it for him. As the result can be large, find this number modulo $$$998244353$$$.Two pairings are called different, if some two points are in one pair in some pairing and in different pairs in another.

The single line of the input contains a single integer $$$n$$$ $$$(1\le n \le 10^6)$$$.

Print the number of good pairings modulo $$$998244353$$$.

NoteThe good pairings for the second example are:   In the third example, the good pairings are:

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)

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])

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())
    # 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
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])

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)

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))

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()

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)

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()))

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)

#------------------------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])

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)

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])

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

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()

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

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,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)

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()

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()

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())
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])

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)

#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
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])

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
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)

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)

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 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_()

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])

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]

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])

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])

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())

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)

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)

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]*(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)

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])

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)

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])

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])

# 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])

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])

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()

# 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()

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])

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])

# 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()

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])

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])

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

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 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])

#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])

# 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())
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])

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()

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
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)

#!/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

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])

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])

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 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])

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)

# 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())
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])