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 \leq n \leq 1000$, $0 \leq k \leq 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.

Difficulty: interview

Starter code:

Solutions:
n, k = map(int, input().split())
if n <= k + k + 1:
    print(1)
    print((n + 1) // 2)
else:
    answer = -1
    answer_n = 10**100
    for i in range(min(k + 1, n)):
        t = n - (k + i + 1)
        if t % (k + k + 1) >= k + 1:
            if 2 + t // (k + k + 1) < answer_n:
                answer = i + 1
                answer_n = 2 + t // (k + k + 1)
        if t % (k + k + 1) == 0:
            if 1 + t // (k + k + 1) < answer_n:
                answer = i + 1
                answer_n = 1 + t // (k + k + 1)            
    print(answer_n)
    while answer <= n:
        print(answer, end = ' ')
        answer += k + k + 1
        

#import sys
#sys.stdin = open("in.txt", "r")

n, k = map(int, input().split())
one = k*2+1

ans = 0
if n % one == 0: ans = n // one
else: ans = n // one + 1
print(ans)
cnt = 1
arr = []
t = one//2 + 1
minus = 0
while cnt <= ans:
    if t > n:
        minus = t - n
    arr += [t]
    #print("%d" % t, end=" ")
    t += one
    cnt += 1

for s in arr:
    print("%d" % (s-minus), end=" ")


n, k = map(int, input().split())
ans = []
if (n % (2 * k + 1) >= (k + 1) or n % (2 * k + 1) == 0):
    for i in range(n):
        if (i % (2 * k + 1) == k):
            ans.append(i)
else:
    ans.append(0)
    for i in range(k + 1, n):
        if (i % (2 * k + 1) == 0):
            ans.append(i)
print(len(ans))
for el in ans:
    print(el + 1, end=' ')

def __starting_point():
    n, k = map(int, input().split())
    width = 2 * k + 1
    rem = n % width
    print(n // width + bool(rem))
    shift = k if 0 < rem <= k else 0
    current = k + 1 - shift
    while current <= n:
        print(current, end=" ")
        current += width
    print()

__starting_point()

#!/usr/bin/env python3
n, k = list(map(int, input().split()))
x = 2*k+1
r = (n - 1) // x + 1
d = r*x-n
s = max(1, k+1-d)
print(r)
print(' '.join([str(s+x*i) for i in range(r)]))


n,k=map(int,input().strip().split())
f=2*k+1
g=n//f
h=n%f
if (h==0):
    print (g)
    c1=k+1
    print (c1,end=" ")
    for i in range(1,g):
        print (c1+f*i,end=" ")
    print()
    return
if (h>k):
    print (g+1)
    e=h-k
    print (e,end=" ")
    for i in range(1,g+1):
        print (e+f*i,end=" ")
    print ()
    return
if (h<=k):
    print (g+1)
    t=h+2*k+1
    e=1
    print (1,end=" ")
    for i in range(1,g+1):
        print (e+f*i,end=" ")
    print ()
    return

n, k = [int(i) for i in input().split()]

'''
1 2 3 4 5 6 7
1 2 3 | 4 5 6 7
split into 2k groups

if last group < k then problem

if k = 3, n = 7

1 2 3 4 5 6 7

1 2 3 4 5

first sz varies from k+1 to 2*k+1


1 (k+1 - 2k+1) + x(2*k) + 1(2k+1 - k+1)
1 2 3 4 5 6 7 8 9 10

11,2 = 1 6 10
8, 2 = 1 6
'''

places, placee = 0, 0
ans = 2*n
for start in range(k+1, 2*k+2):
    for end in range(k+1, 2*k+2):
        if (n - (start) - (end))%(2*k+1) == 0:
            if 2 + (n-(start)-(end))//(2*k+1) < ans:
                ans = min(ans, 2 + (n-(start)-(end))//(2*k+1))
                places = start
                placee = end

print(ans)
print(places-k, end=' ')
if ans>1:
    for j in range((n-places-placee)//(2*k+1)):
        print(places-k + (j+1)*(2*k+1),end=' ')
    last = placee - k -1 
    print(n-last)
    #print(places - k + (j+1)*(2*k+1)) 


n,k = map(int, input().split())
rem = n % (2*k+1)

if n <= k+1:
	ans = [1]
elif rem <= k and rem != 0:
	ans = range(k+1-(k+1-rem), n+1, 2*k+1)
else:
	ans = range(k+1, n+1, 2*k+1)

print(len(ans))
print(' '.join(str(k) for k in ans))


def mi():
	return map(int, input().split())

n,k = mi()

t = 2*k+1
first = (t+1)//2
out = []
while first<=n:
	out.append(first)
	first+=t
if out==[]:
	out = [n]
if len(out) and (out[-1]+k<n):
	out.append(n)

if len(out)>1 and out[-1]-k<=out[-2]+k:
	diff = (out[-2]+k)-(out[-1]-k)+1
	if diff:
		for i in range(len(out)-1):
			out[i]-=diff
print (len(out))
print (*out)

s=input().split()
n,k=int(s[0]),int(s[1])
l=2*k+1
m=n%l
if m==0:
    m=2*k+1
if m<=k+1:
    pos=1
else:
    pos=m-k
res=n//l
if n%l!=0:
    res+=1
print(res)
for i in range(res):
    print(pos+l*i,end=" ")
print("")



n, k = map(int, input().split())

if n <= 2 * k + 1:
	print(1)
	print(n // 2 + 1)
	return

l = 2 * (k + 1)
r = 2 * (2 * k + 1)
cnt = 0
while not (l <= n <= r):
	cnt += 1
	l += 2 * k + 1
	r += 2 * k + 1

print(cnt + 2)

m = n - cnt * (2 * k + 1)
a = m // 2
ans = [a - k - 1]
r = ans[0] + k

while r < n - 1:
	if r + k + 1 < n:
		ans.append(r + k + 1)
	r = ans[-1] + k

for i in ans:
	print(i + 1, end=' ')
print()

import math
n,k=map(int,input().split())
p=math.ceil(n/(2*k + 1))
a=[]
t=max(1,k+1-(2*k +1 - n%(2*k + 1)) )
if n%(2*k + 1)==0:
    t=k+1
for i in range(p):
    a.append(t)
    t+=(2*k + 1)
print(p)
print(*a)

from math import *
n,k=list(map(int,input().split()))
if(k>=n):
    print(1)
    print(1)
else:
    arr=[]
    count=ceil(n/(2*k+1))
    val1=n%(2*k+1)
    if(val1>=k+1 or val1==0):
        i=0
        val=0
    else:
        i=1
        val=k+1-(k+1-val1)+k
        arr.append(k+1-(k+1-val1))
    while(i<count):
        if(val+k+1<=n):
            arr.append(val+k+1)
        else:
            arr.append(n)
        val+=2*k+1
        i+=1
    print(count)
    print(*arr)


n, k = [int(v) for v in input().split()]
if 2 * k + 1 >= n:
    ans = [n // 2]
else:
    rem = n % (2 * k + 1)
    if rem == 0:
        ans = list(range(k, n, 2 * k + 1))
    else:
        ans = list(range(rem // 2, n, 2 * k + 1))

print(len(ans))
print(' '.join(str(v + 1) for v in ans))


import math
n,k=map(int,input().split())


a=math.ceil(n/(2*k+1))
print(a)

x=a*(2*k+1)-n

if x>=k:
    start=1
else:
    start=1+(k-x)

for i in range(start,n+1,2*k+1):
    print(i,end=" ")







n, k = map(int, input().split())
for i in range(k + 1):
    #print(i + 1 + k)
    ost = n - (i + 1 + k)
    ost = ost % (k * 2 + 1)
    #print(ost)
    if k + 1 <= ost or ost == 0:
        ans = []
        for j in range(i, n, k * 2 + 1):
            ans.append(j + 1)
    #print(ans)
if k == 0:
    ans = [i + 1 for i in range(n)]
print(len(ans))
print(*ans)


n,k=tuple(map(int,input().strip().split(" ")))
l=0
arr=[]
cu=0
yo=n%((2*k)+1)
if(yo>=k+1 or yo==0):
    for t in range(k+1,n+1,(2*k)+1):
        arr.append(t)
else:
    for t in range(1,n+1,(2*k)+1):
        arr.append(t)
print(len(arr))
for k in arr:
    print(k," ",end='')


n, k = map(int, input().split())

r = n % (2*k + 1)

out = []

if r >= k + 1:
    cnt = r - k
    while cnt < n:
        out.append(cnt)
        cnt += 2*k + 1
else:
    cut1 = (r + 2*k + 1) // 2
    cut2 = (r + 2*k + 2) // 2
    cnt = cut1 - k
    if cnt == 0:
        cnt += k + 1
    while cnt <= n:
        out.append(cnt)
        cnt += 2*k + 1

print(len(out))
out = map(str, out)
print(' '.join(out))

import math

n, k = map(int, input().split())
ans = []
i = k + 1
if i > n:
    print(1)
    print(math.ceil(n / 2))
    return
while i <= n:
    ans.append(i)
    i += 2 * k + 1
if ans[-1] + k < n:
    ned = 2 * k - (n - ans[-1]) + 1
    print(len(ans) + 1)
    for i in ans:
        print(i - ned, end = " ")
    print(n)
else:
    print(len(ans))
    print(*ans)


n,k=list(map(int,input().split()))
#b=[i for i in range(1,n+1)]
r=n%(2*k+1)
a=[]
if n<=2*k+1:
    a.append((n+1)//2)
    print(len(a))
    print(*a)
    return
if r>=k+1 or r==0:
    l=[i for i in range(k+1,n+1,2*k+1)]
    print(len(l))
    print(*l)
else:
    d=k+1-r
    s=k+1-d
    l=[i for i in range(s,n+1,2*k+1)]
    print(len(l))
    print(*l)


from functools import reduce

n, k = map(int, input().split())

flip = 2*k+1

l = -(-n//flip)

max = (k+1) + (l-1) * flip
i = k+1
if max > n:
	i -= (max-n)

arr = []
# if n%flip > k:
	# i = k+1
while i <= n:
	arr.append(i)
	i += flip
# else:
	# i = 1
	# while i <= n:
		# arr.append(i)
		# i += flip

s = reduce(lambda x, y : str(x)+' '+str(y), arr)
print(l)
print(s)

n, k = map(int, input().split())
a = 1000000
af = []
for i in range(k+1):
    f = []
    for j in range(i+1, n+1, 2*k+1):
        f.append(j)
    if i+1 > n:
        break
    if f[-1]+k >= n:
        if a > len(f):
            a = len(f)
            af = f[:]
print(a)
print(*af)

from math import ceil

n, k = map(int, input().split(' '))

cover = 2 * k + 1

turns = ceil(n / cover)
print(turns)

shift = turns * cover - n
first_index = k - shift

if first_index >= 0:
    for i in range(turns):
        print(first_index + 1 + i * cover, end=' ')
else:
    for i in range(turns):
        print(0 + 1 + i * cover, end=' ')

n,k = list(map(int,input().split()))
ans=[]
if n%(2*k+1)>=k+1 or n%(2*k+1)==0:
    i=k+1
    while i<=n:
        ans.append(i)
        i+=2*k+1
else:
    i=1
    while i<=n:
        ans.append(i)
        i+=2*k+1
print(len(ans))
print(*ans)


n, k = map(int, input().split())
if n % (2 * k + 1) == 0 or n % (2 * k + 1) >= k + 1:
    if n % (2 * k + 1) == 0:
        print(n // (2 * k + 1))
    else:
        print(n // (2 * k + 1) + 1)
    j = k + 1
    while j <= n:
        print(j, end = ' ')
        j += 2 * k + 1
else:
    print(n // (2 * k + 1) + 1)
    j = 1
    while j <= n:
        print(j, end = ' ')
        j += 2 * k + 1