Polycarp has to solve exactly n problems to improve his programming skill before an important programming competition. But this competition will be held very soon, most precisely, it will start in k days. It means that Polycarp has exactly k days for training!

Polycarp doesn't want to procrastinate, so he wants to solve at least one problem during each of k days. He also doesn't want to overwork, so if he solves x problems during some day, he should solve no more than 2x problems during the next day. And, at last, he wants to improve his skill, so if he solves x problems during some day, he should solve at least x+1 problem during the next day.

More formally: let [a_1, a_2, ..., a_k] be the array of numbers of problems solved by Polycarp. The i-th element of this array is the number of problems Polycarp solves during the i-th day of his training. Then the following conditions must be satisfied: 

  * sum of all a_i for i from 1 to k should be n; 
  * a_i should be greater than zero for each i from 1 to k; 
  * the condition a_i < a_{i + 1} ≤ 2 a_i should be satisfied for each i from 1 to k-1. 



Your problem is to find any array a of length k satisfying the conditions above or say that it is impossible to do it.

Input

The first line of the input contains two integers n and k (1 ≤ n ≤ 10^9, 1 ≤ k ≤ 10^5) — the number of problems Polycarp wants to solve and the number of days Polycarp wants to train.

Output

If it is impossible to find any array a of length k satisfying Polycarp's rules of training, print "NO" in the first line.

Otherwise print "YES" in the first line, then print k integers a_1, a_2, ..., a_k in the second line, where a_i should be the number of problems Polycarp should solve during the i-th day. If there are multiple answers, you can print any.

Examples

Input


26 6


Output


YES
1 2 4 5 6 8 


Input


8 3


Output


NO


Input


1 1


Output


YES
1 


Input


9 4


Output


