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.awt.List;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.stream.Collectors;


public class wef {
	public static class FastReader {
		BufferedReader br;
		StringTokenizer st;
		//it reads the data about the specified point and divide the data about it ,it is quite fast
		//than using direct 
 
		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}
 
		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception r) {
					r.printStackTrace();
				}
			}
			return st.nextToken();
		}
 
		int nextInt() {
			return Integer.parseInt(next());//converts string to integer
		}
 
		double nextDouble() {
			return Double.parseDouble(next());
		}
 
		long nextLong() {
			return Long.parseLong(next());
		}
 
		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (Exception r) {
				r.printStackTrace();
			}
			return str;
		}
	}
	static class Pair implements Comparable<Pair>{
	    int x;int y;
	    Pair(int x,int y){
	        this.x=x;
	        this.y=y;
	      //  this.i=i;
	    }
		@Override
		public int compareTo(Pair o) {
			// TODO Auto-generated method stub
			return y-o.y;
			
		}
	}
	
	public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
    
	 static int lowerBound(ArrayList<Integer> list, int length, long val) {
        int low = 0;
        int high = length;
        while (low < high) {
            final int mid = (low + high) / 2;
            if (val <= list.get(mid)) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }
        return low;
    }
	  class ArrayListComparator<Integer extends Comparable<Integer>> implements Comparator<ArrayList<Integer>> {

		  public int compare1(ArrayList<Integer> o1, ArrayList<Integer> o2) {
		    for (int i = 0; i < Math.min(o1.size(), o2.size()); i++) {
		      int c = o1.get(i).compareTo(o2.get(i));
		      if (c != 0) {
		        return c;
		      }
		    }
		    return 0;
		  }

		@Override
		public int compare(ArrayList<Integer> o1, ArrayList<Integer> o2) {
			// TODO Auto-generated method stub
			return 0;
		}

		}
	  public static String frac(int numerator, int denominator) {
	        long a=numerator,b=denominator;
	        if(a%b==0) return String.valueOf(a/b);
	        TreeMap<Long,Integer> map=new TreeMap<>();
	        StringBuilder res=new StringBuilder();
	        if((a>0&&b<0)||(a<0&&b>0)) res.append("-");
	        a=Math.abs(a);
	        b=Math.abs(b);
	        res.append(a/b+".");
	        a=(a%b)*10;
	        while(!map.containsKey(a)){
	            map.put(a,res.length());
	            res.append(String.valueOf(a/b));
	            a=(a%b)*10;
	            if(a==0) return res.toString();
	        }
	        System.out.println(map.keySet());
	        System.out.println(map.values());
	        return res.insert(map.get(a),"(").append(")").toString();
	    }

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
FastReader in=new FastReader();
ArrayList<Integer>list1=new ArrayList<Integer>();
ArrayList<Integer>list2=new ArrayList<Integer>();
TreeMap<Integer,Integer> pos=new TreeMap<Integer,Integer>();
TreeMap<Integer,Integer> neg=new TreeMap<Integer,Integer>();
HashSet<Integer>set=new HashSet<Integer>();

int n=in.nextInt();
if(n%2==1)
{
	System.out.println("YES");
	list1.add(1);
	for(int i=2;i<=2*n;i+=4)
	{
		list2.add(i);
		if(i+1<2*n)
		list2.add(i+1);
	}
	for(int i=4;i<=2*n;i+=4)
	{

		list1.add(i);
		if(i+1<2*n)
		list1.add(i+1);
	}
    for(int h:list1)
    	System.out.print(h+" ");
    for(int h:list2)
    	System.out.print(h+" ");

}
else
	System.out.println("NO");


	}
		}
