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
'''
    Aakash Pahwa ( @aakash10399 )

    Hi There! :D

    queue.Queue()
    queue.LifoQueue() , basically stack
    math.gcd()
    pow(a,b,m)
    pow(a,m-2,m) , mod inverse fermat's theorem
    math.log(a,b)
    math.ceil() floor()


'''

import heapq
import queue
from collections import *
import math
import sys

def sieve(n): 
      
    primes = [True for i in range(n+1)] 

    p = 2

    while (p * p <= n): 
        if (primes[p] == True): 
            for i in range(p * p, n+1, p): 
                primes[i] = False
        p += 1
      
    return primes

n , k = [int(ele) for ele in input().split()]
ms = ( k * (k+1) ) // 2
f = False
if ms > n:
    print( "NO" )
else:
    farr = [ int(ele) for ele in range(1,k+1) ]
    diff = n - ms
    prevdiff = diff
    while diff > 0:
        if diff >= k:
            farr = [ ele+( diff//k ) for ele in farr ]
            diff = diff%k
        else:
            ind = k-1
            ff = True
            while ff and diff > 0 and ind >= 0:
                if ind == 0:
                    temp = farr[1] - farr[0] - 1
                else:
                    temp = 2*farr[ind-1] - farr[ind]
                
                if temp >= diff:
                    farr[ind] += diff
                    diff = 0
                    break
                else:
                    farr[ind] += temp
                    diff -= temp
                ind -= 1
                if ind < 0:
                    ff = False
                    f = True
                    break
                if diff >= prevdiff:
                    ff = False
                    f = True
                    break
        if diff >= prevdiff:
            break
        prevdiff = diff
            #farr[-1] += diff
            #diff = 0
    for i in range( 0 , k-1 ):
        if not ( farr[i+1] > farr[i] and farr[i+1] <= 2*farr[i] ):
            f = True
    if diff > 0:
        f = True
    if f:
        print( "NO" )
    else:
        print( "YES" )
        print( *farr )