Problem: Imp is really pleased that you helped him. But it you solve the last problem, his gladness would raise even more.

<image> Let's define <image> for some set of integers <image> as the number of pairs a, b in <image>, such that:

  * a is strictly less than b; 
  * a divides b without a remainder. 



You are to find such a set <image>, which is a subset of {1, 2, ..., n} (the set that contains all positive integers not greater than n), that <image>. 

Input

The only line contains two integers n and k <image>.

Output

If there is no answer, print "No".

Otherwise, in the first line print "Yes", in the second — an integer m that denotes the size of the set <image> you have found, in the second line print m integers — the elements of the set <image>, in any order.

If there are multiple answers, print any of them.

Examples

Input

3 3


Output

No


Input

6 6


Output

Yes
5
1 2 4 5 6 

Input

8 3


Output

Yes
4
2 4 5 8

Note

In the second sample, the valid pairs in the output set are (1, 2), (1, 4), (1, 5), (1, 6), (2, 4), (2, 6). Thus, <image>.

In the third example, the valid pairs in the output set are (2, 4), (4, 8), (2, 8). Thus, <image>.

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
/*

300000 3529833

 */
public class f2 {
	static int[][] divs;
	static int[] divCnts;
	public static void main(String[] args) throws IOException {
		FastScanner in = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int n = in.nextInt(), k = in.nextInt();
		divCnts = new int[n+1];
		divs = new int[n+1][];
		int max = 0;
		for(int i=1;i<=n;i++) {
			for(int j=i+i;j<=n;j+=i) {
				max++;
				divCnts[j]++;
			}
		}
		for(int i=0;i<=n;i++) {
			divs[i] = new int[divCnts[i]];
			divCnts[i] = 0;
		}
		for(int i=1;i<=n;i++) {
			for(int j=i+i;j<=n;j+=i) {
				divs[j][divCnts[j]++] = i; 
			}
		}
//		System.err.println(max);
		if(k > max) {
			System.out.println("No");
			return;
		}
		out.println("Yes");
		IntList cs = test(n,k);
		out.println(cs.size());
		for(int i=0;i<cs.size();i++) {
			if(i != 0)
				out.print(' ');
			out.print(cs.get(i));
		}
		out.println();
		out.close();
	}
	static void add(BTS bit, int k) {
		bit.add(k+1);
	}
	static void del(BTS bit, int k) {
		bit.remove(k+1);
	}
	static IntList test(int n, int k) {
		boolean[] used = new boolean[n+1];
		IntList[] sets = new IntList[n+1];
		for(int i=0;i<=n;i++)
			sets[i] = new IntList();
		int[] ptrs = new int[n+1];
		
		int[] cnts = new int[n+1];
		IntList ans = new IntList();
		ans.add(1);
		ans.add(2);
		used[1] = true;
		used[2] = true;
		k--;
		BTS tm = new BTS(n+3);
		for(int i=3;i<=n;i++) {
			int p = 2 - (i % 2);
			sets[p].add(i);
			add(tm, p);
			cnts[i] = p;
		}
		while(k > 0) {
			int p = tm.floor(Math.min(k+1, n+2))-1;
			while(cnts[sets[p].get(ptrs[p])] != p)
				ptrs[p]++;
			int c = sets[p].get(ptrs[p]++);
			del(tm, p);
			used[c] = true;
			k -= cnts[c];
			ans.add(c);
			for(int i=c*2;i<=n;i+=c) {
				if(!used[i]) {
					del(tm, cnts[i]);
					cnts[i]++;
					sets[cnts[i]].add(i);
					add(tm, cnts[i]);
				}
			}
//			for(int i : divs[c]) {
			for(int i : divs[c]) {
				if(!used[i]) {
					del(tm, cnts[i]);
					cnts[i]++;
					sets[cnts[i]].add(i);
					add(tm, cnts[i]);
				}
			}
			
		}
		return ans;
	}
	static class FastScanner {
	    BufferedReader br;
	    StringTokenizer st;
		
	    public FastScanner(InputStream i) {
	        br = new BufferedReader(new InputStreamReader(i));
	        st = new StringTokenizer("");
	    }
				
	    public String next() throws IOException {
	        if(st.hasMoreTokens())
	            return st.nextToken();
	        else
	            st = new StringTokenizer(br.readLine());
	        return next();
	    }

	    public int nextInt() throws IOException {
	        return Integer.parseInt(next());
	    }
	}
	static class BTS {
		int[] t;
		int m, hb;
		int size;
		BTS(int max) {
			m = max;
			hb = Integer.highestOneBit(m);
			t = new int[m+1];
			size = 0;
		}
		private int t(int v) {
			return t[v];
		}
		private void t(int v, int dv) {
			t[v] += dv;
		}
		void add(int i) {
			update(i, 1);
		}
		void remove(int v) {
			update(v, -1);
		}
		private void update(int i, int v) {
			size += v;
			while(i <= m) {
				t(i, v);
				i += (i&-i);
			}
		}
		boolean contains(int v) {
			return indexOf(v) - indexOf(v-1) == 1;
		}
		int floor(int v) {
			return get(indexOf(v));
		}
		int ceiling(int v) {
			return get(indexOf(v-1)+1);
		}
		int lower(int v) {
			return get(indexOf(v-1));
		}
		int higher(int v) {
			return get(indexOf(v)+1);
		}
		int indexOf(int i) {
			int s = 0;
			while(i > 0) {
				s += t(i);
				i -= i&-i;
			}
			return s-1;
		}
		int get(int i) {
			if(i == -1)
				return 0;
			i++;
			int v = 0;
			for(int b=hb;b>0;b>>=1) {
				if((v|b) <= m && t(v|b) < i) {
					v |= b;
					i -= t(v);
				}
			}
			return v+1;
		}
		int first() {
			return get(1);
		}
		int last() {
			return get(size);
		}
		int size() {
			return size;
		}
	}
	static class IntList {
		static int[] EMPTY = {};
		int[] a = EMPTY;
		int n = 0;

		void add(int v) {
			if (n >= a.length)
				a = Arrays.copyOf(a, (n << 2) + 8);
			a[n++] = v;
		}

		int get(int idx) {
			return a[idx];
		}

		int size() {
			return n;
		}
	}
}