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.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Arrays;

public class D {
	static long[] ans;
	static class ST {
		int l, r;
		long v, lazy;
		ST left, right;
		
		public ST(int l, int r) {
			this.l = l;
			this.r = r;
			if (l != r) {
				int mid = (l + r)>>1;
				left = new ST(l, mid);
				right = new ST(mid + 1, r);
				v = left.v + right.v;
			} else {
				v = ans[l];
			}
		}
		
		public void fixLazy() {
			if (lazy > 0) {
				v += lazy * (r - l + 1);
				if (l != r) {
					left.lazy += lazy;
					right.lazy += lazy;
				} else {
					ans[l] = v;
				}
				lazy = 0;
			}
		}
		
		public long query(int ind) {
			fixLazy();
			if (l == r) return v;
			int mid = (l + r) >> 1;
			if (ind <= mid) {
				return left.query(ind);
			} else {
				return right.query(ind);
			}
		}
		
		public void update(int l, int r, long v) {
			fixLazy();
			if (r < this.l || this.r < l) return;
			if (l <= this.l && this.r <= r) {
				this.lazy += v;
				fixLazy();
			} else {
				left.update(l, r, v);
				right.update(l, r, v);
				this.v = left.v + right.v;
			}
		}
	}
	
	static final int MAX = 1000000005;
	
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out), false);
		String[] parts = br.readLine().split(" ");
		int n = Integer.parseInt(parts[0]);
		int k = Integer.parseInt(parts[1]);
		ans = new long[k];
		long sumK = (((long)k)*(k + 1L))>>1;
		ans[0] = n/sumK;
		for (int i = 1; i < k; ++i) {
			ans[i] = ans[i - 1] + 1;
		}
		long missing = n - ((ans[0]-1)*k + sumK);
		int curr = 0;
		ST root = new ST(0, k - 1);
		while (missing > 0 && curr < k) {
			long currLimit = MAX;
			if (curr > 0) currLimit = root.query(curr - 1) * 2;
			long elemsToSum = Math.max(0, ((long)k - curr));
			long sum = elemsToSum;
			if (sum > missing || sum == 0) {
				++curr; continue;
			}
			long times = Math.min(currLimit - root.query(curr), missing/sum);
			// System.out.println("Curr " + curr + ", times " + times + ", sum " + sum);
			root.update(curr, k - 1, times);
			missing -= times * sum;
			++curr;
		}
		
		if (missing != 0 || root.query(0) == 0) {
			out.println("NO");
		} else {
			out.println("YES");
			for (int i = 0; i < k; ++i) {
				if (i > 0) out.print(' ');
				out.print(root.query(i));
			}
			out.println();
		}
		out.close();
	}

}
