Problem:
 Score : 200 points    Problem Statement There are 2000001 stones placed on a number line. The coordinates of these stones are -1000000, -999999, -999998, \ldots, 999999, 1000000 .  Among them, some K consecutive stones are painted black, and the others are painted white.  Additionally, we know that the stone at coordinate X is painted black.  Print all coordinates that potentially contain a stone painted black, in ascending order.      Constraints  1 \leq K \leq 100  0 \leq X \leq 100  All values in input are integers.         Input Input is given from Standard Input in the following format:  K  X       Output Print all coordinates that potentially contain a stone painted black, in ascending order, with spaces in between.        Sample Input 1 3 7      Sample Output 1 5 6 7 8 9  We know that there are three stones painted black, and the stone at coordinate 7 is painted black. There are three possible cases:   The three stones painted black are placed at coordinates 5 , 6 , and 7 .  The three stones painted black are placed at coordinates 6 , 7 , and 8 .  The three stones painted black are placed at coordinates 7 , 8 , and 9 .   Thus, five coordinates potentially contain a stone painted black: 5 , 6 , 7 , 8 , and 9 .       Sample Input 2 4 0      Sample Output 2 -3 -2 -1 0 1 2 3  Negative coordinates can also contain a stone painted black.       Sample Input 3 1 100      Sample Output 3 100

Solution (Python):
k,x=map(int,input().split())
for i in range(2*k-1):
  print(x-k+1+i)

Solution (Python):
KX=input().split()
K,X=int(KX[0]),int(KX[1])
 
lis = list(range(X-K+1,X+K))
print(*lis)

Solution (Python):
k,x = map(int,input().split())

result = []
for i in range(k*2-1):
    result.append(str(x-k+1+i))
print(' '.join(result))

Solution (Python):
k,x=map(int,input().split())
for i in range(x-k+1,x+k):
    print(i)

Solution (Python):
K, X = map(int, input().split())
ans = range(X - (K - 1), X + K)
print(*ans)

Solution (Python):
K, X = map(int, input().split())

xmin = max(-1000000, X-K+1)
xmax = min(1000000, K+X-1)

print(*[i for i in range(xmin,xmax+1)])

Solution (Python):
k,x=map(int,input().split())

for i in range(x-k+1,x+k):
    print(i,end=' ')

print()

Solution (Python):
k, x = map(int, input().split())
edge = 10**6
left = max( x-k+1, -edge )
right = min( x+k-1, edge )
res = [ i for i in range(left, right+1) ]
print(*res)

Solution (Python):
k, x = map(int, input().split())

start = x-(k-1)

ans = []
for i in range(k*2-1):
    tmp = start + i
    if tmp < -1000000:
        continue
    if tmp > 1000000:
        break
    ans.append(start + i)

print(*ans, sep=" ")

Solution (Python):
K, X = map(int, input().split())
list = [i for i in range(X-(K-1), X+(K-1)+1)]
print(*list)

Solution (Python):
K,X=map(int,input().split())

MIN=max(-1000000,X-(K-1))
MAX=min(1000000,X+(K-1))

L=[str(i) for i in range(MIN,MAX+1)]
L=" ".join(L)

print(L)

Solution (Python):
N, K = list(map(int, input().split()))
print(" ".join([str(K + n) for n in range(-N+1, N)]))

Solution (Python):
k,x=map(int,input().split())
d=[]
for i in range((k-1)*2+1):
  d.append(x-k+1+i)
print(*d)

Solution (Python):
a,b=map(int,input().split())
for i in range(a*2-1):
  print(b-a+1+i,end=' ')

Solution (Python):
K, X = (int(x) for x in input().split())
l = [int(i) for i in range(X - K + 1, X + K)]
print(*l)

Solution (Python):
K,X=map(int,input().split())

rlist=list(range(X-K+1,X+K))
rlist_str=map(str,rlist)
print(" ".join(rlist_str))

Solution (Python):
K, X = map(int, input().split())
for i in range(X - K + 1, X + K):
    if i < X + K - 1:
        print(i, end=' ')
    else:
        print(i)

Solution (Python):
k, x = map(int, input().split())
a = [0]*(2*k-1)
c = x-k+1
for i in range(len(a)):
    a[i] = str(c)
    c += 1
a = " ".join(a)
print(a)

Solution (Python):
K, X = map(int, input().split())
print(*list(range(X-K+1, X+K)))

Solution (Python):
tmp = list(map(int, input().split()))
k = tmp[0]
x = tmp[1]

