Problem: Mahmoud and Ehab are on the third stage of their adventures now. As you know, Dr. Evil likes sets. This time he won't show them any set from his large collection, but will ask them to create a new set to replenish his beautiful collection of sets.

Dr. Evil has his favorite evil integer x. He asks Mahmoud and Ehab to find a set of n distinct non-negative integers such the bitwise-xor sum of the integers in it is exactly x. Dr. Evil doesn't like big numbers, so any number in the set shouldn't be greater than 106.

Input

The only line contains two integers n and x (1 ≤ n ≤ 105, 0 ≤ x ≤ 105) — the number of elements in the set and the desired bitwise-xor, respectively.

Output

If there is no such set, print "NO" (without quotes).

Otherwise, on the first line print "YES" (without quotes) and on the second line print n distinct integers, denoting the elements in the set is any order. If there are multiple solutions you can print any of them.

Examples

Input

5 5


Output

YES
1 2 4 5 7

Input

3 6


Output

YES
1 2 5

Note

You can read more about the bitwise-xor operation here: <https://en.wikipedia.org/wiki/Bitwise_operation#XOR>

For the first sample <image>.

For the second sample <image>.

Solution (in JAVA):

Solution:


 
    	        			/*
 * Author- Priyam Vora
 * BTech 2nd Year DAIICT
 */
     
     
        		    import java.awt.Checkbox;
import java.awt.Point;
import java.io.*;
        		    import java.math.*;
        		    import java.util.*;
import java.util.Map.Entry;

