Problem: You're given an integer n. For every integer i from 2 to n, assign a positive integer a_i such that the following conditions hold:

  * For any pair of integers (i,j), if i and j are coprime, a_i ≠ a_j. 
  * The maximal value of all a_i should be minimized (that is, as small as possible). 



A pair of integers is called [coprime](https://en.wikipedia.org/wiki/Coprime_integers) if their [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) is 1.

Input

The only line contains the integer n (2 ≤ n ≤ 10^5).

Output

Print n-1 integers, a_2, a_3, …, a_n (1 ≤ a_i ≤ n). 

If there are multiple solutions, print any of them.

Examples

Input


4


Output


1 2 1 

Input


3


Output


2 1

Note

In the first example, notice that 3 and 4 are coprime, so a_3 ≠ a_4. Also, notice that a=[1,2,3] satisfies the first condition, but it's not a correct answer because its maximal value is 3.

Solution (in JAVA):

Solution:
import java.io.BufferedWriter;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.io.OutputStreamWriter;
	import java.io.PrintWriter;
	import java.io.Writer;
	import java.util.Arrays;
	import java.util.InputMismatchException;
	import java.util.*;
	import java.io.*;
	import java.math.*;
	public class Main7{

	static class Pair
		{ 
			int x; 
			int y;
			public Pair(int x, int y) 
			{	 
				this.x = x; 
				this.y = y;
			}	 
		} 
		static class Pair1
		{
			String x;
			int y;
			int z;
			
		}
		static class Compare
		{ 
			static void compare(Pair arr[], int n) 
			{ 
				// Comparator to sort the pair according to second element 
				Arrays.sort(arr, new Comparator<Pair>() { 
					@Override public int compare(Pair p1, Pair p2) 
					{ 
						if(p1.x>p2.x)
						{
							return 1;
						}
						else if(p1.x<p2.x)
						{
							return -1;
						}
						else
						{
							if(p1.y>p2.y)
							{
								return 1;
							}
							else
								return -1;
						}
					} 
				}); 
			} 
		}
		
		static class pqcomparator implements Comparator<Pair>
		{
		                // for Ascending order of cgpa 
            public int compare(Pair s1, Pair s2) { 
                if (s1.x > s2.x) 
                    return -1; 
                else if (s1.x < s2.x) 
                    return 1; 
                return 0; 
                } 
        } 
		
		
		public static long pow(long a, long b)
		{
			long result=1;
			while(b>0)
			{
				if (b % 2 != 0)
				{
					result=(result*a)%mod;
					b--;
				} 
				a=(a*a)%mod;
				b /= 2;
			}   
			return result;
		}
		public static long fact(long num)
		{
					long value=1;
					int i=0;
					for(i=2;i<num;i++)
					{
						value=((value%mod)*i%mod)%mod;
					}
					return value;
				}
				public static long gcd(long a, long b)
				{
					if (a == 0)
						return b;
					return gcd(b%a, a);
				}
				
				public static long lcm(long a,long b)
				{
					return a * (b / gcd(a, b));
				}
				public static long sum(int h)
				{
					return (h*(h+1)/2);
				}
				/*public static void dfs(int parent,boolean[] visited)
				{
					TreeSet<Integer> arr=new TreeSet<Integer>();
					arr=graph.get(parent);
					visited[parent]=true;
					if(a[parent]==1)
					{
						flag=1;
					}
					if(a[parent]==2)
					{
						flag1=1;
					}
					if(flag==1 && flag1==1)
					{
						return;
					}
					Iterator itr=arr.iterator();
					while(itr.hasNext())
					{
						int num=(int)itr.next();
						if(visited[num]==false)
						{
							dfs(num,visited);
						}
					}
					
				}*/
			//	static int flag1=0;
				static int[] dis;
				static long mod=64735492;
				static ArrayList<ArrayList<Integer>> graph;
				
				public static void bfs(int num,int size)
				{
					boolean[] visited=new boolean[size+1];
					Queue<Integer> q=new LinkedList<>();
					q.add(num);
					ans[num]=0;
					visited[num]=true;
					while(!q.isEmpty())
					{
						int x=q.poll();
						ArrayList<Integer> al=graph.get(x);
						for(int i=0;i<al.size();i++)
						{
							int y=al.get(i);	
							if(visited[y]==false)
							{
								q.add(y);
								visited[y]=true;
								ans[y]=ans[x]+1;
							}
							else
							{
								ans[y]=Math.min(ans[y],ans[x]+1);
							}
						}
						
					}
				}
				static int[] ans;
				
				
				
				
				
				
				
				
				
				
				
			//	static int[] a;			  
				
				public static long[] sort(long[] a)
				{
					int n=a.length;
					ArrayList<Long> ar=new ArrayList<>();
					for(int i=0;i<a.length;i++)
					{
						ar.add(a[i]);
					}
					Collections.sort(ar);
					for(int i=0;i<n;i++)
					{
						a[i]=ar.get(i);
					}
					return a;
				}
			//	static int flag=1;
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
				public static void main(String args[])throws IOException
				{
				//	InputReader in=new InputReader(System.in);
				//	OutputWriter out=new OutputWriter(System.out);
				//	long a=pow(26,1000000005);
				    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
					ArrayList<Integer> ar4=new ArrayList<>();
					ArrayList<Integer> ar2=new ArrayList<>();
					
					ArrayList<Integer> ar1=new ArrayList<>();
			//		TreeSet<Integer> ts=new TreeSet<>();
			//		TreeSet<Long> ts1=new TreeSet<>();
				//	HashMap<Long,Integer> hash=new HashMap<>();
					HashMap<Integer,Integer> odd=new HashMap<Integer,Integer>();
					HashMap<Long,Integer> hash2=new HashMap<Long,Integer>();
				/*	boolean[] prime=new boolean[100001];
					for(int i=2;i*i<=100000;i++)
					{
						if(prime[i]==false)
						{
							for(int j=2*i;j<=100000;j+=i)
							{
								prime[j]=true;
							}
						}
					}*/
					int n=i();
					int[] a=new int[n+1];
					int count=0;
					boolean[] prime=new boolean[n+1];
					
					for(int i=2;i<=n;i++)
					{
						if(prime[i]==false)
						{
							count++;
							a[i]=count;
							for(int j=2*i;j<=n;j+=i)
							{
								prime[j]=true;
								if(a[j]==0)
									a[j]=count;
							}
						}
					}
					for(int i=2;i<=n;i++)
					{
						System.out.print(a[i]+" ");
					}
				}
				
				
				
				
				/**/
				static InputReader in=new InputReader(System.in);
					static OutputWriter out=new OutputWriter(System.out);
					public static long l()
					{
						String s=in.String();
						return Long.parseLong(s);
					}
					public static void pln(String value)
					{
						System.out.println(value);
					}
					public static int i()
					{
						return in.Int();
					}
					public static String s()
					{
						return in.String();
					}
		}
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			class InputReader {
				 
				private InputStream stream;
				private byte[] buf = new byte[1024];
				private int curChar;
				private int numChars;
				private SpaceCharFilter filter;
			 
				public InputReader(InputStream stream) {
					this.stream = stream;
				}
			 
				public int read() {
					if (numChars== -1)
						throw new InputMismatchException();
					if (curChar >= numChars) {
						curChar = 0;
						try {
							numChars = stream.read(buf);
						} catch (IOException e) {
							throw new InputMismatchException();
						}
						if (numChars <= 0)
							return -1;
					}
					return buf[curChar++];
				}
			 
				public int Int() {
					int c = read();
					while (isSpaceChar(c))
						c = read();
					int sgn = 1;
					if (c == '-') {
						sgn = -1;
						c = read();
					}
					int res = 0;
					do {
						if (c < '0' || c > '9')
							throw new InputMismatchException();
						res *= 10;
						res += c - '0';
						c = read();
					} while (!isSpaceChar(c));
					return res * sgn;
				}
			 
				public String String() {
					int c = read();
					while (isSpaceChar(c))
						c = read();
					StringBuilder res = new StringBuilder();
					do {
						res.appendCodePoint(c);
						c = read();
					} while (!isSpaceChar(c));
					return res.toString();
				}
			 
				public boolean isSpaceChar(int c) {
					if (filter != null)
						return filter.isSpaceChar(c);
					return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
				}
			 
				public String next() {
					return String();
				}
			 
				public interface SpaceCharFilter {
					public boolean isSpaceChar(int ch);
				}
			}
			 
			class OutputWriter {
				private final PrintWriter writer;
			 
				public OutputWriter(OutputStream outputStream) {
					writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
				}
			 
				public OutputWriter(Writer writer) {
					this.writer = new PrintWriter(writer);
				}
			 
				public void print(Object...objects) {
					for (int i = 0; i < objects.length; i++) {
						if (i != 0)
							writer.print(' ');
						writer.print(objects[i]);
					}
				}
			 
				public void printLine(Object...objects) {
					print(objects);
					writer.println();
				}
			 
				public void close() {
					writer.close();
				}
			 
				public void flush() {
					writer.flush();
				}
			 
				}
			 
				class IOUtils {
			 
				public static int[] readIntArray(InputReader in, int size) {
					int[] array = new int[size];
					for (int i = 0; i < size; i++)
						array[i] = in.Int();
					return array;
				}
			 
				}