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.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.security.interfaces.DSAKey;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class main {

    public static class in   {
        static BufferedReader reader;
        static StringTokenizer tokenizer;

        static void init(InputStream input) throws FileNotFoundException {
             //reader = new BufferedReader(new FileReader("jacks_candy_shop.txt"));
            reader = new BufferedReader(new InputStreamReader(input));
            tokenizer = new StringTokenizer("");
        }

        static String next() throws IOException {
            while (!tokenizer.hasMoreTokens())
                tokenizer = new StringTokenizer(reader.readLine());
            return tokenizer.nextToken();
        }

        static int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        static double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        static long nextLong() throws IOException {
            return Long.parseLong(next());
        }
    }

    public static long comp(int n, int r) {
        r = Math.min(r, n - r);
        long ans = 1;
        for (int i = 1; i <= r; i++) {
            ans = ans * (long) (n - r + i) / (long) i;
        }
        return ans;

    }


    public static int gcd(int x, int y) {
        if (y == 0)
            return x;
        return gcd(y, x % y);
    }


    public static class point implements Comparable<point>  {
        String a ;
        int idx;

        point( String a, int idx) {
            this.a = a;
            this.idx = idx;
        }

        @Override
        public int compareTo(point o) {
            if (o.idx < idx)
                return 1;
            else if (o.idx > idx)
                return -1;
            return 0;
        }
    }

    // for bad input
    static String ReadLn(int maxLg) {
        byte lin[] = new byte[maxLg];
        int lg = 0, car = -1;
        String line = "";

        try {
            while (lg < maxLg) {
                car = System.in.read();
                if ((car < 0) || (car == '\n'))
                    break;
                lin[lg++] += car;
            }
        } catch (IOException e) {
            return (null);
        }

        if ((car < 0) && (lg == 0))
            return (null);
        return (new String(lin, 0, lg));
    }







    public static class node implements Comparable<node>{
        int value;

        node(int value){
            this.value = value;

        }
        @Override
        public int compareTo(node o) {
            if(o.value > value)
                return 1;
            else if(o.value < value)
                return -1;
            return 0;
        }
    }




    public static void main(String[] args) throws IOException {

        StringBuilder qq = new StringBuilder();
        in.init(System.in);
        PrintWriter out = new PrintWriter(System.out);
        BufferedReader inp = new BufferedReader(
                new InputStreamReader(System.in));


        int n = in.nextInt();
        int k = in.nextInt();

        int a [] = new int[31];

        for (int i = 0; i < 31; i++) {
            a[i] = 1<< i;
        }



       PriorityQueue<node> q = new PriorityQueue<>();
        while(n > 0){
            int bin = Arrays.binarySearch(a, n);

            if(bin > -1){
                q.add(new node(a[bin]));
                n -= a[bin];
            }else{
                bin *= -1;
                bin -= 2;
                q.add(new node(a[bin]));
                n -= a[bin];
            }

        }

        if(q.size() > k){
            out.println("NO");
        }else{

            while(q.size() < k){
                int large = q.poll().value;
                if(large == 1){
                    out.println("NO");
                    out.close();
                    return;
                }else{
                    q.add(new node(large/2));
                    q.add(new node(large/2));

                }
            }

            out.println("YES");
            while(!q.isEmpty()){
                out.print(q.poll().value+" ");
            }
            out.println();
        }

        out.close();
    }

}