Problem: Long story short, shashlik is Miroslav's favorite food. Shashlik is prepared on several skewers simultaneously. There are two states for each skewer: initial and turned over.

This time Miroslav laid out n skewers parallel to each other, and enumerated them with consecutive integers from 1 to n in order from left to right. For better cooking, he puts them quite close to each other, so when he turns skewer number i, it leads to turning k closest skewers from each side of the skewer i, that is, skewers number i - k, i - k + 1, ..., i - 1, i + 1, ..., i + k - 1, i + k (if they exist). 

For example, let n = 6 and k = 1. When Miroslav turns skewer number 3, then skewers with numbers 2, 3, and 4 will come up turned over. If after that he turns skewer number 1, then skewers number 1, 3, and 4 will be turned over, while skewer number 2 will be in the initial position (because it is turned again).

As we said before, the art of cooking requires perfect timing, so Miroslav wants to turn over all n skewers with the minimal possible number of actions. For example, for the above example n = 6 and k = 1, two turnings are sufficient: he can turn over skewers number 2 and 5.

Help Miroslav turn over all n skewers.

Input

The first line contains two integers n and k (1 ≤ n ≤ 1000, 0 ≤ k ≤ 1000) — the number of skewers and the number of skewers from each side that are turned in one step.

Output

The first line should contain integer l — the minimum number of actions needed by Miroslav to turn over all n skewers. After than print l integers from 1 to n denoting the number of the skewer that is to be turned over at the corresponding step.

Examples

Input

7 2


Output

2
1 6 


Input

5 1


Output

2
1 4 

Note

In the first example the first operation turns over skewers 1, 2 and 3, the second operation turns over skewers 4, 5, 6 and 7.

In the second example it is also correct to turn over skewers 2 and 5, but turning skewers 2 and 4, or 1 and 5 are incorrect solutions because the skewer 3 is in the initial state after these operations.

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.Collection;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.io.InputStream;

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

    static class TaskB {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt();
            int K = in.nextInt();
            if (K == 0) {
                out.println(n);
                StringBuilder stringBuilder = new StringBuilder();
                for (int i = 0; i < n; ++i) {
                    stringBuilder.append(i + 1);
                    stringBuilder.append(" ");
                }
                out.println(stringBuilder.toString().trim());
            } else if (K >= n / 2) {
                out.println(1);
                out.println((n >> 1) + 1);
            } else if (n % (2 * K + 1) == 0) {
                out.println(n / (2 * K + 1));
                StringBuilder stringBuilder = new StringBuilder();
                int start = K + 1;
                while (start <= n) {
                    stringBuilder.append(start);
                    stringBuilder.append(" ");
                    start += 2 * K + 1;
                }
                out.println(stringBuilder.toString().trim());
            } else {
                ArrayList<Integer> ans = new ArrayList<>();
                int size = Integer.MAX_VALUE;
                int f = -1;
                int s = -1;
                for (int i = 1; i <= K + 1; ++i) {
                    for (int j = n; j >= n - K; --j) {
                        if (i + K >= j - K) continue;
                        int tillNow = i + K + K + (n - j + 1);
                        int rem = n - tillNow;
                        if (rem % (2 * K + 1) == 0) {
                            if (size > 2 + (rem / (2 * K + 1))) {
                                size = 2 + (rem / (2 * K + 1));
                                f = i;
                                s = j;
                            }
                        }
                    }
                }
                if (f == -1 || s == -1) {
                    out.println(-1);
                    return;
                }
                ans.add(f);
                ans.add(s);
                boolean[] up = new boolean[n + 1];
                for (int i = Math.max(f - K, 1); i <= Math.min(f + K, n); i += 1) up[i] = true;
                for (int i = Math.max(1, s - K); i <= Math.min(n, s + K); i += 1) up[i] = true;
                for (int i = f + 2 * K + 1; ; i += 2 * K + 1) {
                    if (i >= n + 1 || up[i]) break;
                    ans.add(i);
                    for (int j = i - K; j <= i + K; ++j) {
                        if (up[j]) throw new RuntimeException();
                        up[j] = true;
                    }
                }
                out.println(ans.size());
                ArrayUtils.printArray(out, ans);
            }
        }

    }

    static class ArrayUtils {
        public static <T> void printArray(PrintWriter out, Collection<T> array) {
            if (array.size() == 0) return;
            int size = array.size();
            Iterator<T> iterator = array.iterator();
            int ct = 0;
            for (; ct < size && iterator.hasNext(); ct++) {
                if (ct != 0) out.print(" ");
                out.print(iterator.next());
            }
            out.println();
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar;
        private int pnumChars;

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

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

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

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

    }
}