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:

<image>

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.

Input

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

Output

Print the number of good pairings modulo 998244353.

Examples

Input


1


Output


1

Input


2


Output


3

Input


3


Output


6

Input


100


Output


688750769

Note

The good pairings for the second example are: 

<image>

In the third example, the good pairings are: 

<image>

Difficulty: MEDIUM_HARD

Solutions:
import sys, math
import io, os

def data():
	return sys.stdin.buffer.readline().strip()

def mdata():
	return list(map(int, data().split()))

def outl(var):
	sys.stdout.write(' '.join(map(str, var)) + '\n')

def out(var):
	sys.stdout.write(str(var) + '\n')
mod = 998244353
n = int(data())
l = [1] * (n + 1)
for i in range(1, n + 1):
	for j in range(i * 2, n + 1, i):
		l[j] += 1
dp = [1]
s = 1
for i in range(1, n + 1):
	a = s
	a += l[i] - 1
	dp.append(a % mod)
	s += dp[i]
print(dp[-1])


n = int(input())
l = [1] * n
for i in range(1, n):
	for j in range(i, n, i + 1):
		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)


MAX = 1000001
factor = [0] * (MAX + 1)

def generatePrimeFactors():
	factor[1] = 1
	for i in range(2, MAX):
		factor[i] = i
	for i in range(4, MAX, 2):
		factor[i] = 2
	i = 3
	while i * i < MAX:
		if factor[i] == i:
			j = i * i
			while j < MAX:
				if factor[j] == j:
					factor[j] = i
				j += i
		i += 1

def calculateNoOFactors(n):
	if n == 1:
		return 1
	ans = 1
	dup = factor[n]
	c = 1
	j = int(n / factor[n])
	while j > 1:
		if factor[j] == dup:
			c += 1
		else:
			dup = factor[j]
			ans = ans * (c + 1)
			c = 1
		j = int(j / factor[j])
	ans = ans * (c + 1)
	return ans
generatePrimeFactors()
a = [10, 30, 100, 450, 987]
q = len(a)
for i in range(0, q):
	pass
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 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')

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

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

def N():
	return int(input())

def A(n):
	return [0] * n

def AI(n, x):
	return [x] * n

def A2(n, m):
	return [[0] * m for i in range(n)]

def G(n):
	return [[] for i in range(n)]

def GP(it):
	return [[ch, len(list(g))] for (ch, g) in groupby(it)]
from types import GeneratorType

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
mod = 10 ** 9 + 7
farr = [1]
ifa = []

def fact(x, mod=0):
	if mod:
		while x >= len(farr):
			farr.append(farr[-1] * len(farr) % mod)
	else:
		while x >= len(farr):
			farr.append(farr[-1] * len(farr))
	return farr[x]

def ifact(x, mod):
	global ifa
	fact(x, mod)
	ifa.append(pow(farr[-1], mod - 2, mod))
	for i in range(x, 0, -1):
		ifa.append(ifa[-1] * i % mod)
	ifa.reverse()

def per(i, j, mod=0):
	if i < j:
		return 0
	if not mod:
		return fact(i) // fact(i - j)
	return farr[i] * ifa[i - j] % mod

def com(i, j, mod=0):
	if i < j:
		return 0
	if not mod:
		return per(i, j) // fact(j)
	return per(i, j, mod) * ifa[j] % mod

def catalan(n):
	return com(2 * n, n) // (n + 1)

def isprime(n):
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			return False
	return True

def floorsum(a, b, c, n):
	if a == 0:
		return b // c * (n + 1)
	if a >= c or b >= c:
		return floorsum(a % c, b % c, c, n) + b // c * (n + 1) + a // c * n * (n + 1) // 2
	m = (a * n + b) // c
	return n * m - floorsum(c, c - b - 1, a, m - 1)

def inverse(a, m):
	a %= m
	if a <= 1:
		return a
	return (1 - inverse(m, a) * m) // a % m

def lowbit(n):
	return n & -n

class BIT:

	def __init__(self, arr):
		self.arr = arr
		self.n = len(arr) - 1

	def update(self, x, v):
		while x <= self.n:
			self.arr[x] += v
			x += x & -x

	def query(self, x):
		ans = 0
		while x:
			ans += self.arr[x]
			x &= x - 1
		return ans

