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.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Map.Entry;

import static java.lang.Character.isSpaceChar;

public class codeChef
{
    static int mod1 = (int) (1e9 + 7);

    static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do
            {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }

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

    static Set<Long> divisor(Set<Long> set0, long num0)
    {
        if (num0 != 1)
        {
            set0.add(num0);
        }
        for (long i = 2; i * i <= num0; i++)
        {
            while (num0 % i == 0)
            {
                set0.add(i);
                num0 /= i;
            }
        }
        return set0;
    }
    static long primeDivisor(long num0)
    {
        long maxPrime1=1;
        for (long i = 2; i * i <= num0; i++)
        {
            while (num0 % i == 0)
            {
                boolean b1=primeCheck(i);
                if(b1)
                {
                    if(maxPrime1<i)
                    {
                        maxPrime1=i;
                    }
                }
                boolean b2=primeCheck(num0/i);
                if(b2)
                {
                    if(maxPrime1<num0/i)
                    {
                        maxPrime1=num0/i;
                    }
                }
                num0/=i;
            }
        }
        if(maxPrime1==1)
        {
            maxPrime1=num0;
        }
        return maxPrime1;
    }

    static long power2(long x, long y, long p)
    {
        long res = 1;
        x = x % p;
        while (y > 0)
        {
            if ((y & 1) == 1)
            {
                BigInteger res0 = BigInteger.valueOf(res);
                res0 = res0.multiply(BigInteger.valueOf(x));
                res0 = res0.mod(BigInteger.valueOf(p));
                String str0 = res0.toString();
                res = Long.parseLong(str0);
            }
            y = y >> 1;
            BigInteger res00 = BigInteger.valueOf(x);
            res00 = res00.multiply(BigInteger.valueOf(x));
            res00 = res00.mod(BigInteger.valueOf(p));
            String ans00 = res00.toString();
            x = Long.parseLong(ans00);

        }
        return res;
    }

    static long GCD(long num0, long num00)
    {
        BigInteger big1 = BigInteger.valueOf(num0);
        BigInteger big2 = BigInteger.valueOf(num00);
        big1 = big1.gcd(big2);
        long num000 = Long.parseLong(big1.toString());
        return num000;
    }

    static boolean primeCheck(long num0)
    {
        int num01 = (int) (Math.sqrt(num0)) + 1;
        boolean b1 = true;
        me1:
        for (int i = 2; i < num01; i++)
        {
            if (num0 % i == 0)
            {
                b1 = false;
                break me1;
            }
        }
        return b1;
    }

    static double getTime()
    {
        return System.nanoTime();
    }

    static int countSum1(int len0, int[] arr0, int sum0)
    {
        HashMap<Integer, Integer> map1 = new HashMap<>();

        for (int i = 0; i < len0; i++)
        {
            if (!map1.containsKey(arr0[i]))
            {
                map1.put(arr0[i], 0);
            }
            map1.put(arr0[i], map1.get(arr0[i]) + 1);
        }
        int count0 = 0;
        for (int i = 0; i < len0; i++)
        {
            if (map1.get(sum0 - arr0[i]) != null)
                count0 += map1.get(sum0 - arr0[i]);
            if (sum0 - arr0[i] == arr0[i])
                count0--;
        }
        int num7 = count0 / 2;
        return num7;
    }

    static int lastNum1(int num0)
    {
        String str1 = String.valueOf(num0);
        int num00 = num0;
        while (str1.length() > 1)
        {
            num00 = 0;
            for (int i = 0; i < str1.length(); i++)
            {
                num00 = num00 + Character.getNumericValue(str1.charAt(i));
            }
            str1 = String.valueOf(num00);
        }
        return num00;
    }

    static String sortedString(String str01)
    {
        char[] chrArr1=str01.toCharArray();
        Arrays.sort(chrArr1);
        str01="";
        for(int i=0;i<chrArr1.length;i++)
        {
            str01=str01+chrArr1[i];
        }
        return str01;
    }

    static String reverse(String str0,int len1,String str01)
    {
        if(len1==-1)
            return str01;
        else
        {
            str01=str01+ str0.charAt(len1);
            len1--;
            return reverse(str0,len1,str01);
        }
    }



    public static void main(String[] args) throws IOException
    {

        //Reader r = new Reader();
        Scanner r = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
        //Scanner r=new Scanner(System.in);
        OutputWriter2 out1 = new OutputWriter2(System.out);
        int num1=r.nextInt();
        String ans1="No";
        long num2=(num1*(num1+1))/2;
        long sum1=0;
        int pos1=0;
        boolean bool1=false;
        me1: for(int i=1;i<num2;i++)
        {
            sum1+=i;
            num2-=i;
            long num3=GCD(num2,sum1);
            if(num3>1)
            {
                pos1=i;
                ans1="Yes";
                bool1=true;
                break me1;
            }
        }
        if(bool1)
        {
            out1.print(ans1+"\n");
            out1.print(pos1+" ");
            for(int i=1;i<pos1+1;i++)
            {
                out1.print(i+" ");
            }
            int num5=num1-pos1;
            out1.print("\n");
            out1.print(num5+" ");
            for(int i=pos1+1;i<num1+1;i++)
            {
                out1.print(i+" ");
            }
        }
        else
        {
            out1.print(ans1+"");
        }
        r.close();
        out1.close();
    }
}

class circulaLinkedList
{
    Node head;

    static class Node
    {
        int data;
        Node next;


        Node(int d)
        {
            data = d;
            next = null;
        }
    }

    public void print()
    {
        Node ptr1 = head;
        while (ptr1 != null)
        {
            System.out.print(ptr1.data + " ");
            ptr1 = ptr1.next;
        }
    }
}

class OutputWriter2
{
    BufferedWriter writer;

    public OutputWriter2(OutputStream stream)
    {
        writer = new BufferedWriter(new OutputStreamWriter(stream));
    }

    public void print(int i) throws IOException
    {
        writer.write(i + "");
    }

    public void println(int i) throws IOException
    {
        writer.write(i + "\n");
    }

    public void print(String s) throws IOException
    {
        writer.write(s + "");
    }

    public void println(String s) throws IOException
    {
        writer.write(s + "\n");
    }

    public void print(char[] c) throws IOException
    {
        writer.write(c);
    }

    public void close() throws IOException
    {
        writer.close();
    }
}