Problem: A positive integer x is called a power of two if it can be represented as x = 2^y, where y is a non-negative integer. So, the powers of two are 1, 2, 4, 8, 16, ....

You are given two positive integers n and k. Your task is to represent n as the sum of exactly k powers of two.

Input

The only line of the input contains two integers n and k (1 ≤ n ≤ 10^9, 1 ≤ k ≤ 2 ⋅ 10^5).

Output

If it is impossible to represent n as the sum of k powers of two, print NO.

Otherwise, print YES, and then print k positive integers b_1, b_2, ..., b_k such that each of b_i is a power of two, and ∑ _{i = 1}^{k} b_i = n. If there are multiple answers, you may print any of them.

Examples

Input


9 4


Output


YES
1 2 2 4 


Input


8 1


Output


YES
8 


Input


5 1


Output


NO


Input


3 7


Output


NO

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;

public class C {
	static Random random;
	private static void mySort(int[] s) {
        for (int i = 0; i < s.length; ++i) {
            int j = random.nextInt(i + 1);
            int t = s[i];
            s[i] = s[j];
            s[j] = t;
        }
        Arrays.sort(s);
    }
	
	static class Pair{
		int x;
		int y;
		
		public Pair(int x, int y) {
			this.x=x;
			this.y=y;
		}
	}
	
	public static void sortPairX(Pair[] p) {
		Arrays.sort(p, new Comparator<Pair>() {
			public int compare(Pair o1, Pair o2) {
				return o1.x-o2.x;
			}			
		});
	}
	
	public static void sortPairY(Pair[] p) {
		Arrays.sort(p, new Comparator<Pair>() {
			public int compare(Pair o1, Pair o2) {
				return o1.y-o2.y;
			}			
		});
	}
	
	

	public static void main(String[] args) {
		random = new Random(543534151132L + System.currentTimeMillis());
		InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        
        int nb=in.nextInt();
        int k=in.nextInt();
        
        
        if(k>nb)out.println("NO");
        else {
        	PriorityQueue<Integer> pq=new PriorityQueue<Integer>();
        	int i=0;
        	int x=nb;
        	while(nb>0) {
        		if(nb%2==1)pq.add(x-i);
        		i++;
        		nb/=2;
        	}
        	boolean ok=true;
        	if(pq.size()>k) {
        		ok=false;
        	}
        	while(pq.size()<k) {
        		if(pq.isEmpty()) {
        			ok=false;
        			break;
        		}else {
        			int a=x-pq.poll();
        			if(a<=0) {
        				ok=false;
        				break;
        			}
        			
        			pq.add(x-(a-1));
        			pq.add(x-(a-1));
        		}
        	}
        	
        	if(ok) {
        		out.println("YES");
        		PriorityQueue<Integer> result=new PriorityQueue<Integer>();
        		for(int v:pq) {
        			result.add(x-v);
        		}
        		for(int v:result) {
            		out.print((int)Math.pow(2, v)+" ");
            	}
        	}else out.println("NO");
        	
        }
        
        
        
        
        
        
        
		out.close();
		
	}
	
	

	public static int gcd(int a, int b)  
    { 
        BigInteger b1 = BigInteger.valueOf(a); 
        BigInteger b2 = BigInteger.valueOf(b); 
        BigInteger gcd = b1.gcd(b2); 
            return gcd.intValue(); 
    } 
      
    public static long gcd(long a, long b)  
    { 
        BigInteger b1 = BigInteger.valueOf(a); 
        BigInteger b2 = BigInteger.valueOf(b); 
        BigInteger gcd = b1.gcd(b2); 
            return gcd.longValue(); 
    } 
	
	static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        
        public long nextLong() {
            return Long.parseLong(next());
        }
        
        public double nextDouble() {
            return Double.parseDouble(next());
        }
        
        public float nextFloat() {
            return Float.parseFloat(next());
        }
        
    }

}