Problem: Find out if it is possible to partition the first n positive integers into two non-empty disjoint sets S_1 and S_2 such that:

gcd(sum(S_1), sum(S_2)) > 1 

Here sum(S) denotes the sum of all elements present in set S and gcd means the[greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).

Every integer number from 1 to n should be present in exactly one of S_1 or S_2.

Input

The only line of the input contains a single integer n (1 ≤ n ≤ 45 000)

Output

If such partition doesn't exist, print "No" (quotes for clarity).

Otherwise, print "Yes" (quotes for clarity), followed by two lines, describing S_1 and S_2 respectively.

Each set description starts with the set size, followed by the elements of the set in any order. Each set must be non-empty.

If there are multiple possible partitions — print any of them.

Examples

Input

1


Output

No

Input

3


Output

Yes
1 2
2 1 3 

Note

In the first example, there is no way to partition a single number into two non-empty sets, hence the answer is "No".

In the second example, the sums of the sets are 2 and 4 respectively. The gcd(2, 4) = 2 > 1, hence that is one of the possible answers.

Solution (in JAVA):

Solution:
//package practice_codes;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.stream.Collectors;

//import codes.Reference.i;

public class NonCoprimePartition {
	protected NonCoprimePartition()
	{
		 
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		
		long t;
		
		t = i.l();
		ArrayList<Integer> al = new ArrayList<Integer>();
		StringBuilder s = new StringBuilder(" 1");
		for(int i=2;i<=t;i++)
		{
			if((new BigInteger(i+"")).isProbablePrime(1))
			{
				al.add(i);
			}
			s.append(" "+i);
		}
		int ans=0;
		if(t>1)
			for(int i=0;i<al.size();i++)
			{
				long eq = (t*(t+1)/2)-al.get(i);
				//System.out.println(eq);
				if(eq%al.get(i)==0)
				{
					ans=al.get(i);
				}
			}
		
		
		if(ans==0)
		{
			System.out.println("No");
		}
		else
		{
			System.out.println("Yes");
			System.out.println("1 "+ans);
			System.out.println((t-1)+s.delete(s.indexOf(ans+""),s.indexOf(ans+"")+(ans+"").length()).toString());
		}
	}
	static private class i
	{
		//input taking methods
		static BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
		
		public static String[] sa()
	    {
	    	try {
				return b.readLine().split(" ");
			} catch (IOException e) {
				
				e.printStackTrace();
			}
	    	return null;
	    }
		
		public static long l()
		{
			try {
				return Long.parseLong(b.readLine());
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	    	return 0;
		}
		
		public static String s()
		{
			try {
				return b.readLine();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	    	return null;
		}
		
		public static long[] la()
		{
			return Arrays.stream(sa()).parallel().mapToLong(Long::parseLong).toArray();
		}
		
		public static ArrayList<Long> lal()
		{
			return (ArrayList<Long>)Arrays.stream(la()).parallel().boxed().collect(Collectors.toList());
		}
		public static StringBuilder so(String a)
		{
			return new StringBuilder(a);
		}

	}
	/*
	 HashMap<String,Integer> map = new HashMap<String,Integer>();
	 if(!map.containsKey(key))
	 {
	 	map.put(key,value);
	 }
	 else
	 {
	 	map.replace(key,map.get(key));
	 } 
	 */
	static private class algo{
		
		public static boolean isPrime(int a)
		{
			for(int i=2;i<a;i++)
			{
				if(a%i==0)
				{
					return false;
				}
			}
			return true;
		}
		static String reverse(String s)
		{
			return i.so(s).reverse().toString();
		}
		static String replace(String s,int st,int e,String repl)
		{
			return i.so(s).replace(st, e, repl).toString();
		}
		static String insert(String s,int pos,String ins)
		{
			return i.so(s).insert(pos, ins).toString();
		}
		static long sod(long n) 
	    { 
	        long sum; 
	        for (sum = 0; n > 0; sum += n % 10, 
	                                  n /= 10); 
	  
	        return sum; 
	    } 

		static int gcd(int a, int b) 
	    { 
			if (a == 0) 
				return b;  
			return gcd(b % a, a);  
	    } 
		
	    static int lcm(int a, int b) 
	    { 
	        return (a*b)/gcd(a, b); 
	    }
	    static long sumOfSquares(long[] a)
	    {
	    	
	    	return (long) Arrays.stream(a).mapToDouble(i->i*i).sum();
	    }
	    //use of filter
	    //Arrays.stream(a).filter(k->k==1).count();
	    //            array       variable->condition returning boolean  . lot fof functionsa re available
	    
	    static String[] generateBinSeq(int cnt)
	    {
	    	int loopvar=(int) Math.pow(2, cnt);
			String a[][] = new String[cnt+1][loopvar];
			
			for(int i=1;i<=cnt;i++)
			{
				int temp = (int) Math.pow(2, i);
				for(int j=0;j<temp;j++)
				{
					if(i==1 || i==2)
					{
						if(i==1)
						{
							a[i][0]="0";
							a[i][1]="1";
							continue;
						}
						else
						{
							a[2][0]="00";a[2][1]="01";a[2][2]="10";a[2][3]="11";
							continue;
						}
					}
					else
					{
						if(j<(temp/2))
						{
							a[i][j] = a[i-1][j]+"0"; 
						}
						else
						{
							a[i][j] = a[i-1][j%((temp+1)/2)]+"1";
						}
				
					}
						
				}
			}
	    
			return a[cnt];
	    }
	    
	 // USe this snippet for calling
//	    int ndx = algo.bs(a,key,0,a.length-1);
//		if(ndx<0)
//			ndx=0;
//		if(ndx==a.length)
//			ndx=a.length-1;

	    static public int bs(long a[],long key,int s,int e)
		{
			int m = (s+e)/2;
			if(s>e)
				return s;
				
			if(a[m]==key)
				return m;
			else if(a[m]>key)
				return bs(a,key,s,m-1);
			else
				return bs(a,key,m+1,e);
			
		}
	 // USe this snippet for calling
//	    int ndx = bsa(al,key,0,al.size()-1);
//		if(ndx<0)
//			ndx=0;
//		if(ndx==al.size())
//			ndx=al.size()-1;
	    static public int bsa(ArrayList<Long> a,long key,int s,int e)
		{
			int m = (s+e)/2;
			if(s>e)
				return s;
				
			if(a.get(m)==key)
				return m;
			else if(a.get(m)>key)
				return bsa(a,key,s,m-1);
			else
				return bsa(a,key,m+1,e);
			
		}
	    static public long fact(long a)
	    {
	    	long i,fact=1;  
	    	 long number=a;   
	    	  for(i=1;i<=number;i++){    
	    	      fact=fact*i;    
	    	  } 
	    	  return fact;
	    }
	    
	}
}