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:
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map.Entry;
import java.util.Random;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.Vector;



  public class solve {
	static PrintWriter out = new PrintWriter(System.out);
	static Scanner sc = new Scanner(System.in);
	
	 public static void main(String[] args) throws IOException  {
		 int n = sc.nextInt();
		 if(n==1 || n==2) {
			 out.println("No");
			 out.close();
			 return;
		 }
		 
		 out.println("Yes");
		 if(n%2==0) {
			 out.println(2+" "+(1+" "+n));
			 n--;
			 out.print(n-1+" ");
			 for(int i=2;i<=n;i++)
				 out.print(i+" ");
			 
		 }else {
			 out.println(1+" "+n);
			 n--;
			 out.print(n+" ");
			 for(int i=1;i<=n;i++)
				 out.print(i+" ");
			 
		 }
		 out.flush();
		 out.close();
		 
		 
		 
		 
	 }
	    
	     
	    

	
		
	}	
  class Parent
 {
     // private methods are not overridden
      void m1() { System.out.println("From parent m1()");}
      
     protected void m2() { System.out.println("From parent m2()"); }
 }
  
 class Child extends Parent
 {
     // new m1() method
     // unique to Child class
      
     // overriding method
     // with more accessibility
     @Override
     public void m2() { System.out.println("From child m2()");}
      
 }
	
	


    
	    
	    
	    

	
	
	
	















	













































































class Point{
	int x ; 
	int y ;
	 
	public Point(int x,int y) {
		this.x=x;
		this.y=y;
	}
	
	void print() {
		System.out.println(x+" "+y);
	}
	
	double slope() {
		return (double)y/x*1.0;
	}
	
	
	
}

class pair implements Comparable{
	int x ,y,z;
	pair(int x,int y,int z)
	{
		this.x=x;
		this.y=y;
		this.z=z;
	}
	@Override
	public int compareTo(Object arg0) {
		
		pair u =((pair)arg0);
		
		return -this.z+u.z;
	}
}
 	


	    
	    
	    



class Scanner {
	StringTokenizer st;
	BufferedReader br;

	public Scanner(InputStream s) {
		br = new BufferedReader(new InputStreamReader(s));
	}

	public Scanner(String f) throws FileNotFoundException {
		br = new BufferedReader(new FileReader(f));
	}

	public String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(next());
	}

	public String nextLine() throws IOException {
		return br.readLine();
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	public boolean ready() throws IOException {
		return br.ready();
	}

	public int[] nextIntArray(int n) throws IOException {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}

	public int[] nextIntArray1(int n) throws IOException {
		int[] a = new int[n + 1];
		for (int i = 1; i <= n; i++)
			a[i] = nextInt();
		return a;
	}

	public int[] shuffle(int[] a, int n) {
		int[] b = new int[n];
		for (int i = 0; i < n; i++)
			b[i] = a[i];
		Random r = new Random();
		for (int i = 0; i < n; i++) {
			int j = i + r.nextInt(n - i);
			int t = b[i];
			b[i] = b[j];
			b[j] = t;
		}
		return b;
	}

	public int[] nextIntArraySorted(int n) throws IOException {
		int[] a = nextIntArray(n);
		a = shuffle(a, n);
		Arrays.sort(a);
		return a;
	}

	public long[] nextLongArray(int n) throws IOException {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nextLong();
		return a;
	}

	public long[] nextLongArray1(int n) throws IOException {
		long[] a = new long[n + 1];
		for (int i = 1; i <= n; i++)
			a[i] = nextLong();
		return a;
	}

	public long[] nextLongArraySorted(int n) throws IOException {
		long[] a = nextLongArray(n);
		Random r = new Random();
		for (int i = 0; i < n; i++) {
			int j = i + r.nextInt(n - i);
			long t = a[i];
			a[i] = a[j];
			a[j] = t;
		}
		Arrays.sort(a);
		return a;
	}
}