NO
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author DY
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        DNProblemsDuringKDays solver = new DNProblemsDuringKDays();
        solver.solve(1, in, out);
        out.close();
    }

    static class DNProblemsDuringKDays {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.readInt();
            int k = in.readInt();
            if ((long) k * (k + 1) / 2 > n) {
                out.printLine("NO");
                return;
            }
            int[] xs = new int[k];
            for (int i = 0; i < k; ++i) xs[i] = i + 1;
            IntSumIntervalTree tree = new IntSumIntervalTree(xs);
            int left = n - tree.query(0, k);
            for (int i = 0; i < k && left > 0; ++i) {
                if (i == 0 || tree.query(i, i + 1) < 2 * tree.query(i - 1, i - 1 + 1)) {
                    int can = i == 0 ? Integer.MAX_VALUE : 2 * tree.query(i - 1, i - 1 + 1) - tree.query(i, i + 1);
                    int mul = Math.min(can, left / (k - i));
                    left -= mul * (k - i);
                    tree.update(i, k, mul);
                }
            }
            if (left != 0)
                out.printLine("NO");
            else {
                out.printLine("YES");
                for (int i = 0; i < k; ++i) out.print(tree.query(i, i + 1) + " ");
                out.printLine();
            }
        }

    }

    static abstract class AbstractIntervalTree<T> {
        private int root = 0;

        public AbstractIntervalTree() {
        }

        protected abstract int arraySize();

        protected abstract int joinDelta(int delta1, int delta2);

        protected abstract int getDelta(int root);

        protected abstract int baseDelta();

        protected abstract void setDelta(int root, int newDelta);

        protected abstract void initLeaf(int root, int arrayIndex);

        protected abstract void initAfter(int root, int left, int right);

        protected abstract void updateFull(int root, int from, int to, int left, int right, int updateDelta);

        protected abstract void updateAfter(int root, int from, int to, int left, int right, int curDelta);

        protected abstract T queryFull(int root, int from, int to, int left, int right, int deltaAcc);

        protected abstract T queryAfter(T leftResult, T rightResult);

        protected int nodeCount(int arraySize) {
            return (Integer.highestOneBit(arraySize) << 2) + root;
        }

        protected void init() {

            init(root, 0, arraySize());
        }

        private void init(int root, int from, int to) {
            if (from >= to) return;
            if (from + 1 == to) {
                setDelta(root, baseDelta());
                initLeaf(root, from);
                return;
            }
            int mid = from + (to - from) / 2;
            init(root * 2 + 1, from, mid);
            init(root * 2 + 2, mid, to);
            setDelta(root, baseDelta());
            initAfter(root, root * 2 + 1, root * 2 + 2);
        }

        public void update(int updateFrom, int updateTo, int delta) {
            check(0, arraySize(), updateFrom, updateTo);
            update(root, 0, arraySize(), updateFrom, updateTo, delta);
        }

        private void update(int root, int from, int to, int updateFrom, int updateTo, int delta) {
            if (updateFrom <= from && to <= updateTo) {
                updateFull(root, from, to, root * 2 + 1, root * 2 + 2, delta);
                setDelta(root, joinDelta(delta, getDelta(root)));
                return;
            }
            int mid = from + (to - from) / 2;
            if (!(updateTo <= from || mid <= updateFrom)) update(root * 2 + 1, from, mid, updateFrom, updateTo, delta);
            if (!(updateTo <= mid || to <= updateFrom)) update(root * 2 + 2, mid, to, updateFrom, updateTo, delta);
            updateAfter(root, from, to, root * 2 + 1, root * 2 + 2, getDelta(root));
        }

        private T query(int root, int from, int to, int queryFrom, int queryTo, int deltaAcc) {
            if (queryFrom <= from && to <= queryTo) {
                return queryFull(root, from, to, root * 2 + 1, root * 2 + 2, deltaAcc);
            }
            int mid = from + (to - from) / 2;
            if (queryFrom < mid && mid < queryTo) {
                T leftResult = query(root * 2 + 1, from, mid, queryFrom, queryTo, joinDelta(deltaAcc, getDelta(root)));
                T rightResult = query(root * 2 + 2, mid, to, queryFrom, queryTo, joinDelta(deltaAcc, getDelta(root)));
                return queryAfter(leftResult, rightResult);
            }
            if (from < queryTo && queryTo <= mid) {
                T leftResult = query(root * 2 + 1, from, mid, queryFrom, queryTo, joinDelta(deltaAcc, getDelta(root)));
                return leftResult;
            }
            if (mid <= queryFrom && queryFrom < to) {
                T rightResult = query(root * 2 + 2, mid, to, queryFrom, queryTo, joinDelta(deltaAcc, getDelta(root)));
                return rightResult;
            }

            throw new RuntimeException();
        }

        public T query(int queryFrom, int queryTo) {
            check(0, arraySize(), queryFrom, queryTo);
            return query(root, 0, arraySize(), queryFrom, queryTo, baseDelta());
        }

        private void check(int from, int to, int rangeFrom, int rangeTo) {
            if (from >= to || rangeFrom >= rangeTo) throw new IllegalArgumentException();
            if (!(from <= rangeFrom && rangeTo <= to)) throw new IllegalArgumentException();
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void printLine() {
            writer.println();
        }

        public void printLine(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }

    static class IntSumIntervalTree extends AbstractIntervalTree<Integer> {
        private int[] array;
        private int nodeCount;
        private int[] delta;
        private int[] sum;

        public IntSumIntervalTree(int array[]) {
            this.array = array;
            this.nodeCount = nodeCount(array.length);
            delta = new int[nodeCount];
            sum = new int[nodeCount];
            init();
        }

        public int arraySize() {
            return array.length;
        }

        public int joinDelta(int delta1, int delta2) {
            return delta1 + delta2;
        }

        public int getDelta(int root) {
            return delta[root];
        }

        public int baseDelta() {
            return 0;
        }

        public void setDelta(int root, int newDelta) {
            delta[root] = newDelta;
        }

        public void initLeaf(int root, int arrayIndex) {
            sum[root] = array[arrayIndex];
        }

        public void initAfter(int root, int left, int right) {
            sum[root] = sum[left] + sum[right];
        }

        public void updateFull(int root, int from, int to, int left, int right, int updateDelta) {
            sum[root] += (to - from) * updateDelta;
        }

        public void updateAfter(int root, int from, int to, int left, int right, int curDelta) {
            sum[root] = sum[left] + sum[right] + (to - from) * curDelta;
        }

        public Integer queryFull(int root, int from, int to, int left, int right, int deltaAcc) {
            return sum[root] + (to - from) * deltaAcc;
        }

        public Integer queryAfter(Integer leftResult, Integer rightResult) {
            return leftResult + rightResult;
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

