You are given integer n. You have to arrange numbers from 1 to 2n, using each of them exactly once, on the circle, so that the following condition would be satisfied:

For every n consecutive numbers on the circle write their sum on the blackboard. Then any two of written on the blackboard 2n numbers differ not more than by 1.

For example, choose n = 3. On the left you can see an example of a valid arrangement: 1 + 4 + 5 = 10, 4 + 5 + 2 = 11, 5 + 2 + 3 = 10, 2 + 3 + 6 = 11, 3 + 6 + 1 = 10, 6 + 1 + 4 = 11, any two numbers differ by at most 1. On the right you can see an invalid arrangement: for example, 5 + 1 + 6 = 12, and 3 + 2 + 4 = 9, 9 and 12 differ more than by 1.

<image>

Input

The first and the only line contain one integer n (1 ≤ n ≤ 10^5).

Output

If there is no solution, output "NO" in the first line. 

If there is a solution, output "YES" in the first line. In the second line output 2n numbers — numbers from 1 to 2n in the order they will stay in the circle. Each number should appear only once. If there are several solutions, you can output any of them.

Examples

Input


3


Output


YES
1 4 5 2 3 6 

Input


4


Output


NO

Note

Example from the statement is shown for the first example. 

It can be proved that there is no solution in the second example.

import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

public class Contest {

    final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    public static void main(String[] args) {
        new Contest().run();
    }

    void init() throws FileNotFoundException {
        if (ONLINE_JUDGE) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    public void run() {
        try {
            long t1 = System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2 = System.currentTimeMillis();
            System.err.println("Time(ms) = " + (t2 - t1));
        } catch (Exception e) {
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    class MyComparator implements Comparable<MyComparator> {

        int x;
        int y;

        public MyComparator(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public int compareTo(MyComparator a) {
            if (x == a.x) {
                return (y - a.y);
            }
            return x - a.x;
        }
    }

    public static boolean isPrime(int num) {
        if (num > 2 && num % 2 == 0) {
            //System.out.println(num + " is not prime");
            return false;
        }
        int top = (int) Math.sqrt(num) + 1;
        for (int i = 3; i < top; i += 2) {
            if (num % i == 0) {
                //System.out.println(num + " is not prime");
                return false;
            }
        }
        //System.out.println(num + " is prime");
        return true;
    }

    private static int lowerBound(int[] a, int low, int high, int element) {
        while (low < high) {
            int middle = low + (high - low) / 2;
            if (element > a[middle]) {
                low = middle + 1;
            } else {
                high = middle;
            }
        }
        return low;
    }

    private static int upperBound(int[] a, int low, int high, int element) {
        while (low < high) {
            int middle = low + (high - low) / 2;
            if (a[middle] > element) {
                high = middle;
            } else {
                low = middle + 1;
            }
        }
        return low;
    }

    public void solve() throws IOException {

        int num = readInt();
        if(num%2 == 0) {
            System.out.println("NO");
            return;
        } else {
            System.out.println("YES");
        }
        int[] array = new int[2 * num];
        int first = 1;
        // 0, n, n+1, 1, 2, n+2...
        int current = 1;
        for (int i = 0; i < num; i++) {
            array[i] = current;
            first++;
            if (first == 2) {
                first = 0;
                current += 2;
            }
            current++;
        }
        first = 0;
        current = 2;
        for (int i = num; i < 2 * num; i++) {
            array[i] = current;
            first++;
            if (first == 2) {
                first = 0;
                current += 2;
            }
            current++;
        }
        StringBuilder builder = new StringBuilder();
        for (int a : array) {
            builder.append(a).append(" ");
        }
        builder.setLength(builder.length() - 1);

        System.out.println(builder);

        //out.println("");
    }

    public void solveB() throws IOException {

        int num_a = readInt();
        int[] array = new int[num_a];
        for (int i = 0; i < num_a; i++) {
            array[i] = readInt();
        }

        long numbers = 0;
        int negative = 0;
        boolean nulls = false;
        for (int a : array) {
            //System.out.println(a);
            if (a > 0) {
                numbers += a - 1;
            } else if (a < 0) {
                numbers += -a - 1;
                negative++;
            } else {
                numbers += 1;
                nulls = true;
            }
        }
        if (negative % 2 == 0 || nulls) {

        } else {
            numbers += 2;
        }
        System.out.println(numbers);

        //out.println("");
    }

    public void solveA() throws IOException {

        int num_a = readInt();
        int[] array = new int[num_a];
        for (int i = 0; i < num_a; i++) {
            array[i] = readInt();
        }
        int num_b = readInt();
        int[] brray = new int[num_b];
        for (int i = 0; i < num_b; i++) {
            brray[i] = readInt();
        }

        for (int a : array) {
            for (int b : brray) {
                if (!isInArray(a + b, array) && !isInArray(a + b, brray)) {
                    System.out.println(a + " " + b);
                    return;
                }
            }
        }

        //out.println("");
    }

    private boolean isInArray(int num, int[] array) {
        for (int i : array) {
            if (num == i) {
                return true;
            }
        }
        return false;
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    private BigInteger lcm(BigInteger a, BigInteger b) {
        return a.multiply(b.divide(a.gcd(b)));
    }

}
