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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Array;
import java.util.*;


public class main {


    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    static int gcd(int a, int b)
    {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }

    static int findGCD(int arr[])
    {
        int result = arr[1];
        for (int i = 1; i <arr.length-1 ; i++)
            result = gcd(arr[i], result);

        return result;
    }
    private static long[] getLongArrar(int size) {
        long arr[] = new long[size + 2];
        for (int i = 0; i <= size; i++) {
            arr[i] = in.nextLong();
        }
        return arr;
    }
    private static String[] getStringArray(int size) {
        String arr[] = new String[size + 2];
        for (int i = 1; i <= size; i++) {
            arr[i] = in.next();
        }
        return arr;
    }
    private static int[] getIntArray(int size) {
        int arr[] = new int[size + 2];
        for (int i = 1; i <= size; i++) {
            arr[i] = in.nextInt();
        }
        return arr;
    }
    private static long[] CumulativeOfArrayCreator(int arr[],int size){
        long cumulative [] =new long[size];
        cumulative[0]=arr[0];
        for(int i=1;i<size;i++){
            cumulative[i]=cumulative[i-1]+arr[i];
        }
        return cumulative;
    }
    private static int ModifiedBinarySearch(int a[],int start,int end,long value){
        // this search INDEX will find greatest element small or equal to the value

        int mid=-1;
        int nearest=start;
        while(start<=end){
            mid=(start+end)/2;
            if(a[mid]<value) {
                nearest=mid;
                start=mid+1;
            }else if (a[mid]>value){
                end=mid-1;
            }else{
                return mid;
            }
        }
        return nearest;
    }












    private static void builtSegmentTree(int a[],int n){

        for(int i=n-1;i>0;i--){
            a[i]=a[i*2]+a[(2*i)+1];
        }

    }
    private static void updateSegmentTree(int a[],int n,int index,int value){
        index+=n-1;
        int change = value-a[index];

        while(index>0){
            a[index]+=change;
            index/=2;
        }
    }
    private static int rangeSum(int a[],int n,int l,int r){
        int sum=0;

        l+=n-1;r+=n-1;

        while(l<=r){
            if(l==r){
                sum+=a[l];
                break;
            }
            if(l%2==1) {sum+=a[l]; l++;}
            if(r%2==0) {sum+=a[r]; r--;}
            l/=2;
            r/=2;
        }

        return sum;
    }

    static FastReader in;
    static StringBuilder out;

    public static void main(String[] args) {
        out=new StringBuilder();
        in = new FastReader();

        int n = in.nextInt();
        int k =in.nextInt();
        int count = 0;
        int oneStep = 2*k +1;
        if(n%oneStep==0){
            System.out.println(n/oneStep);
            int i=0;
            int pos = k+1;
            count = n/oneStep;
            while (i<count){
                System.out.print(pos+ " ");
                pos+= oneStep;
                i++;
            }
            return;
        }
        if(n- oneStep*(n/oneStep)>k){
            count = n/oneStep;
            count++;
            int pos = k+1;
            int i=0;
            System.out.println(count);
            while (i<count){
                System.out.print(pos+ " ");
                pos+= oneStep;
                i++;
            }
            return;
        }
        int pos =1;
        count = n/oneStep+1;
        int i=0;
        System.out.println(count);
        while (i<count){
            System.out.print(pos + " ");
            pos+= oneStep;
            i++;
        }

    }
}

/*
in = new FastReader();

        int a[]=new int[n];
        for(int i=0;i<n;i++){
            a[i]=in.nextInt();
        }

        Arrays.sort(a);
        int mid = n/2;
        if(a[mid]==s){
            System.out.println(0);
            return;
        }
        long sum=0;
        int Lindex = ModifiedBinarySearch(a,0,a.length-1,s);
        if(Lindex<mid){
            for(int i=Lindex+1;i<=mid;i++){
                sum+=Math.abs(a[i]-s);
            }
        }else{
            for (int i=mid;i<=Lindex;i++){
                sum+=Math.abs(a[i]-s);
            }
        }
        System.out.println(sum);
*/