import javax.print.attribute.SetOfIntegerSyntax;
import javax.swing.plaf.FontUIResource;
    	     
        		    public class Main{
        		  	private static InputStream stream;
        		    	private static byte[] buf = new byte[1024];
        		    	private static int curChar;
        		    	private static int numChars;
        		    	private static SpaceCharFilter filter;
        		    	private static PrintWriter pw;
        		    	private static long count = 0,mod=1000000007;
        		    //	private static TreeSet<Integer> ts=new TreeSet[200000];
public final static int INF = (int) 1E9;

public static void main(String args[]) {
	InputReader(System.in);
	pw = new PrintWriter(System.out); 
    new Thread(null ,new Runnable(){
       public void run(){
           try{
               solve();
               
               pw.close();
           } catch(Exception e){
               e.printStackTrace();
           }
       }
   },"1",1<<26).start();
   }
    static StringBuilder sb;
    public static void test(){
    	 sb=new StringBuilder();
    	int t=nextInt();
    	while(t-->0){
    		
    		solve();
    		//pw.println();
    		//sb.append("\n");
    	}
    	pw.println(sb);
    }
    public static long pow(long n, long p,long mod) {
		if(p==0)
			return 1;
		if(p==1)
			return n%mod;
		if(p%2==0){
			long temp=pow(n, p/2,mod);
		return (temp*temp)%mod;
		}else{
			 	long temp=pow(n,p/2,mod);
			 	temp=(temp*temp)%mod;
			 	return(temp*n)%mod;
			 	
		}
	}
    public static long pow(long n, long p) {
		if(p==0)
			return 1;
		if(p==1)
			return n;
		if(p%2==0){
			long temp=pow(n, p/2);
		return (temp*temp);
		}else{
			 	long temp=pow(n,p/2);
			 	temp=(temp*temp);
			 	return(temp*n);
			 	
		}
	}
    public static void Merge(long a[],int p,int r){
        if(p<r){
            int q = (p+r)/2;
            Merge(a,p,q);
            Merge(a,q+1,r);
            Merge_Array(a,p,q,r);
        }
    }
    public static void Merge_Array(long a[],int p,int q,int r){
       long b[] = new long[q-p+1];
        long c[] = new long[r-q];
        for(int i=0;i<b.length;i++)
            b[i] = a[p+i];
        for(int i=0;i<c.length;i++)
            c[i] = a[q+i+1];
        int i = 0,j = 0;
        for(int k=p;k<=r;k++){
            if(i==b.length){
                a[k] = c[j];
                j++;
            }
            else if(j==c.length){
                a[k] = b[i];
                i++;
            }
            else if(b[i]<c[j]){
                a[k] = b[i];
                i++;
            }
            else{
                a[k] = c[j];
                j++;
            }
        }
    }
    
  
	public static long gcd(long x, long y) {
		if (x == 0)
			return y;
		else
			return gcd( y % x,x);
	}	
	
	public static boolean isPrime(int n) {
		if (n <= 1)
			return false;
		if (n <= 3)
			return true;
 
		if (n % 2 == 0 || n % 3 == 0)
			return false;
 
		for (int i = 5; i * i <= n; i = i + 6)
			if (n % i == 0 || n % (i + 2) == 0)
				return false;
 
		return true;
	}
	
        static LinkedList<Integer> adj[];
        static boolean Visited[];
        static HashSet<Integer> exc;
        static long oddsum[]=new long[1000001];
        static long co=0,ans=0;
    
    	private static void buildgraph(int n){
    		adj=new LinkedList[n+1];
    		Visited=new boolean[n+1];
    		levl=new int[n+1];
    		
    		for(int i=0;i<=n;i++){
    			adj[i]=new LinkedList<Integer>();
    		
    		}


    	}
      
       
        static int[] levl;
        static int[] eat;
        static int n,m;
        static int price[];
        //ind frog crab
    
        public static void solve(){

        	int n=nextInt();
        	int k=nextInt();
        	if(n==2 && k==0){
        		pw.println("NO");
        		return;
        	}
        	
        	int start=1;
        	sb=new StringBuilder();
        	if(n==6&&k==0)
        	{
        		pw.println("YES");
        		pw.println(1+" "+2+" "+3+" "+4+" "+8+" "+12);
        		return;
        	}
        	for(int i=2;i<=1000000;i++)
        	{
        		if(i+3<=1000000)
        		{
        			int xor=i^(i+1)^(i+2)^(i+3);
        			if(xor==0)
        			{
        				start=i+3;
        			}
        		}
        	}
        	
        	int rem=n%4;
        	if(rem==0){
        		for(int i=0;i<n-4;i++)
        		{
        		     
        			sb.append(start+" ");
        			start--;
        		}
        		if(k>3)
        		sb.append(k+" 1 2 3");
        		else
        			sb.append(4+" "+8+" "+12+" "+k);
        	}
        	if(rem==1){
        		for(int i=0;i<n-1;i++){
        			if(k==start){
        				start--;
        			}
        			sb.append(start+" ");
        			start--;
        		}
        		sb.append(k);
        	}
        	if(rem==2){
        		HashSet<Integer> hs=new HashSet<Integer>();
        		for(int i=0;i<n-2;i++){
        			sb.append(start+" ");
        			start--;
        			
        		}
        		
        		sb.append(0+" "+k);
        		
        	}
        	if(rem==3){
        		n-=3;
        		for(int i=0;i<n;i++){
        			sb.append(start+" ");
        			start--;
        		}
        	
        		for(int i=0;i<=1000000;i++)
        		{
        			int x=i^(i+1)^(i+2)^(i+3);
        			if(x==0)
        			{
        			if(i==k){sb.append((i+1)+" "+(i+2)+" "+(i+3));break;}
        			else	if(1+i==k){sb.append((i)+" "+(i+2)+" "+(i+3));break;}
        			else if(i+2==k){sb.append((i+1)+" "+(i)+" "+(i+3));break;}
        			else	if(i+3==k){sb.append((i+1)+" "+(i+2)+" "+(i));
        				break;}
        			}
        		}
        	}
        	pw.println("YES");
        	pw.println(sb);
    }
       
        static int col[];
    public static boolean isVowel(char c){
    	if(c=='a' || c=='e'||c=='i' || c=='o' || c=='u')
    		return true;
    	return false;
    }
static int no_vert=0;

  private static void dfs(int start){
	  Visited[start]=true;
	 no_vert++;
	 
	  for(int i:adj[start]){
		  if(!Visited[i])
			  {
			  col[i]=col[start]^1;
			  dfs(i);
			  
			  }
	  }
	  
	  
  }
    
    public static String reverseString(String s) {
		StringBuilder sb = new StringBuilder(s);
		sb.reverse();
		return (sb.toString());
	}
    
  /*  
   private static void BFS(int sou){
    	Queue<Integer> q=new LinkedList<Integer>();
    	q.add(sou);
    	Visited[sou]=true;
    	levl[sou]=0;
    	while(!q.isEmpty()){
    		int top=q.poll();
    		
    		for(int i:adj[top]){
    			//pw.println(i+" "+top);
			if(!Visited[i])
			{
				
				q.add(i);
				levl[i]=levl[top]+1;
			}
			
			Visited[i]=true;
			
			}
		}
	}*/
	



    		      static int indeg[];
    		   /* private static void kahn(int n){
    		    	
    		    	PriorityQueue<Integer> q=new PriorityQueue<Integer>();
    				for(int i=1;i<=n;i++){
    					if(indeg[i]==0){
    						q.add(i);
    					}
    				}
    				while(!q.isEmpty()){
    					int top=q.poll();
    					st.push(top);
    					for(Node i:adj[top]){
    						indeg[i.to]--;
    						if(indeg[i.to]==0){
    							q.add(i.to);
    						}
    					}
    				}
    		    }
    		        
    		        static int state=1;
    		        static long no_exc=0,no_vert=0;
    		      static Stack<Integer> st;
    		      static HashSet<Integer> inset;
    		     /*   private static void topo(int curr){
    		        	
    		        	Visited[curr]=true;
    		        	inset.add(curr);
    		        	for(int x:adj[curr]){
    		        		if(adj[x].contains(curr) || inset.contains(x)){
    		        			state=0;
    		        			return;
    		        		}
    		        		if(state==0)
    		        			return;
    		        		
    		        	}
    		        	st.push(curr);
    		        	
    		        	inset.remove(curr);
    		        }*/
    		        static HashSet<Integer> hs;
    		       
    		     
    		     	static boolean prime[];
					static int spf[];
					public static void sieve(int n){
						prime=new boolean[n+1];
						spf=new int[n+1];
						
						Arrays.fill(spf, 1);
						Arrays.fill(prime, true);
					prime[1]=false;
						spf[2]=2;
						
					for(int i=4;i<=n;i+=2){
						spf[i]=2;
					}
					for(int i=3;i<=n;i+=2){
						if(prime[i]){
							spf[i]=i;
							for(int j=2*i;j<=n;j+=i){
								
								prime[j]=false;
							if(spf[j]==1){
								spf[j]=i;
							}
							}
						}
					}
					
						
					}
    		     	
    		    	// To Get Input
// Some Buffer Methods
 
    		     	public static void sort(long a[]){
    		     		Merge(a, 0, a.length-1);
    		     	}
    		    	public static void InputReader(InputStream stream1) {
    		    		stream = stream1;
    		    	}
 
    		    	private static boolean isWhitespace(int c) {
    		    		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    		    	}
 
    		    	private static boolean isEndOfLine(int c) {
    		    		return c == '\n' || c == '\r' || c == -1;
    		    	}
 
    		    	private static int read() {
    		    		if (numChars == -1)
    		    			throw new InputMismatchException();
    		    		if (curChar >= numChars) {
    		    			curChar = 0;
    		    			try {
    		    				numChars = stream.read(buf);
    		    			} catch (IOException e) {
    		    				throw new InputMismatchException();
    		    			}
    		    			if (numChars <= 0)
    		    				return -1;
    		    		}
    		    		return buf[curChar++];
    		    	}
 
    		    	private static int nextInt() {
    		    		int c = read();
    		    		while (isSpaceChar(c))
    		    			c = read();
    		    		int sgn = 1;
    		    		if (c == '-') {
		sgn = -1;
		c = read();
	}
	int res = 0;
	do {
		if (c < '0' || c > '9')
			throw new InputMismatchException();
		res *= 10;
		res += c - '0';
    		    			c = read();
    		    		} while (!isSpaceChar(c));
    		    		return res * sgn;
    		    	}
 
    		    	private static long nextLong() {
    		    		int c = read();
    		    		while (isSpaceChar(c))
    		    			c = read();
    		    		int sgn = 1;
    		    		if (c == '-') {
		sgn = -1;
		c = read();
	}
	long res = 0;
	do {
		if (c < '0' || c > '9')
			throw new InputMismatchException();
		res *= 10;
		res += c - '0';
    		    			c = read();
    		    		} while (!isSpaceChar(c));
    		    		return res * sgn;
    		    	}
 
    		    	private static String nextToken() {
    		    		int c = read();
    		    		while (isSpaceChar(c))
    		    			c = read();
    		    		StringBuilder res = new StringBuilder();
    		    		do {
    		    			res.appendCodePoint(c);
    		    			c = read();
    		    		} while (!isSpaceChar(c));
    		    		return res.toString();
    		    	}
 
    		    	private static String nextLine() {
    		    		int c = read();
    		    		while (isSpaceChar(c))
    		    			c = read();
    		    		StringBuilder res = new StringBuilder();
    		    		do {
    		    			res.appendCodePoint(c);
    		    			c = read();
    		    		} while (!isEndOfLine(c));
    		    		return res.toString();
    		    	}
 
    		    	private static int[] nextIntArray(int n) {
    		    		int[] arr = new int[n];
    		    		for (int i = 0; i < n; i++) {
    		    			arr[i] = nextInt();
    		    		}
    		    		return arr;
    		    	}
 
    		    	private static long[][] next2dArray(int n, int m) {
    		    		long[][] arr = new long[n][m];
    		    		for (int i = 0; i < n; i++) {
    		    			for (int j = 0; j < m; j++) {
    		    				arr[i][j] = nextLong();
    		    			}
    		    		}
    		    		return arr;
    		    	}
    		    	private static char[][] nextCharArray(int n,int m){
    		    		char [][]c=new char[n][m];
    		    		for(int i=0;i<n;i++){
    		    			String s=nextLine();
    		    			for(int j=0;j<s.length();j++){
    		    				c[i][j]=s.charAt(j);
    		    			}
    		    		}
    		    		return c;
    		    	}
 
    		    	private static long[] nextLongArray(int n) {
    		    		long[] arr = new long[n];
    		    		for (int i = 0; i < n; i++) {
    		    			arr[i] = nextLong();
    		    		}
    		    		return arr;
    		    	}
 
    		    	private static void pArray(int[] arr) {
    		    		for (int i = 0; i < arr.length; i++) {
    		    			pw.print(arr[i] + " ");
    		    		}
    		    		pw.println();
    		    		return;
    		    	}
 
    		    	private static void pArray(long[] arr) {
    		    		for (int i = 0; i < arr.length; i++) {
    		    			pw.print(arr[i] + " ");
    		    		}
    		    		pw.println();
    		    		return;
    		    	}
 
    		    	private static void pArray(boolean[] arr) {
    		    		for (int i = 0; i < arr.length; i++) {
    		    			pw.print(arr[i] + " ");
    		    		}
    		    		pw.println();
    		    		return;
    		    	}
 
    		    	private static boolean isSpaceChar(int c) {
    		    		if (filter != null)
    		    			return filter.isSpaceChar(c);
    		    		return isWhitespace(c);
    		    	}
 
    		    	private interface SpaceCharFilter {
    		    		public boolean isSpaceChar(int ch);
    		    	}
    		    	

}
    		    
    		        class Node{
    		    	int to;
    		    	long dist;
    		    	Node(int to,long dist){
    		    		this.to=to;
    		    		this.dist=dist;
    		    	}
    		    	
    		    }
    		