for i in range(k*2-1):
  print(x-k+1+i, end=' ')

Solution (Python):
k, x = map(int, input().split())
lower = max(x - k + 1, -1000000)
upper = min(x + k - 1, 1000000)
print(*tuple(range(lower, upper + 1)))

Solution (Python):
K,X = map(int, input().split())

res_list = [X]


for i in range(K-1):
        res_list.append(X - (i+1))
        res_list.append(X + (i+1))

res_list.sort()
print(' '.join(map(str, res_list)))

Solution (Python):
k, m = map(int, input().split())
a = []
if k == 1:
    print(m)
else:
    for i in range(m - k + 1, m + k):
        a.append(str(i))
    print(" ".join(a))

Solution (Python):
def main():
    k,x = [int(x) for x in input().split()]

    start = x-(k-1)
    end = x+(k-1)
    array = [str(start+i) for i in range(end-start+1)]
    print(' '.join(array))

if __name__ == '__main__':
    main()

Solution (Python):
n, x = map(int, input().split())

list = [x]
a = 1

for X in range(n - 1):
  list.append(x + a)
  list.insert(0, (x - a))
  a += 1
str_list = str(list)
strip_list = str_list.strip("[]")
l = strip_list.replace(",", "")
print(l)

Solution (Python):
def t(k, x):
    return ' '.join(map(str, range(x - k + 1, x + k)))


if __name__ == '__main__':
    k, x = map(int, input().split())
    print(t(k, x))

Solution (Python):
k, x = map(int, input().split())
z = []
for i in range(k):
    z.append(x-i)
for i in range(1,k):
    z.append(x+i)
print(*sorted(z))

Solution (Python):
from sys import stdin, exit

input = stdin.readline
lmi = lambda: list(map(int, input().split()))
mi = lambda: map(int, input().split())
si = lambda: input().strip('\n')
ssi = lambda: input().strip('\n').split()

k, x = mi()
for i in range(max(-1000000, x-k+1), min(x+k, 1000000)):
    print(i, end=" ")

Solution (Python):
k,x = list(map(int, input().split()))
for i in range(x-k+1, x+k-1+1, 1):
    print(i, end=" ")

Solution (Python):
K,X = map(int,input().split())

p = X-K+1
for _ in range(2*K-1):
    print(p,end=' ')
    p += 1
print()

Solution (Python):
K, X = map(int, input().split())
min = X-(K-1)
max = X+(K-1)
if min < -1000000:
  min = -1000000
if max > 1000000:
  max = 1000000
li = []
  
for i in range(min,max+1,1):
  li.append(str(i))

print(' '.join(li))

Solution (Python):
if __name__ == '__main__':

	K,X = list(map(int,input().split()))

	start = X - ( K - 1 )
	end   = X + ( K - 1 )

	print(*(list(i for i in range(start,end+1))))

Solution (Python):
K,X = [int(x) for x in input().split()]
ans=[]
for i in range(X-K+1,X+K):
    ans+= [i]

print(*ans)

Solution (Python):
num = input().split(" ")
k = int(num[0])
x = int(num[1])
print (" ".join([str(i) for i in range(x-(k-1), x+k)]))

Solution (Python):
K, X = map(int, input().split( ))

MIN = X - (K-1)
MAX = X + (K-1)
out = str(MIN)

for i in range(MIN+1, MAX+1):
    out += " "+ str(i)
    
print(out)

Solution (Python):
k, x = map(int,input().split())

maxv = x + (k-1)
minv = x - (k-1)
if maxv > 1000000:
  maxv = 1000000
  
if minv < -1000000:
  minv =  -1000000

ans = ''
for i in range(maxv-minv+1):
  ans += ' ' + str(minv+i) 
  
ans = ans.strip()
print(ans)

Solution (Python):
K,X = map(int,input().split())

for i in range(-K+1,K-1):
    print(X+i,end=' ')

print(X+K-1)

Solution (Python):
k, x = map(int, input().split())
i = 0
l = list()
if k == 1:
    print(x)
else:
    while i < k*2-1:
        l.append(x + k - 1)
        x -= 1
        i += 1
l.sort()
print(*l)

Solution (Python):
k, x = map(int, input().split())
l = [i for i in range(x - k + 1, x + k)]
ans = map(str, l)
print(' '.join(ans))

Solution (Python):
k,x = list(map(int,input().strip().split()))
n = 2 * k - 1
a = x - k 
s = str()
for i in range(n):
    a = a + 1
    print(a," ",end="")

