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 heapq import heapify, heappop, heappush
import io
import os
import sys
from atexit import register
import random
import math
import itertools

##################################### Flags          #####################################
# DEBUG = True
DEBUG = False
STRESSTEST = False

##################################### IO             #####################################

if not DEBUG:
    input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
sys.stdout = io.BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))

tokens = []
tokens_next = 0


def nextStr():
    global tokens, tokens_next
    while tokens_next >= len(tokens):
        tokens = input().split()
        tokens_next = 0
    tokens_next += 1

    if type(tokens[tokens_next - 1]) == str:
        return tokens[tokens_next - 1]
    return tokens[tokens_next - 1].decode()


def nextInt():
    return int(nextStr())


def nextIntArr(n):
    return [nextInt() for i in range(n)]


def print(*argv, end='\n'):
    for arg in argv:
        sys.stdout.write((str(arg) + ' ').encode())
    sys.stdout.write(end.encode())


##################################### Helper Methods #####################################
def genTestCase():
    raise NotImplementedError


def bruteforce(a):
    raise NotImplementedError


def doStressTest():
    while True:
        curTest = genTestCase()
        mySoln = solve(curTest)
        bruteforceSoln = bruteforce(curTest)
        if mySoln != bruteforceSoln:
            print('### Found case ###')
            print(curTest)
            print(f'{mySoln} should have been: {bruteforceSoln}')
            return


def breakIntoPowersOf2(n):
    rep = bin(n)
    rep = rep[2:]
    rep = list(reversed(rep))

    res = []
    for i in range(len(rep)):
        if rep[i] == '1':
            res.append(1 << i)
    return res


def solve(n, k):
    rep = breakIntoPowersOf2(n)
    rep = [-i for i in rep]
    heapify(rep)

    while len(rep) < k:
        cur = -heappop(rep)
        if cur == 1:
            return None
        heappush(rep, -cur // 2)
        heappush(rep, -cur // 2)

    return [-i for i in rep] if len(rep) == k else None


##################################### Driver         #####################################

if __name__ == "__main__":
    if not DEBUG and STRESSTEST:
        raise Exception('Wrong flags!')

    if STRESSTEST:
        doStressTest()
    else:
        ### Read input here
        n = nextInt()
        k = nextInt()
        res = solve(n, k)
        if res:
            print('YES')
            print(' '.join(map(str, sorted(res))))
        else:
            print('NO')
    sys.stdout.flush()