class ST:

	def __init__(self, arr):
		n = len(arr)
		mx = n.bit_length()
		self.st = [[0] * mx for i in range(n)]
		for i in range(n):
			self.st[i][0] = arr[i]
		for j in range(1, mx):
			for i in range(n - (1 << j) + 1):
				self.st[i][j] = max(self.st[i][j - 1], self.st[i + (1 << j - 1)][j - 1])

	def query(self, l, r):
		if l > r:
			return -inf
		s = (r + 1 - l).bit_length() - 1
		return max(self.st[l][s], self.st[r - (1 << s) + 1][s])

class DSU:

	def __init__(self, n):
		self.c = [-1] * n

	def same(self, x, y):
		return self.find(x) == self.find(y)

	def find(self, x):
		if self.c[x] < 0:
			return x
		self.c[x] = self.find(self.c[x])
		return self.c[x]

	def union(self, u, v):
		(u, v) = (self.find(u), self.find(v))
		if u == v:
			return False
		if self.c[u] > self.c[v]:
			(u, v) = (v, u)
		self.c[u] += self.c[v]
		self.c[v] = u
		return True

	def size(self, x):
		return -self.c[self.find(x)]

class UFS:

	def __init__(self, n):
		self.parent = [i for i in range(n)]
		self.ranks = [0] * n

	def find(self, x):
		if x != self.parent[x]:
			self.parent[x] = self.find(self.parent[x])
		return self.parent[x]

	def union(self, u, v):
		(pu, pv) = (self.find(u), self.find(v))
		if pu == pv:
			return False
		if self.ranks[pu] >= self.ranks[pv]:
			self.parent[pv] = pu
			if self.ranks[pv] == self.ranks[pu]:
				self.ranks[pu] += 1
		else:
			self.parent[pu] = pv

class UF:

	def __init__(self, n):
		self.parent = [i for i in range(n)]
		self.ranks = [0] * n
		self.size = AI(n, 1)
		self.edge = A(n)

	def find(self, x):
		if x != self.parent[x]:
			self.parent[x] = self.find(self.parent[x])
		return self.parent[x]

	def union(self, u, v):
		(pu, pv) = (self.find(u), self.find(v))
		if pu == pv:
			self.edge[pu] += 1
			return False
		if self.ranks[pu] >= self.ranks[pv]:
			self.parent[pv] = pu
			self.edge[pu] += self.edge[pv] + 1
			self.size[pu] += self.size[pv]
			if self.ranks[pv] == self.ranks[pu]:
				self.ranks[pu] += 1
		else:
			self.parent[pu] = pv
			self.edge[pv] += self.edge[pu] + 1
			self.size[pv] += self.size[pu]

def Prime(n):
	c = 0
	prime = []
	flag = [0] * (n + 1)
	for i in range(2, n + 1):
		if not flag[i]:
			prime.append(i)
			c += 1
		for j in range(c):
			if i * prime[j] > n:
				break
			flag[i * prime[j]] = prime[j]
			if i % prime[j] == 0:
				break
	return flag

def dij(s, graph):
	d = AI(n, inf)
	d[s] = 0
	heap = [(0, s)]
	vis = A(n)
	while heap:
		(dis, u) = heappop(heap)
		if vis[u]:
			continue
		vis[u] = 1
		for (v, w) in graph[u]:
			if d[v] > d[u] + w:
				d[v] = d[u] + w
				heappush(heap, (d[v], v))
	return d

def bell(s, g):
	dis = AI(n, inf)
	dis[s] = 0
	for i in range(n - 1):
		for (u, v, w) in edge:
			if dis[v] > dis[u] + w:
				dis[v] = dis[u] + w
	change = A(n)
	for i in range(n):
		for (u, v, w) in edge:
			if dis[v] > dis[u] + w:
				dis[v] = dis[u] + w
				change[v] = 1
	return dis

def lcm(a, b):
	return a * b // gcd(a, b)

def lis(nums):
	res = []
	for k in nums:
		i = bisect.bisect_left(res, k)
		if i == len(res):
			res.append(k)
		else:
			res[i] = k
	return len(res)

def RP(nums):
	n = len(nums)
	s = set(nums)
	d = {}
	for (i, k) in enumerate(sorted(s), 1):
		d[k] = i
	bi = BIT([0] * (len(s) + 1))
	ans = 0
	for i in range(n - 1, -1, -1):
		ans += bi.query(d[nums[i]] - 1)
		bi.update(d[nums[i]], 1)
	return ans

def michange(a, b):
	d = defaultdict(deque)
	for (i, x) in enumerate(b):
		d[x].append(i)
	order = A(len(a))
	for (i, x) in enumerate(a):
		if not d:
			return -1
		order[i] = d[x].popleft()
	return RP(order)