Solution (Python):
numbers =input().rstrip().split(" ")
consective =int(numbers[0])
X =int(numbers[1])
minimum =X-consective+1
maximum =X+consective-1
if minimum<=-1000000:
  minimum=-1000000
if maximum>=1000000:
  maximum=1000000
for i in range(minimum,maximum+1):
  print(i ,end=" ")

Solution (Python):
K,X=map(int,input().split())
for i in range(max(X-K+1,-1000000),min(X+K-1,1000000)+1):
    print(i,end=' ')

Solution (Python):
a = list(map(int,input().split()))
K = a[0]
X = a[1]
O = []
for i in range(2*K-1):
    O.append((X-(2*K-1)//2+i))

print(' '.join(map(str, O)))

Solution (Python):
k , x = map(int,input().split())
a = x + k - 1
b = x - k + 1
n = a - b + 1

for i in range(n):
    print(b + i,end=" ")

Solution (Python):
K,X = map(int,input().split())
x = list(range(X-K+1,X+K))
print(" ".join([str(i) for i in x]))

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

K,X = map(int,read().split())

L = X-K+1
R = X+K-1

print(' '.join(map(str,range(L,R+1))))

Solution (Python):
k, x = map(int,input().split())

res = []

for i in range(k):
  Pi = x + i
  Ni = x - i
  if Pi == Ni:
    res.append(Pi)
  elif Pi > 1000000:
    res.insert(0,Ni)
  elif abs(Ni) > 1000000:
    res.append(Pi)
  else:
    res.append(Pi)
    res.insert(0,Ni)


r = [str(i) for i in res]
result = ' '.join(r)
print(result)

Solution (Python):
K,X = map(int,input().split())

for i in range(X-K+1,K+X):
  print(i,end=' ')

Solution (Python):
k, x = map(int,input().split())

black = []
for i in range(x-k+1,x+k):
	black.append(i)
  
print(' '.join(map(str,black)))

Solution (Python):
k,x = map(int,input().split())
l=[]
for i in range(2*k-1):
  l.append(x-(k-1)+i)
s = ' '.join(map(str,l))
print(s)

Solution (Python):
K, X = map(int, input().split())

black = []

for i in range(K*2 -1):
    black.append(X-K+1+i)

print(' '.join(str(i) for i in black))

Solution (Python):
import numpy as np
K, X = map(int, input().split())

a = np.arange(X-K+1, X+K)
print(*a)

Solution (Python):
K,X = map(int,input().split())
R = map(str,list(range(X-(K-1),X+(K-1)+1)))
print(' '.join(R))

Solution (Python):
K, X = map(int, input().split())
ans = [i for i in range(X - K + 1, X + K)]
print(' '.join(map(str, ans)))

Solution (Python):
k,x = map(int,input().split())
ans = range(x-(k-1),x+(k-1)+1)
for i in ans:
  print(i)

Solution (Python):
[K, X] = list(map(int, input().split()))
answer = []
for i in range(X-K+1, X+K):
    if i in range(-1000000,1000000):
        answer.append(i)
print(' '.join(map(str, answer)))

Solution (Python):
a,b=map(int,input().split())
for i in range(b-a+1,b+a):
  print(i)

Solution (Python):
k,x = map(int,input().strip().split())
for i in range(max(-1000000,x-k+1),min(10**6,x+k)):
    print(i,end=' ')
print()

Solution (Python):
a, b = map(int, input().split())
print(*range(b-a+1,b+a))

Solution (Python):
K, X = map(int, input().split())

list = []
for i in range(X-K+1, X+K):
	list.append(i)

print(' '.join(map(str, list)))

Solution (Python):
S = input().split()
K = int(S[0])
X = int(S[1])

ansl = []
j = 0
for i in range(-200,200):
    if i > X - K and i < X + K:
        ansl.append(i)
for a in ansl:
    s = str(a)
    print(s, end="")
    if len(ansl)-1 != j:
        print(" ", end="")
        j+=1

Solution (Python):
K,X= map(int, input().split())

print(*range(X-(K-1), X+K))

Solution (Python):
k,x = map(int,input().split())

min = x - k + 1
max = x + k
res = ''

for i in range(min,max):
    res = res + str(i) + ' '

print(res)

Solution (Python):
k,x=[int(x) for x in input().split()]
for i in range(x-k+1, x+k):
  print(i, end=' ')

Solution (Python):
n,m = map(int,input().split())
for i in range(-(n-1),n):
    print(i+m, end=' ')

Solution (Python):
k, x = map(int, input().split())
for i in range(x - k + 1, x + k):
    print(i, end=' ')

Solution (Python):
K, X = map(int, input().split())
min = X - (K - 1)
max = X + (K - 1)

for i in range(min, max + 1):
    print(i, end=' ')

Solution (Python):
from sys import exit

if __name__ == "__main__":
    k, x = map(int, input().split())
    if k == 1:
        print(x)
        exit()

    for i in range(x - k + 1, x + k):
        print(i, end=" ")
    print()

Solution (Python):
K,X = map(int, input().split())
list = []
for k in range(2*K-1):
  list.append(X-(K-1)+k)
print(*list)

Solution (Python):
K, X = map(int, input().split())

ans = [i for i in range(X-K+1, X+K)]

print(*ans)

Solution (Python):

def main():
    K, X = [int(x) for x in input().split()]
    left = X - K + 1
    right = X + K
    ans = range(left, right)
    print(*ans)


if __name__ == "__main__":
    main()

Solution (Python):
k, x = map(int, input().split())  

for i in range(x-k+1, x+k):
    print(str(i)+" ", end="")
print()

Solution (Python):
k,x=map(int,input().split())
print(*[i for i in range(x-k+1,x+k)])

Solution (Python):
k,x=map(int,input().split())

L=[]
for i in range(x-(k-1),x+(k-1)+1):
      L.append(str(i))
print(' '.join(L))

Solution (Python):
k, x = map(int, input().split())
black = [i for i in range(x-k+1,x+k)]
print(*black)

Solution (Python):
k,x = map(int,input().split())
l = x - k + 1
r = x + k
if l < -100000:
  r -= l + 100000
  l = -100000
if r > 100001:
  l -= r - 100001
  r = 100001
A = range(l,r,1)
print(' '.join(map(str,A)))

Solution (Python):
K, X = map(int, input().split())

a = X - 1 + K
b = X + 1 - K

A = list(range(X, a+1))
B = list(range(b, X))

ans = ' '.join(map(str, B+A))
print(ans)

Solution (Python):

k, x = map(int, input().split())
if k == 1:
    print(x)
    exit()
print(" ".join(map(str, list(range(x - k + 1, x + k )))))

Solution (Python):
K, X = map(int, input().split())

l = max(-1000000, X - K + 1)
r = min(1000000, X + K - 1)
print(*[i for i in range(l, r + 1)])

Solution (Python):
k,x=map(int,input().split())
list=[x+i for i in range(-k+1,k)]
print(*list)

Solution (Python):
str_list = input().split(' ')
int_list = [int(x) for x in str_list]

K, X = int_list[0], int_list[1]

import numpy as np
x = np.arange(X-K+1, X+K)
for i in range(len(x)):
    if i < len(x)-1:
        print('%d ' % x[i], end="")
    else:
        print(x[i])

Solution (Python):
k,x=map(int,input().split())
g=x-k+1
for i in range(k*2-1):
  print(i+g,end=" ")

Solution (Python):
a=input()
A=a.split()
B=[]
for i in range(2*int(A[0])-1):
   B.append(int(A[1])-int(A[0])+1+i)
L=[str(a) for a in B]
L=" ".join(L)
print(L)

Solution (Python):
import numpy as np
k,x = map(int,input().split())
ans = np.arange((x-k+1),(x+k))
for i in range(len(ans)):
    print(ans[i], end = " ")

Solution (Python):
k,x = map(int,input().split())
for i in range(-k+1,k):
    print(x+i,end=' ')

Solution (Python):
k, x = map(int, input().split())
print(' '.join(map(str, range(x- k + 1, x + k ))))

Solution (Python):
K, X = map(int, input().split())
min_X = X - (K - 1)
max_X = X + (K - 1)
answer_list = [i for i in range(max(min_X, -1000000), min(max_X + 1, 1000001), 1)]
print(" ".join(map(str, answer_list)))

Solution (Python):
k,x= map(int, input().split())

def printRange(a,b): 
	for i in range(a,b+1):
		print(i,end=' ')

printRange(max(x-k+1,-1000000),min(x+k-1,1000000))

Solution (Python):
k,x=map(int,input().split())
s=''
for i in range(2*k-1):
  s+=str(x-k+1+i)+' '
print(s)

Solution (Python):




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

print(' '.join(map(str, range(x-k+1, x+k))))

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    k, x = list(map(int, input().rstrip('\n').split()))
    print(*([i for i in range(x - k + 1, x + k)]))


if __name__ == '__main__':
    slove()

Solution (Python):
K, X = map(int, input().split())
print(' '.join(map(str, range(X - K + 1, X + K))))

Solution (Python):
K, X = map(int, input().split())
print(*list(range(X-(K-1), X+(K-1)+1)))

Solution (Python):
K, X = map(int, input().split())

ans = []
for i in range(max(-1000000, X - (K - 1)), min(1000000, X + (K - 1)) + 1):
    ans.append(i)

print(' '.join(map(str, ans)))

Solution (Python):
K,X = map(int,input().split())

for i in range(X-K+1,X+K):
  print(i)

Solution (Python):
K, X = map(int, input().split(" "))

for i in range(X - K + 1, X + K):
    print(i)

Solution (Python):
K,X=map(int,input().split())

for i in range(X-K+1,X+K):
    print(i,end=" ")

Solution (Python):
k,x = map(int,input().split())
for i in range(x-k+1, x+k-1):
    print(i, end="")
    print(" ", end="")
print(x+k-1)

Solution (Python):
k, x = map(int, input().split())

l = []
a = x - (k-1)
for _ in range(k*2 - 1):
    l.append(a)
    a += 1
    
print(*l)

Solution (Python):
K,X = map(int,input().split())
cnt = 2 * K - 1
init = X - K + 1
for i in range(cnt):
    print(init + i)

Solution (Python):
K,X=map(int,input().split())
for i in range(X-K+1,X+K):
    print(i)

Solution (Python):
k, x = map(int, input().split())
min_i = x - k + 1
max_i = x + k - 1
min_i = max(min_i, -1000000)
max_i = min(max_i,  1000000)
print(*range(min_i, max_i+1))

Solution (Python):
k,x=map(int,input().split())
for i in range(-k+1,k):
    print(x+i)

Solution (Python):
k, x = map(int, input().split())

l = map(str, list(range(x - k + 1, x + k)))

print(' '.join(l))

Solution (Python):
K, X = map(int,input().split())
for i in range(X-K+1, X+K):
  print(i)

Solution (Python):
K, X = (int(x) for x in input().split())
start = max(X - K + 1, -1000000)
end = min(X + K - 1, 1000000)
for i in range(start, end + 1):
    print(i, end=' ')
print('\n')

Solution (Python):
k,x = map(int, input().split())
a =[i for i in range((x-k)+1,x+k)]
print(*a)

Solution (Python):
k, x = map(int, input().split())
if k > 1:
    print (*([p for p in range(x-k+1,x+1)] + [p for p in range(x+1, x+k)]))
else:
    print (x)

Solution (Python):
k,x=(int(x)for x in input().split())

i=-1*k+1

ans=[] 

for i in range (-1*k+1,k):
    
    ans.append(x+i)
    i=i+1


ans_str = [str(n) for n in ans]

wer=' '.join(ans_str)

print(wer)

Solution (Python):
a=input().split(" ")
K,X=int(a[0]),int(a[1])
ans=[]
for i in range(X-K+1,X+K,1):
    ans.append(str(i))
print(" ".join(ans))

Solution (Python):
K,X=list(map(int,input().split()))
li=[]
for i in range(X-K+1,X+K):
  li.append(i)
print(*li)

Solution (Python):
K,X=input().split()
K=int(K)
X=int(X)
for i in range(X-K+1,X+K):
    if i<X+K-1:
        print(i,end=" ")
    else:
        print(i)

Solution (Python):
K,X = map(int,input().split())

a=[]
for i in range(X-K+1,X):
    a.append(i)
for i in range(X,X+K):
    a.append(i)
set(list(a))

print(*a)

Solution (Python):
from sys import stdin, setrecursionlimit
setrecursionlimit(10000000)

input = stdin.readline
lmi = lambda: list(map(int, input().split()))
mi = lambda: map(int, input().split())
si = lambda: input().strip('\n')
ssi = lambda: input().strip('\n').split()


a, b = mi()
for i in range(max(b-a+1, -1000000), min(b+a, 1000000)):
    print(i, end=" ")

Solution (Python):
a,b=map(int,input().split())
A= b-a +1
s=[]
for i in range(a*2-1):
	s.append(str(A+i))
print(" ".join(s))

Solution (Python):
import sys,queue,copy
sys.setrecursionlimit(10**8)
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

K,X =inpl()

i = X - (K-1)
j = X + K

ans =list()
for a in range(i,j):
    ans.append(str(a))

print(" ".join(ans))

Solution (Python):
k,x = map(int, input().split())
li = []
for i in range(x-k+1, x+k):
    li.append(i)
print(*li)

Solution (Python):
K, X = list(map(int, input().split()))
for x in range(X-K+1, X+K):
    if -10**6 <= x <= 10**6:
        print(x, end=' ')
print()

Solution (Python):
K,X=map(int,input().split())
for i in range(X-K+1,X+K):
    print(i,end=" ")
print()

Solution (Python):
k,x=map(int,input().split())
if x-k+1<-1000000:
  ans1=-1000000
else:
  ans1=x-k+1
if x+k-1>1000000:
  ans2=1000000
else:
  ans2=x+k-1
while ans1<ans2:
  print(ans1,end=' ')
  ans1+=1
print(ans2)

Solution (Python):
import sys
input = sys.stdin.readline


def main():
    K, X = map(int, input().split())
    A = [str(i) for i in range(X-K+1, X+K)]
    print(' '.join(A))

if __name__ == '__main__':
    main()

Solution (Python):


import sys,collections,itertools,re,math,fractions,decimal,random,array,bisect,heapq





def solve(f):
    k, x = f.read_int_list()

    return " ".join(map(str, range(x-k+1, x+k)))


class Reader(object):
    def __init__(self, filename=None):
        self.file = open(filename) if filename is not None else None
        self.case = 1

    def __readline(self):
        return self.file.next().strip() if self.file else raw_input()

    def next_case(self):
        self.file.next()
        self.case += 1

    def read_int(self): return int(self.__readline())
    def read_float(self): return float(self.__readline())
    def read_long(self): return long(self.__readline())
    def read_decimal(self): return decimal.Decimal(self.__readline())
    def read_str(self): return self.__readline()

    def read_int_list(self): return map(int, self.__readline().split())
    def read_float_list(self): return map(float, self.__readline().split())
    def read_long_list(self): return map(long, self.__readline().split())
    def read_decimal_list(self): return map(decimal.Decimal, self.__readline().split())
    def read_str_list(self): return self.__readline().split()

if __name__ == '__main__':
    filename = sys.argv[1] if len(sys.argv) > 1 else None
    f = Reader(filename)
    if f.file:
        while True:
            print "Case 
            try:
                f.next_case()
            except StopIteration:
                break
    else:
        print solve(f)

Solution (Python):
K,X=map(int,input().split())

for i in range(X-K+1,X+K,1):
        print(i)

Solution (Python):
k,x=map(int,input().split())
min_x=x-k
max_x=x+k
ans=[]
for i in range(min_x+1,max_x):
    ans.append(i)
print(*ans)

Solution (Python):
K,X=map(int,input().split())

print(*range(X-(K-1),X+K))

Solution (Python):
K,X=map(int,input().split())
print(*range(X-(K-1),X+K))

Solution (Python):
K,X=map(int,input().split())
ANS= list(range(X-(K-1),X)) + list(range(X, X+K))
print(' '.join([str(i) for i in ANS]))

Solution (Python):
k,x=map(int,input().split())
ans=""
for i in range(x-k+1,x+k):
    ans+=str(i)+" "
    
print(ans)

Solution (Python):
K,X=map(int,input().split())
list=[]
for i in range((2*K)-1):
	list.append(X-(K-1)+i)
print(*list)

Solution (Python):
K, X = map(int, input().split())

l = list(range(max(-1000000, X-K+1), min(X+K, 1000000)))

L = ' '.join([str(v) for v in l])
print(L)

Solution (Python):
k,x = map(int,input().split())

for i in range(x-k+1,x+k):
    if i != x+k-1:
        print(i,end=' ')
    else:
        print(i)

Solution (Python):
K,X=map(int,input().split())
for i in range(max(-1000000,X-K+1),min(1000000,X+K-1)+1):
    print(i)

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import *
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def A():
    a, b = LI()
    print(max(a + b, a - b, a * b))
    return


def B():
    k, x = LI()
    ans = []
    for i in range(x - k + 1, x + k):
        ans.append(i)
    print(*ans)
    return


def C():
    n = II()
    d = defaultdict(int)
    for _ in range(n):
        s = S()
        s.sort()
        d[tuple(s)] += 1
    ans = 0
    for i in d.values():
        ans += i * (i - 1) // 2
    print(ans)
    return


def D():
    n, m = LI()
    ab = LIR(n)
    ab.sort(key=lambda x: (x[1], x[0]), reverse=True)
    ans = 0
    for i in range(n):
        if m >= ab[i][0]:
            ans += ab[i][1]
            m -= 1
    print(ans)
    return


def E():
    return


def F():
    return


if __name__ == '__main__':
    B()

Solution (Python):
K,X = map(int, input().split())

ans = []
for i in range(1,K):
  ans.append(X+i)
  ans.append(X-i)
ans.append(X)

ans.sort()
print(*ans)

Solution (Python):
k, x = map(int, input().split())
print(' '.join([str(i) for i in range(x - k + 1, x + k)]))

Solution (Python):
k,x=map(int,input().split())
for i in range(x-k+1,x+k):
  print(i)

Solution (Python):
k,x=map(int,input().split())
ans=[]
for i in range(2*k-1):
  ans.append(x-k+1+i)
print(*ans)

Solution (Python):
K,X = map(int,input().split(" "))

for i in range(X-(K-1),X+(K-1)+1):
  print(i,end = " ")

Solution (Python):
a,b=map(int,input().split())
for i in range(b-a+1,b+a):
    print(i,end=" ")

Solution (Python):
K,X = map(int, input().split())

lis = [i for i in range(X-K+1,X+K)]
print(' '.join(map(str,lis)))

Solution (Python):
def solve():
    K, X = map(int, input().split())
    
    for i in range(X-K+1, X+K):
        print(i, end=' ')


if __name__ == '__main__':
    solve()

Solution (Python):
K, X = map(int, input().split())
data = []
data.append(X)
for i in range(1, K):
    num1 = X - i
    num2 = X + i
    if (num1 < -10000) and (num2 > 10000):
        break
    elif (num1 < -10000):
        data.append(num2)
    elif (num2 > 10000):
        data.append(num1)
    else:
        data.append(num1)
        data.append(num2)

sort_data = sorted(data)
print(' '.join(map(str,  sort_data)))

Solution (Python):
k,x=map(int,input().split())
r= [i for i in range(x-k+1,x+k)]
print(' '.join(map(str,r)))

Solution (Python):
k, x = map(int, input().split())
l = max(-1000000, x - k + 1)
r = min(1000000, x + k - 1)
for i in range(l, r + 1):
  print(i)

Solution (Python):
k, x = map(int, input().split())
sa = k-1
zahyous = []
for add in range(-sa, sa+1):
  zahyous.append(str(x + add))
ret_val = " ".join(zahyous)
print(ret_val)

Solution (Python):

K, X = list(map(int,input().split()))
left = max(-1000000,X-K+1)
right = min(1000000,X+K-1)
for i in range(left,right+1,1):
    print(i,end=" ")

Solution (Python):

K, X = list(map(int,input().split()))
left = max(-1000000,X-K+1)
right = min(1000000,X+K-1)
ans = [str(i) for i in range(left,right+1,1)]
print(' '.join(ans))

Solution (Python):

K, X = list(map(int,input().split()))
left = max(-1000000,X-K+1)
right = min(1000000,X+K-1)
if left == right:
    print(left)
else:
    ans = [str(i) for i in range(left,right+1,1)]
    print(' '.join(ans))

Solution (Python):

K, X = list(map(int,input().split()))
left = max(-1000000,X-K+1)
right = min(1000000,X+K-1)
if left == right:
    print(left)
else:
    for i in range(left,right+1,1):
        print(i,end=" ")

Solution (Python):
K, X = map(int, input().split())
print(" ".join([str(i) for i in range(X - K + 1, X + K)]))

Solution (Python):
k, x = map(int, input().split())

for i in range(x-k+1, x+k):
  print(i, end=" ")

Solution (Python):
k, x = map(int, input().split())

for i in range(x-(k-1), x+(k-1)+1):
    if i >= -1000000 and i <= 1000000:
      print(i, end="")
      print(" ", end="")

Solution (Python):
K, X = map(int, input().split())

start = X - K + 1
end = X + K - 1

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

Solution (Python):
K, X = map(int, input().split())
left = X - K + 1
right = X + K

print(" ".join([str(i) for i in range(left, right)]))

Solution (Python):
k, x = map(int, input().split())
for i in range(x-(k-1), x+k):
  print(i, end=" ")

Solution (Python):
def main():
    k, x = map(int, input().split())
    ans = []
    for i in range(-k+1, k):
        ans.append(x+i)
    print(*ans)


if __name__ == "__main__":
    main()

Solution (Python):
K, X = map(int, input().split())
start = X-K+1
end = X+K
ans_list = list(range(start,end))
ans_list = [str(i) for i in ans_list]
print(" ".join(ans_list))

Solution (Python):
K,X = map(int,input().split())
A = X-K+1
B = X + K
for i in range(A,B):
    print(i)

Solution (Python):
K, X = map(int, input().split())
s = X-K+1
e = X+K-1
for i in range(s, e+1):
    print(i, end=" ")

Solution (Python):
K, X = map(int, input().split())
k = K - 1
if X - k < -1000000:
    result = range(-1000000, -1000000+K)
elif X + k > 1000000:
    result = range(1000000-k, 1000001)
else:
    result = range(X-k, X+K)
for i in result:
    print(str(i) + ' ', end='')

Solution (Python):
k ,x = map(int, input().split())

list_a =[]




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

Solution (Python):
K,X = list(map(int,input().split()))

for i in range(2*K-1):
    ans = X - K + 1 + i
    if  ans <= 10**6 and -10**6 <= ans:
        print(ans,end=' ')

Solution (Python):
K, X = map(int, input().split())
for i in list(range(X-K+1, X+K)):
    print(i, end=' ')

Solution (Python):
K, X = map(int, input().split())
ans = list(range(X-K+1, X+K))
for i in range(len(ans)):
    print(ans[i],end=' ')

Solution (Python):
K_X = list(map(int, input().split()))
min_cordinate = K_X[1]-(K_X[0]-1)
max_cordinate = K_X[1]+(K_X[0]-1)
if min_cordinate < -1000000:
    min_cordinate = -1000000
if max_cordinate > 1000000:
    max_cordinate = 1000000

N = (max_cordinate - min_cordinate) + 1
cordinateList = [min_cordinate]
s = ''

for i in range(N-1):
    cordinateList.append(cordinateList[-1] + 1)

for i in range(len(cordinateList)):
    s += ' ' + str(cordinateList[i])
print(s.lstrip(' '))

Solution (Python):
k,x=map(int,input().split())
print(' '.join(map(str,range(x-k+1,x+k))))

Solution (Python):
K,Y = list(map(int,input().split()))
l = []
for i in range(Y - K,Y + K - 1):
	print(i+1, end = ' ')
print()

Solution (Python):
k,x = list(map(int, input().split(" ")))

min_n = (x - k + 1)
max_n = (x + k - 1)

print(" ".join(map(str,range(min_n, max_n + 1))))

Solution (Python):
K, X = map(int, input().split())
for i in range(X - K + 1, X + K):
    print(i, end = ' ')

Solution (Python):
K, X = map(int,input().split())
minstone = max(X-K+1,-1000000)
maxstone = min(X+K-1,1000000)
i = minstone
while i <= maxstone:
    print(i , end=" ")
    i += 1

Solution (Python):
K, X = map(int, input().split())
for n in range(X-K+1,X+K):
    print(n, end=' ')

Solution (Python):
k, x = map(int, input().split())

possible = []

for i in range(x-k+1, x+k):
  possible.append(i)
  
print(*possible)

Solution (Python):
K, X = map(int, input().split())
a=X-K+1
b=X+K
for i in range(a,b):
    print(i)

Solution (Python):
def main():
    k, x = map(int, open(0).read().split())

    min_black = max(-1000000, x - (k - 1))
    max_black = min(1000000, x + (k - 1))
    ans = range(min_black, max_black + 1)
    print(*ans)
    return()

if __name__ == '__main__':
    main()

Solution (Python):
K, X = map(int, input().split())
for i in range(X - (K - 1), X + (K - 1) + 1):
    print(i, end = " ")

Solution (Python):
k,x = map(int,input().split())

li = []
for i in range(x-k+1,x+k):
    li.append(i)

print(*li)

Solution (Python):
K,X = map(int,input().split())
A = ''

for i in range(X-K+1,X+K):
  if(i != X+K-1): A += str(i) +' '
  else: A += str(i)
print(A)

Solution (Python):
K,X = list(map(int,input().split()))
ans=X-K+1
for i in range(K*2-1):
    print(ans)
    ans+=1

Solution (Python):
k,x = map(int,input().split()) 

max_x = x+k
min_x = x-k+1

lists = list(range(min_x,max_x))
print(" ".join(map(str, lists)))

Solution (Python):

import sys
import numpy as np


def solve(K: int, X: int):
    start = X - K + 1
    end = X + K - 1
    for i in range(start, end + 1):
        if i == end:
            print(i)
        else:
            print(i, end=" ")

    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    tokens = iterate_tokens()
    K = int(next(tokens))  
    X = int(next(tokens))  
    solve(K, X)


if __name__ == "__main__":
    main()