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:
from math import log2
from heapq import heappush, heappop, heapify  
  
# heappop - pop and return the smallest element from heap 
# heappush - push the value item onto the heap, maintaining 
#             heap invarient 
# heapify - transform list into heap, in place, in linear time 
  
# A class for Min Heap 
class MinHeap: 
      
    # Constructor to initialize a heap 
    def __init__(self): 
        self.heap = []  
  
    def parent(self, i): 
        return (i-1)/2
      
    # Inserts a new key 'k' 
    def insertKey(self, k): 
        heappush(self.heap, k)            
  
    # Decrease value of key at index 'i' to new_val 
    # It is assumed that new_val is smaller than heap[i] 
    def decreaseKey(self, i, new_val): 
        self.heap[i]  = new_val  
        while(i != 0 and self.heap[self.parent(i)] > self.heap[i]): 
            # Swap heap[i] with heap[parent(i)] 
            self.heap[i] , self.heap[self.parent(i)] = ( 
            self.heap[self.parent(i)], self.heap[i]) 
              
    # Method to remove minium element from min heap 
    def extractMin(self): 
        return heappop(self.heap) 
  
    # This functon deletes key at index i. It first reduces 
    # value to minus infinite and then calls extractMin() 
    def deleteKey(self, i): 
        self.decreaseKey(i, float("-inf")) 
        self.extractMin() 
  
    # Get the minimum element from the heap 
    def getMin(self): 
        return self.heap[0] 

    def leng(self):
        return len(self.heap)
    
    def summ(self):
        return sum(self.heap)

import math
n, m = map(int, input().split())
def pr(num,k,sol):
    if k<=0 and num <= 0:
        if sol.summ()==-n and sol.leng()==m:
            print('YES')
            pp = [-sol.extractMin() for _ in range(m)]
            pp.reverse()
            print(' '.join(map(str, pp)))
        else:
            print('NO')
    elif k>0 and num <= 0:
        while k>0:
            tt = sol.extractMin()
            if(tt==-1):
                break
            sol.insertKey(tt//2)
            sol.insertKey(tt//2)
            k-=1
        if k>0:
            print('NO')
        else:
            print('YES')
            pp = [-sol.extractMin() for _ in range(m)]
            pp.reverse()
            print(' '.join(map(str, pp)))
    else:
        if num%2!=0:
            sol.insertKey(-1)
            pr(num-1,k-1,sol)
        elif math.floor(log2(num)) == log2(num):
            if k==1:
                sol.insertKey(-num)
                num = -1
                pr(num,k-1,sol)
            else:
                sol.insertKey(-num//2)
                pr(num//2,k-1,sol)
        else:
            p = 2**math.floor(log2(num))
            sol.insertKey(-p)
            pr(num-p,k-1,sol)

ho = MinHeap() 
pr(n,m,ho)