There are n students who have taken part in an olympiad. Now it's time to award the students.

Some of them will receive diplomas, some wiil get certificates, and others won't receive anything. Students with diplomas and certificates are called winners. But there are some rules of counting the number of diplomas and certificates. The number of certificates must be exactly k times greater than the number of diplomas. The number of winners must not be greater than half of the number of all students (i.e. not be greater than half of n). It's possible that there are no winners.

You have to identify the maximum possible number of winners, according to these rules. Also for this case you have to calculate the number of students with diplomas, the number of students with certificates and the number of students who are not winners.

Input

The first (and the only) line of input contains two integers n and k (1 ≤ n, k ≤ 1012), where n is the number of students and k is the ratio between the number of certificates and the number of diplomas.

Output

Output three numbers: the number of students with diplomas, the number of students with certificates and the number of students who are not winners in case when the number of winners is maximum possible.

It's possible that there are no winners.

Examples

Input

18 2


Output

3 6 9


Input

9 10


Output

0 0 9


Input

1000000000000 5


Output

83333333333 416666666665 500000000002


Input

1000000000000 499999999999


Output

1 499999999999 500000000000
import java.io.*;
import java.util.*;

public class Main {

	class IOManager {
		BufferedReader reader;
		PrintWriter writer;
		StringTokenizer tokenizer;

		IOManager() {
			reader = new BufferedReader(new InputStreamReader(System.in));
			writer = new PrintWriter(new BufferedOutputStream(System.out));
		}

		IOManager(String file) throws FileNotFoundException {
			reader = new BufferedReader(new FileReader(file));
			writer = new PrintWriter(new BufferedOutputStream(System.out));
		}

		String next() throws IOException {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				String line = reader.readLine();
				if (line == null)
					throw new IOException("No lines left.");
				tokenizer = new StringTokenizer(line);
			}
			return tokenizer.nextToken();
		}

		public Integer nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public Long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public Double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public void writeSpace(Object obj) {
			writer.print(obj.toString() + " ");
		}

		public void writeLine(Object obj) {
			writer.println(obj.toString());
		}

		public void writeDouble(Double x, int n) {
			String format = "%." + n + "f";
			writer.printf(format, x);
		}

		public void write(Object obj) {
			writer.print(obj.toString());
		}

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

	class Pair<T extends Comparable> implements Comparable {
		public T u, v;

		public Pair(T u, T v) {
			this.u = u;
			this.v = v;
		}

		@Override
		public int compareTo(Object o) {
			Pair that = (Pair) o;
			if (u.compareTo(that.u) != 0)
				return u.compareTo(that.u);
			return v.compareTo(that.v);
		}
	}

	class Graph {
		public int n, m;
		public List<Integer>[] adj;

		public Graph(int n, int m) {
			this.n = n;
			this.m = m;
			adj = new List[n + 1];
			for (int i = 0; i <= n; ++i) {
				adj[i] = new ArrayList<>();
			}
		}

		public void add(int u, int v) {
			adj[u].add(v);
		}

		public void add2Ways(int u, int v) {
			add(u, v);
			add(v, u);
		}

		public void dfs(int i, boolean fr[]) {
			fr[i] = false;
			for (int j : adj[i]) {
				if (fr[j]) {
					dfs(j, fr);
				}
			}
		}

		public boolean isConnected() {
			boolean fr[] = new boolean[n + 1];
			Arrays.fill(fr, true);
			dfs(1, fr);
			for (int i = 2; i <= n; ++i) {
				if (fr[i])
					return false;
			}
			return true;
		}

		public boolean hasEuclideanPath() {
			if (!isConnected())
				return false;
			int cnt = 0;
			for (int i = 1; i <= n; ++i) {
				if (adj[i].size() % 2 == 1)
					cnt++;
			}
			return cnt <= 2;
		}

		public boolean dfsHamiltonian(int i, boolean[] fr, int reached) {
			fr[i] = false;
			reached++;
			if (reached == n)
				return true;
			for (int j : adj[i]) {
				if (fr[j]) {
					if (dfsHamiltonian(j, fr, reached))
						return true;
				}
			}
			fr[i] = true;
			return false;
		}

		public boolean hasHamiltonianPathFrom(int st) {
			boolean fr[] = new boolean[n + 1];
			Arrays.fill(fr, true);
			return dfsHamiltonian(st, fr, 0);
		}
	}

	// Actually rooted forest
	class Tree extends Graph {

		public Tree(int n, int m) {
			super(n, m);
		}

		public int getHeight(int i) {
			int res = 0;
			for (Integer j : adj[i]) {
				res = Math.max(res, getHeight(j) + 1);
			}
			return res;
		}
	}

	class FenwickTree {
		int n;
		int tree[];

		public FenwickTree() {

		}

		public FenwickTree(int maxn) {
			n = maxn;
			tree = new int[maxn + 10];
		}

		public void add(int i, int x) {
			while (i <= n) {
				tree[i] += x;
				i += i & (-i);
			}
		}

		public void add(int i) {
			add(i, 1);
		}

