Problem: 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>

Solution (in PYTHON3):

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