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 PYTHON3):

Solution:
"""https://codeforces.com/contest/1095/problem/C"""
class Heap():
    def __init__(self, arr = [], key = None, heap_type = 'min'):
        self.arr = arr
        self.key = key
        self.heap_type = heap_type
        if key==None: self.key = lambda x: x
        self.heapify()
        
    def __repr__(self):
        return str(self.arr)

    def __compare(self, index1, index2 ):
        """ 1>2 : 1 else -1 """
        return self.__compare_keys( self[index1], self[index2])
    
    def __compare_keys(self, key1, key2 ):
        """ 1>2 : 1 else -1 """
        ans = 0
        if key1 > key2: ans = 1
        elif key1 < key2: ans = -1
        else: ans = 0
        return ans if self.heap_type=='min' else -1*ans
    
    def heapify(self):
        """heapify array between 0 and high"""
        for i in range(0,len(self)):
            self.__bubble_up(i)
    
    def insert(self, item):
        self.arr.append(item)
        self.__bubble_up( len(self)-1 )
    
    def __getitem__(self, index):
        return self.key( self.arr[index] )
    
    def __bubble_up(self, index):
        """bubble up from index"""
        parent = (index-1)//2
        while parent >= 0 and self.__compare(index, parent) == -1:
            self.arr[parent], self.arr[index] = self.arr[index], self.arr[parent]
            index, parent = parent, (parent-1)//2
        
    def __bubble_down(self, index):
        """bubble down from index"""
        high = len(self)
        while True:
            l, r = index*2 + 1, index*2 + 2
            if r < high:
                if self.__compare( r, l ) == -1:
                    if self.__compare( r, index ) >= 0: break
                    self.arr[r], self.arr[index] = self.arr[index], self.arr[r]
                    index = r
                else:
                    if self.__compare( l, index ) >= 0: break
                    self.arr[l], self.arr[index] = self.arr[index], self.arr[l]
                    index = l
            elif l < high:
                if self.__compare( l, index ) >= 0: break
                self.arr[l], self.arr[index] = self.arr[index], self.arr[l]
                break
            else:
                break

    def __len__(self):
        return len(self.arr)
    
    def pop(self):
        self.arr[0], self.arr[-1] = self.arr[-1], self.arr[0]
        top = self.arr.pop(-1)
        self.__bubble_down( 0 )
        return top

from math import log2
n, k = tuple(map(int,input().split()))
if k > n:
    print('NO')
else:
    powers = Heap(heap_type='max')
    while n!=0:
        x = int( log2(n) )
        powers.insert( pow(2,x) )
        n = n-pow(2,x)
    if len(powers) > k:
        print('NO')
    else:
        while len(powers) != k:
            g = powers.pop()
            powers.insert(g//2)
            powers.insert(g//2)
        print('YES')
        print(*powers)