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.math.BigInteger;
import java.util.*;
import java.io.*;
import java.text.*;

public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in), 32768);
    static PrintWriter out = new PrintWriter(System.out);
    static StringTokenizer t;

    static String sn() {
        while (t == null || !t.hasMoreTokens()) {
            try {
                t = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                throw new RuntimeException();
            }
        }
        return t.nextToken();
    }

    static int ni() {
        return Integer.parseInt(sn());
    }

    static long nlo() {
        return Long.parseLong(sn());
    }

    public static void main(String args[]) {
        int t = 1;
        while (t-- > 0) {
            solve();
        }
        out.close();
    }

    static long mod = (long) 1e9 + 7;

    static long pro(long a, long b) {
        return (a % mod * b % mod) % mod;
    }

    static long add(long a, long b) {
        return (a + b) % mod;
    }

    static long sub(long a, long b) {
        return ((a % mod - b % mod) + mod) % mod;
    }

    static int maxn = 200005;

    static int pow(int n) {
        return (int) (Math.log10(n) / Math.log10(2));
    }

    static long modpow(long x, long y) {
        long res = 1l;
        x %= mod;
        while (y > 0) {
            if (y % 2 != 0)
                res = pro(res, x);
            x = pro(x, x);
            y /= 2;
        }
        return res;
    }

    static class pair {
        String a;
        int b;

        pair(String x, int y) {
            a = x;
            b = y;
        }
    }

    static long modInverse(long n) {
        BigInteger n1 = new BigInteger(Long.toString(n));
        String s = (n1.modInverse(new BigInteger(Long.toString(mod)))).toString();
        return Long.parseLong(s);
    }

    static boolean primecheck(long n) {
        for (int i = 2; i * i <= n; i++) {
            if (n % i == 0)
                return false;
        }
        return true;
    }

    static long gcd(long a, long b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    static void solve() {
        int n = ni();
        int k = ni();
        if (k > n || k < Integer.bitCount(n))
            out.println("NO");
        else {
            out.println("YES");
            Deque<Integer> dq = new LinkedList<>();
            int p = 0;
            while (p < 31) {
                if ((n & (1 << p)) > 0) {
                    dq.add(1 << p);
                }
                p++;
            }
            int d = k - Integer.bitCount(n);
            while (d > 0) {
                int t = dq.pollFirst();
                if (t != 1) {
                    d -= 1;
                    dq.addLast(t / 2);
                    dq.addLast(t / 2);
                } else
                    dq.addLast(1);
            }
            while (!dq.isEmpty())
                out.print(dq.pollFirst() + " ");
        }
//        int n = ni();
//        int child[] = new int[n + 1];
//        int move[][] = new int[n + 1][2];
//        for (int i = 1; i <= n; i++) {
//            child[i] = -1;
//            move[i][0] = ni();
//            move[i][1] = ni();
//        }
//        int cur = 1;
//        boolean v[] = new boolean[n + 1];
//        v[1] = true;
//        while (true) {
//            int nxt = -1;
//            int x = move[cur][0];
//            int y = move[cur][1];
//            if (move[x][0] == y || move[x][1] == y) {
//                nxt = x;
//            } else
//                nxt = y;
//            if (v[nxt])
//                break;
//            child[cur] = nxt;
//            cur = nxt;
//        }
//        int s = 1;
//        while (s != -1) {
//            out.print(s + " ");
//            s = child[s];
//        }
    }
}