		public int get(int i) {
			int res = 0;
			while (i > 0) {
				res += tree[i];
				i -= i & (-i);
			}
			return res;
		}
	}

	class DoubleMatrix {

		public int m, n;
		public double a[][];

		public DoubleMatrix(int _m, int _n) {
			m = _m;
			n = _n;
			a = new double[m][n];
		}

		public DoubleMatrix(double x[][]) {
			if (x.length == 0)
				return;
			m = x.length;
			n = x[0].length;
			a = new double[m][n];
			for (int i = 0; i < m; ++i) {
				for (int j = 0; j < n; ++j) {
					a[i][j] = x[i][j];
				}
			}
		}

		public DoubleMatrix invert() {
			if (m != n)
				return null;
			double x[][] = new double[n][n];
			double b[][] = new double[n][n];
			int index[] = new int[n];
			for (int i = 0; i < n; ++i)
				b[i][i] = 1;

			// Transform the matrix into an upper triangle
			DoubleMatrix a2 = new DoubleMatrix(a);
			a2.gaussian(index);

			// Update the matrix b[i][j] with the ratios stored
			for (int i = 0; i < n - 1; ++i)
				for (int j = i + 1; j < n; ++j)
					for (int k = 0; k < n; ++k)
						b[index[j]][k] -= a2.a[index[j]][i] * b[index[i]][k];

			// Perform backward substitutions
			for (int i = 0; i < n; ++i) {
				x[n - 1][i] = b[index[n - 1]][i] / a2.a[index[n - 1]][n - 1];
				for (int j = n - 2; j >= 0; --j) {
					x[j][i] = b[index[j]][i];
					for (int k = j + 1; k < n; ++k) {
						x[j][i] -= a2.a[index[j]][k] * x[k][i];
					}
					x[j][i] /= a2.a[index[j]][j];
				}
			}
			return new DoubleMatrix(x);
		}

		// Method to carry out the partial-pivoting Gaussian
		// elimination.  Here index[] stores pivoting order.

		public void gaussian(int index[]) {
			int n = index.length;
			double c[] = new double[n];

			// Initialize the index
			for (int i = 0; i < n; ++i)
				index[i] = i;

			// Find the rescaling factors, one from each row
			for (int i = 0; i < n; ++i) {
				double c1 = 0;
				for (int j = 0; j < n; ++j) {
					double c0 = Math.abs(a[i][j]);
					if (c0 > c1) c1 = c0;
				}
				c[i] = c1;
			}

			// Search the pivoting element from each column
			int k = 0;
			for (int j = 0; j < n - 1; ++j) {
				double pi1 = 0;
				for (int i = j; i < n; ++i) {
					double pi0 = Math.abs(a[index[i]][j]);
					pi0 /= c[index[i]];
					if (pi0 > pi1) {
						pi1 = pi0;
						k = i;
					}
				}

				// Interchange rows according to the pivoting order
				int itmp = index[j];
				index[j] = index[k];
				index[k] = itmp;
				for (int i = j + 1; i < n; ++i) {
					double pj = a[index[i]][j] / a[index[j]][j];

					// Record pivoting ratios below the diagonal
					a[index[i]][j] = pj;

					// Modify other elements accordingly
					for (int l = j + 1; l < n; ++l)
						a[index[i]][l] -= pj * a[index[j]][l];
				}
			}
		}

		public DoubleMatrix mul(DoubleMatrix b) {
			if (n != b.m)
				return null;
			DoubleMatrix c = new DoubleMatrix(m, b.n);
			for (int i = 0; i < m; ++i) {
				for (int j = 0; j < b.n; ++j) {
					c.a[i][j] = 0;
					for (int k = 0; k < n; ++k) {
						c.a[i][j] += a[i][k] * b.a[k][j];
					}
				}
			}
			return c;
		}

		public String toString() {
			StringBuilder sb = new StringBuilder();
			for (int i = 0; i < m; ++i) {
				for (int j = 0; j < n; ++j) {
					sb.append(a[i][j]);
					sb.append(j == n - 1 ? "\n" : " ");
				}
			}
			return sb.toString();
		}

		public DoubleMatrix transpose() {
			DoubleMatrix res = new DoubleMatrix(n, m);
			for (int i = 0; i < n; ++i) {
				for (int j = 0; j < m; ++j) {
					res.a[i][j] = a[j][i];
				}
			}
			return res;
		}
	}

	IOManager ioManager;

	Main() {
		ioManager = new IOManager();
	}

	Main(String file) throws FileNotFoundException {
		ioManager = new IOManager(file);
	}

	void solve() throws IOException {
		long n = ioManager.nextLong();
		long k=  ioManager.nextLong();
		long x = (n / 2) / (k + 1);
		ioManager.writeLine(x + " " + (x * k) + " " + (n - x - x * k));
	}

	void close() {
		ioManager.close();
	}

	public static void main(String args[]) throws IOException {
		Main solver;
//		solver = new Main();
        if (!"true".equals(System.getProperty("ONLINE_JUDGE"))) {
            solver = new Main("input.txt");
        } else {
            solver = new Main();
        }
		solver.solve();
		solver.close();
	}
}