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

Solution:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.function.BiConsumer;

import javax.sound.midi.SysexMessage;

import java.io.IOException;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;

public class S2 {
	
	static class Reader {
		
		static BufferedReader reader;
		static StringTokenizer tokenizer;
		
		static void init(InputStream input) {
			reader = new BufferedReader(new InputStreamReader(input));
			tokenizer = new StringTokenizer("");
		}
		
		static String next() throws IOException {
			while(!tokenizer.hasMoreTokens()) {
				tokenizer = new StringTokenizer(reader.readLine());
			}
			return tokenizer.nextToken();
		}
		
		static int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
		
		static long nextLong() throws IOException {
			return Long.parseLong(next());
		}
		
	}
	
	private static void arrInp(int n1) throws IOException {
		// TODO Auto-generated method stub
		arr = new long[n1];
		for(int i=0; i<n1; i++) {
			long a = Reader.nextLong();
			arr[i] = a;
		}
	}

	static long[] merge(long[] a, long[] b) {
		int m = a.length;
		int n = b.length;
		long [] c = new long[n+m];
		
		int j=0, k=0;
		while(j+k<m+n) {
			if(j>=m) {
				c[j+k] = b[k];
				k++;
			}
			else if(k>=n) {
				c[j+k] = a[j];
				j++;
			}
			else {
				if(a[j]<b[k]) {
					c[j+k] = a[j];
					j++;
				}
				else if(a[j]==b[k]) {
					if(a[j]<b[k]) {
						c[j+k] = a[j];
						j++;
					}
					else {
						c[j+k] = b[k];
						k++;
					}
				}
				else {
					c[j+k] = b[k];
					k++;
				}
			}
		}
		return c;
	}
	
	static long[] Msort(long[] unsorted){
		int l = unsorted.length;
		
		if(l<=1) {
			return unsorted;
		}
		
		else {
			long[] Msorted = new long[l];
			long[] m1 = new long[l/2];
			long[] m2 = new long[l-(l/2)];
			
			for(int i=0; i<l; i++) {
				if(i<l/2) {
					m1[i] = unsorted[i];
				}
				else {
					m2[i-(l/2)] = unsorted[i];
				}
			}
			
			Msorted = merge(Msort(m1), Msort(m2));		
			
			return Msorted;
		}
		
	}
	
	private static long inf = 1<<27;
	private static long ans;
	private static long n;
	private static long k;
	private static long[] arr;
	private static char[] str;
	private final static long qwerty = 1000000007;
	private static boolean bruh;
	private static Vtx[] vts;
	
	private static class Vtx {
		public long l,r, lAns,rAns;
		public ArrayList<Integer> nbs;
		public boolean visited;
		
		public Vtx(int l1, int r1) {
			l=l1;
			r=r1;
			nbs = new ArrayList<Integer>();
		}
		
		public void addN(int v) {
			nbs.add(v);
		}
		
		public void calc() {
			visited = true;
			lAns=0;
			rAns=0;
			int l = nbs.size();
			for(int i=0; i<l; i++) {
				Vtx v = vts[nbs.get(i)];
				if(!v.visited) {
					v.calc();
					//rAns
					long rx = v.rAns+(Math.abs(this.r-v.r)); 
					long lx = v.lAns+(Math.abs(this.r-v.l));
					rAns += Math.max(rx, lx);
					
					//lAns
					rx = v.rAns+(Math.abs(this.l-v.r)); 
					lx = v.lAns+(Math.abs(this.l-v.l));
					lAns += Math.max(rx, lx);
				}
			}
		}
		
	}
	

	public static void main(String[] args) throws IOException {
				
		ans = 0;
		
		Reader.init(System.in);
		
		OutputStream out = new BufferedOutputStream(System.out);
		
		int tc=1;
	//	tc = Reader.nextInt();
		
		main_loop:
		for(int tn=0; tn<tc; tn++) {
			
			ans=0;
			bruh = false;
			n=tn+1;
			n = Reader.nextInt();
			int n1 = (int) n;	
		//	arrInp(n1);	
		//	k = Reader.nextInt();
			
			arr = new long[n1+1];
			
			for(int i=1; i<=n; i++) {
				int j=i;
				while(j<=n) {
					arr[j]++;
					j+=i;
				}
			}
			
			
			ans=0;
			for(int i=1; i<=n; i++) {
				ans  = ans + ans + arr[i] - arr[i-1];
				ans %= 998244353;
			}
			
		//	out.write(("YES").getBytes());
		//	out.write(("NO").getBytes());
			
			out.write((ans+" ").getBytes());
			out.write(("\n").getBytes());
			
		}
		
		out.flush();
		out.close();
		
	}

	private static void f(long x) {
		// TODO Auto-generated method stub
		ans %= 998244353;
	}
	
	
	
}