You are given positive integer number n. You should create such strictly increasing sequence of k positive numbers a1, a2, ..., ak, that their sum is equal to n and greatest common divisor is maximal.

Greatest common divisor of sequence is maximum of such numbers that every element of sequence is divisible by them.

If there is no possible sequence then output -1.

Input

The first line consists of two numbers n and k (1 ≤ n, k ≤ 1010).

Output

If the answer exists then output k numbers — resulting sequence. Otherwise output -1. If there are multiple answers, print any of them.

Examples

Input

6 3


Output

1 2 3


Input

8 2


Output

2 6


Input

5 3


Output

-1
import java.util.*;

public class c{
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		long N = in.nextLong();
		int K = (int)Math.min(2147483647L, in.nextLong());
		
		if(N == 1){
			if(K == 1){
				System.out.println(1);
			}
			else{
				System.out.println(-1);
			}
			return;
		}
		
		
		
		
		// pfac
		long tempN = N;
		pfac = new ArrayList<>();
		for(long n = 2; n*n <= tempN; n++){
			if(tempN % n == 0){
				long[] newfac = new long[]{n, 0};
				while(tempN % n == 0){
					newfac[1]++;
					tempN /= n;
				}
				pfac.add(newfac);
			}
		}
		if(tempN > 1){
			pfac.add(new long[]{tempN, 1});
		}
		
		
		// after that then we can find any factor of N
		facs = new ArrayList<>();
		// obviously 1 is a factor
		facs.add(1L);
		// now find the rest
		findMoreFacs(0, 1L);
		
		// we have all divisors that will work
		// what is the largest divisor D such that we can still have AD + BD + CD + ED + ... + ZD work?
		// we can probably binsearch this
		Collections.sort(facs);
		
		int lo = -1, hi = facs.size();
		while(lo + 1 < hi){
			int mid = lo + (hi - lo >> 1);
			long fac = facs.get(mid);
			
			// too low would be if we CAN make it
			// too high would be if we CANNOT make it
			
			long quot = N / fac;
			long sum = 0, i = 1;
			for(; sum + i <= quot; i++){
				sum += i;
			}
			i--;
			// now, i represents the max cardinality of strictly increasing sum that equals quot
			if(i < K){
				// cannot make it
				// too high
				hi = mid;
			}
			else{
				lo = mid;
			}
		}
		
		if(lo == -1){
			System.out.println(-1);
			return;
		}
		
		long gcd = facs.get(lo);
		long[] ans = new long[K];
		long sumAns = 0;
		for(int k = 0; k < K; k++){
			ans[k] = gcd * (1+k);
			sumAns += ans[k];
		}
		
		if(sumAns < N){
			ans[K-1] += (N - sumAns);
		}
		else if(sumAns > N){
			System.out.println("REEEEEEEEEEEEEEEE");
		}
		
		StringBuilder sb = new StringBuilder();
		for(long l : ans){
			sb.append(l).append(' ');
		}
		System.out.println(sb.toString().trim());
	}
	static ArrayList<Long> facs;
	static ArrayList<long[]> pfac;
	static void findMoreFacs(int dex, long currentFac){
		if(dex >= pfac.size()) return;
		for(int d = dex; d < pfac.size(); d++){
			long[] pfacpow = pfac.get(d);
			long temp = currentFac;
			for(long l = 0; l < pfacpow[1]; l++){
				temp *= pfacpow[0];
				facs.add(temp);
				findMoreFacs(d+1, temp);
			}
		}
	}
}