class DLN:

	def __init__(self, val):
		self.val = val
		self.pre = None
		self.next = None

def nb(i, j, n, m):
	for (ni, nj) in [[i + 1, j], [i - 1, j], [i, j - 1], [i, j + 1]]:
		if 0 <= ni < n and 0 <= nj < m:
			yield (ni, nj)

def topo(n):
	q = deque()
	res = []
	for i in range(1, n + 1):
		if ind[i] == 0:
			q.append(i)
			res.append(i)
	while q:
		u = q.popleft()
		for v in g[u]:
			ind[v] -= 1
			if ind[v] == 0:
				q.append(v)
				res.append(v)
	return res

@bootstrap
def gdfs(r, p):
	for ch in g[r]:
		if ch != p:
			yield gdfs(ch, r)
	yield None
mod = 998244353
t = 1
for i in range(t):
	n = N()
	dp = 1
	pre = 2
	flag = Prime(n)
	for i in range(2, n + 1):
		cnt = 1
		while flag[i]:
			c = 0
			tmp = flag[i]
			while i % tmp == 0:
				i //= tmp
				c += 1
			cnt *= c + 1
		if i > 1:
			cnt *= 2
		dp = (pre + cnt - 1) % mod
		pre = (pre + dp) % mod
	ans = dp
	print(ans)


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


n = int(input())
m = 998244353
if n == 1:
	print(1)
else:
	dp = [0] * (n + 1)
	dp[1] = 1
	f = [0] * (n + 1)
	for i in range(1, n // 2 + 1):
		for j in range(2 * i, n + 1, i):
			f[j] += 1
	c = 1
	for i in range(2, n + 1):
		dp[i] = c + f[i] + 1
		c += dp[i]
		dp[i] %= m
		c %= m
	print(dp[n])


(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
for i in range(1, n - 1):
	a = (2 * a + d[i]) % 998244353
print(a + d[n - 1])


import sys
input = lambda : sys.stdin.readline().rstrip()
N = int(input())
prime_list = []
lpf = [0] * (N + 1)
for i in range(2, N + 1):
	if not lpf[i]:
		lpf[i] = i
		prime_list.append(i)
	a = lpf[i]
	for p in prime_list:
		if p > a or p * i > N:
			break
		lpf[p * i] = p
lpf_cnt = [1] * (N + 1)
div_cnt = [1] * (N + 1)
for i in range(2, N + 1):
	p = lpf[i]
	ip = i // p
	if ip % p:
		div_cnt[i] = div_cnt[ip] * 2
	else:
		lpf_cnt[i] = lpf_cnt[ip] + 1
		div_cnt[i] = div_cnt[ip] // lpf_cnt[i] * (lpf_cnt[i] + 1)
P = 998244353
x = 0
for i in range(1, N + 1):
	y = div_cnt[i] + x
	x = (x + y) % P
print(y)


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


def sieve(N):
	l = [0] * N
	for i in range(1, N + 1):
		z = i
		while z <= N:
			l[z - 1] += 1
			z += i
	return l

def main():
	n = int(input())
	mod = 998244353
	l = sieve(n)
	total = l[n - 1]
	p = 1
	for i in range(n - 1, 0, -1):
		total += l[i - 1] * p
		total %= mod
		p *= 2
		p %= mod
	print(total)
main()


N = int(input())
total = 1
result = 1
ds = [1] * (N + 1)
for k in range(2, N + 1):
	d = k
	while d <= N:
		ds[d] += 1
		d += k
for n in range(2, N + 1):
	result = total + ds[n]
	total = (total + result) % 998244353
print(result)


from collections import defaultdict
from functools import reduce
from bisect import bisect_right
from bisect import bisect_left
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):
	for i in range(1, n + 1):
		for j in range(i, n + 1, i):
			div[j] += 1

def primes1(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)
main()


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


def some_random_function():
	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():
	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

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


n = int(input())
if n == 1:
	print(1)
else:
	summ = 1
	mod = 998244353
	divisor = [0] * n
	for i in range(1, n + 1):
		for j in range(i, n + 1, i):
			divisor[j - 1] += 1
	for i in range(2, n + 1):
		divisor[i - 1] += summ
		if divisor[i - 1] > mod:
			divisor[i - 1] -= mod
		summ += divisor[i - 1]
		if summ > mod:
			summ -= mod
	print(divisor[n - 1])