class Dsu{
private int rank[], parent[] ,n;
long str[],si[],larg[];
long max=0;
int cnt=0;
private static int[] parent1;
Dsu(int size){
	this.n=size+1;
	rank=new int[n];
	cnt=n-1;
	//parent=new int[n];
    		    		    		parent=new int[n];
    		    		    		str=new long[n];
    		    		    		si=new long[n];
    		    		
    		    		    		larg=new long[n];
    		    		    		makeSet();
    		    		
    		    		    	}
    		    		    	
    		    		    	void makeSet(){
    		    		    		for(int i=0;i<n;i++){
    		    		    			parent[i]=i;
    		    		    			si[i]=1;
    		    		    		}
    		    		    	}
    		    		    	
    		    		    	int find(int x){
    		    		    		if(parent[x]!=x){
    		    		    			
    		    		    			parent[x]=find(parent[x]);
    		    		    		}
    		    		    		return parent[x];
    		    		    	}
    		    		    	
    		    		    	void join(int ind,long val){
    		    		    		if(str[ind]==0){
    		    		    			str[ind]=val;
    		    		    			larg[ind]=val;
    		    		    			max=Math.max(max, str[ind]);
    		    		    		}
    		    		    		int prev_ind=(ind-1);
    		    		    		int next_ind=(ind+1);
    		    		    		if(prev_ind>0 && larg[prev_ind]!=0){
    		    		    			union(prev_ind,ind);
    		    		    		}
    		    		    		if(next_ind<n && larg[next_ind]!=0){
    		    		    			union(next_ind,ind);
    		    		    		}
    		    		    		
    		    		    	}
    		    		    
    		    		    	
    		    		    	boolean union(int x,int y){
    		    		    		int xRoot=find(x);
    		    		    		int yRoot=find(y);
    		    		    
    		    		    	
    		    		    		if(xRoot==yRoot)
    		    		    			return false;
    		    		    		if(rank[xRoot]<rank[yRoot]){
    		    		    		parent[xRoot]=yRoot;
    		    		    		
    		    		    		larg[yRoot]=Math.max(larg[xRoot], larg[yRoot]);
    		    		    		
    		    		    		si[yRoot]+=si[xRoot];
    		    		    		str[yRoot]=larg[yRoot]*si[yRoot];
    		    		    			max=Math.max(str[yRoot], max);
    		    		    		}else if(rank[yRoot]<rank[xRoot]){
    		    		    			parent[yRoot]=xRoot;
     
    		    		    			larg[xRoot]=Math.max(larg[xRoot], larg[yRoot]);
        		    		    		
        		    		    		si[xRoot]+=si[yRoot];
        		    		    		str[xRoot]=larg[xRoot]*si[xRoot];
    			    		    		max=Math.max(str[xRoot], max);
    		    		    		}else{
    		    		    			parent[yRoot]=xRoot;
    		    		    			rank[xRoot]++;
     
    		    		    			larg[xRoot]=Math.max(larg[xRoot], larg[yRoot]);
        		    		    		
        		    		    		si[xRoot]+=si[yRoot];
        		    		    		str[xRoot]=larg[xRoot]*si[xRoot];
    			    		    		max=Math.max(str[xRoot], max);
    		    		    		
    		    		    		}
    		    		    		cnt--;
    		    		    		return true;
    		    		    	}
    	
    		    		     
    		    		    }