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(str(x-k+1+i)+" ",end="")

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

Solution (Python):



k, x = [int(x) for x in input().split()]
if x - k + 1 < -1000000:
    mi = -1000000
    ma = x + k - 1
if x + k - 1 > 1000000:
    mi = x - k + 1
    ma = 1000000
else:
    mi = x - k + 1
    ma = x + k - 1
r = map(str, list(range(mi, ma + 1)))
print(" ".join(r))

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

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

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

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

Solution (Python):
a,b = map(int, input().split())

min = b -a + 1
max = b +a - 1

print(*[i for i in range(min,max+1)])

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

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

ans = ' '.join([str(n) for n in range(X-K+1, X+K)])
print(ans)

Solution (Python):




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


if __name__ == "__main__":
    main()

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

K, X = MAP()

for i in range(X - K + 1 , X + K):
	if i < -1000000:
		continue
	if i > 1000000:
		continue
	print(i, "", 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())
for i in range(X-K+1, X+K):
    print(i, end=" ")

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

def create_num(K,X):
    ans = [X-(K-1) + i for i in range(K*2-1)]
    return ans

if K == 1:
    print(X)
else:
    ans = create_num(K,X)
    L=[str(a) for a in ans]
    L=" ".join(L)
    print(L)

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())

print(*list(range(x-k+1, x)) + list(range(x, x+k)))

Solution (Python):
a,b=map(int,input().split())
l=[]
for x in range(a):
    l.append(b-x)
    l.append(b+x)
l.remove(b)
print(" ".join(map(str,sorted(l))))

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

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

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

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

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

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

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())
print(*range(X-K+1, X+K))

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

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

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 = list(map(int, input().split()))
print(*range(X-K+1, X+K))

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

Solution (Python):
k, x = map(int, input().split())
ans_list = range(x-k+1, x+k)


print(*ans_list)

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

ans_list = []
for i in range(x-k+1, x+k):
    if -1000000 <= i <= 1000000:
        ans_list.append(str(i))

print(" ".join(ans_list))

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

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())
Brack=range(X-K+1,X+K)
print(*Brack)

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

Solution (Python):
a,b=map(int,input().split())

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

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

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

for i in range(len(List)):
    print(List[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())
if (X-K+1 > -1000000) and (X+K < 1000000):
  print(' '.join([str(i) for i in range(X-K+1, X+K)]))
elif (X-K+1 < -1000000) and (X+K < 1000000):
  print(' '.join([str(i) for i in range(-1000000, X+K)]))
elif (X-K+1 > -1000000) and (X+K > 1000000):
  print(' '.join([str(i) for i in range(X-K+1, 1000000)]))
elif (X-K+1 < -1000000) and (X+K > 1000000):
  print(' '.join([str(i) for i in range(1000000, 1000000)]))

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

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

right = X + K_ko - 1
right = min(right, 10 ** 6)
left = X + 1 - K_ko
left = max(left, -10 ** 6)

for i in range(left, right + 1):
    print(i,end=" ")

Solution (Python):
k, x = map(int, input().split())
max = x + k - 1
min = x - k + 1
ans = [i for i in range(min, max+1)]
print(*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())
m = x-k+1
M = x+k-1
for i in range(m, M+1):
  print(i , end=" ")

Solution (Python):
n,k=map(int,input().split())
s1=set()
s2=set()
for i in range(n):
    s1.add(k-i)
for j in range(n):
    s2.add(k+j)
print(" ".join(map(str,sorted(s1|s2))))

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

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

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

minimum = max(-1000000, x-k+1)
maximum = min(1000000, x+k-1)

ans = ''
for i in range(minimum, maximum+1):
  ans = ans + str(i) + ' '

print(ans)

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

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

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

result=[]

for i in range(x-k+1,x+k):
    result.append(str(i))

print(" ".join(result))

Solution (Python):
import sys

input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]

IN=lambda : map(int, input().split())
mod=1000000007



def main():
	b , c = IN()
	s = list(range(c-b+1,c+b-1+1))
	print(' '.join([str(c) for c in s]))
	
	

isTest=False

def pa(v):
	if isTest:
		print(v)
		
def input_clipboard():
	import clipboard
	input_text=clipboard.get()
	input_l=input_text.splitlines()
	for l in input_l:
		yield l

if __name__ == "__main__":
	if sys.platform =='ios':
		if input_method==input_methods[0]:
			ic=input_clipboard()
			input = lambda : ic.__next__()
		elif input_method==input_methods[1]:
			sys.stdin=open('inputFile.txt')
		else:
			pass
		isTest=True
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)

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

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

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

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

a=list(range(-k+1,k))

for b in a:
    print(x+b,"",end="")

Solution (Python):

import sys
sys.setrecursionlimit(10000000)
INF = 1<<32


def solve(K: int, X: int):
    print(' '.join(map(str, [i for i in range(max(-1000000, X-K+1), min(1000000, X+K))])))
    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()

Solution (Python):
k, x = map(int, input().split())
ans = ""
if k == 1 :
	print(x)
	exit()

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

print(ans)

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

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

output = []

for i in range(X - K + 1, X + K):
    output.append(str(i))

print(" ".join(output))

Solution (Python):

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

mn = max(x - k+1, -20000)
mx = min(x + k-1, 20000)
res = [str(i) for i in range(mn, mx+1)]
print(' '.join(res))

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())
k=k-1
num=[i for i in range(x-k,x+k+1)]
ans=""
for n in num:
    ans+=(str(n)+" ")
print(ans)

Solution (Python):
k,x=(int(x) for x in input().split())
left=x-(k-1)
right=x+(k-1)
l=[]
while(left<=right):
    if -1000000<=left<=1000000:
        l.append(str(left))
    left+=1
print(" ".join(l))

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

Solution (Python):
k, x = map(int, input().split())
A = list(range(x - k + 1, x + k))
print(*A)

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

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

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

ans = []

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

print(*ans)

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

lst = []

def chk(num):
    if num < -1000000:
        return -1000000
    elif num > 1000000:
        return 1000000
    else:
        return num

for i in range(x-k + 1, k + x):
    lst.append(chk(i))

print(*sorted(lst))

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

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

res = ""
for i in range(X-(K-1), X+K):
    res += " " + str(i)

print(res[1:])

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

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

s = ""
first = X - K + 1
for i in range(K*2 - 1):
    s += " " + str(first + i)
print(s[1:])

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

s = ""
first = X - K + 1
for i in range(K*2 - 1):
    s += " " + str(first + i)
print(s)

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

st = X-(K-1)
ed = X+(K-1)

res = ""
for i in range(max({-1000000, st}), min({ed, 1000000})+1):
    res += " " + str(i)

print(res[1:])

Solution (Python):
K,X=map(int,input().split())
list_x=[0]*(((K-1)*2)+1)
k=K-1
p=0
for i in range(K-1):
  list_x[p]=X-k
  k=k-1
  p=p+1
list_x[p]=X
k=1
p=p+1
for i in range(K-1):
  list_x[p]=X+k
  k=k+1
  p=p+1
for i in range(((K-1)*2)+1):
  print(str(list_x[i])+' ',end='')

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

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

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

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

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

Solution (Python):
k,x = map(int,input().split())
l = []
a = ""
for i in range(x-k+1,x+k):
    if -1000000 <= i <=100000:
        l.append(i)

l = [str(j) for j in l]
print(" ".join(l))

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

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

begin = x - k + 1
end = x + k - 1
if begin < -1000000:
    begin = -1000000
if end > 1000000:
    end = 1000000

print(" ".join(str(i) for i in range(begin, end + 1)))

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

if x-k+1<=-1000000:
  a=-1000000
else: a=x-k+1
if x+k-1>=1000000:
  b=1000000
else:b=x+k-1

print(*range(a,b+1))

Solution (Python):

K,X=map(int,input().split())
lis=[]
st=""
lis=list(range(X-K+1,X+K,1))


for i in range(len(lis)):
    st="".join((st," ",str(lis[i])))
st=st.strip()
print(st)

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())

li = []

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

print (*li)

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

l = []
for i in range(-(k-1), k):
    if -1000000 <= x+i and x+i <= 1000000:
        l.append(x + i)

for i in l:
    print(i, end=" ")

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

print(*li)

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())
for i in range(x-k+1,x+k):
    print(i,end=' ')

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

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

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

print()

Solution (Python):
def LI():
  return [int(s) for s in input().split()]

K,X = LI()



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

Solution (Python):
k,x = map(int,input().split())
print(*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())

A = ""
for i in range(2*K-1):
  A += str(X-K+1+i) +" "

print(A)

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

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

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

if __name__ == '__main__':
    main()

Solution (Python):
kx = list(map(int, input().split()))
k, x = kx[0], kx[1]
minimum = x - k + 1
maximum = x + k - 1
minimum = max(minimum, -1000000)
maximum = min(maximum, 1000000)
r = [i for i in range(minimum, maximum + 1)]
print(" ".join(list(map(str, r))))

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,n=map(int, input().split())
for i in range(2*k-1):
  z=n-k+i+1
  print(z,end=' ')

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

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

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

left = x - (k - 1)
right = x + (k - 1)

row = []

for i in range(left, right +1):
    row.append(str(i))
print(" ".join(row))

Solution (Python):



k, m =map(int, input().split())
n = k - 1
answer = [m]
for i in range(1, n + 1):
    answer.append(m - i)
    answer.append(m + i)
answer.sort()
if k == 1:
    answer = [m]
print(*answer)

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, end=' ')

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())

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

Solution (Python):
K, X = map(int, input().split())
num = X - K + 1
ans = []
while num < (X + K):
    ans.append(str(num))
    num += 1

print(' '.join(ans))

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

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

print(' '.join(ans))

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

ans = range(x-(k-1), x+k)

print(*ans)

Solution (Python):
import sys
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())
def FLIST(n):
    res = [1]
    for i in range(1, n+1): res.append(res[i-1]*i%DVSR)
    return res
def gcd(x, y):
    if x < y: x, y = y, x
    div = x % y
    while div != 0:
        x, y = y, div
        div = x % y
    return y

K,X=LI()

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

Solution (Python):
def main():
    k, x = map(int, input().split())
    l = list(range(max(x-k+1, -1000000), min(x+k,1000000)))
    print(*l)

if __name__ == '__main__':
    main()

Solution (Python):
"""
author : halo2halo
date : 11, Jan, 2020
"""

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

A, B = map(int, read().split())

l, r = B - (A - 1), B + (A - 1)
ans = [str(i) for i in range(l, r + 1)]
print(' '.join(ans))

Solution (Python):
inputA,inputB =map(int, input().split(' '))




if inputA == 1:
    print(inputB)
else:
    for count in reversed(range(0,inputA,1)):
        print(inputB-count)
    for count in range(1,inputA,1):
        print(inputB+count)

Solution (Python):
import numpy as np

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

l = np.zeros(2*K-1)

for i in range(2*K-1):
    l[i] = X - (K-1-i)

for i in l:
    print(int(i), end=' ')

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

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())
x1=x-(k-1)
x2=x+(k)
for i in range(x1,x2):
    print(i,end=' ')

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

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

Min = X - K + 1
Max = X + K - 1

ans = list(range(Min, Max+1))

for i in ans:
	print(i, end=" ")

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

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

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

print()

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

Solution (Python):
def main():
    K, X = map(int, input().split(" "))
    lower = max(X - K + 1, -1000000)
    upper = min(X + K, 1000000)
    ans = ""
    for i in range(lower, upper):
        ans = ans + str(i) + " "
    print(ans[:-1])


if __name__ == '__main__':
    main()

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

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

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

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())

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)


def main():
    k,x = LI()

    return JA(range(x-k+1,x+k), " ")


print(main())

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())
a = list(range(x-k+1, x+k))
c = map(str, a)
b = ' '.join(c)
print(b)

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

a = X - K +1
b = X + K
ans = []

for i in range(a, b):
    ans.append(i)
print(*ans)

Solution (Python):
def fa(K,X):
    ch=""
    L=[X]
    for i in range(1,K):
        L.append(X-i)
        L.append(X+i)
    L.sort()
    C=str(L)
    ch=C[1:len(C)-1]
    return ch
K,X=map(int,input().split())
print(fa(K,X).replace(",",""))

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

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

print(*l)

Solution (Python):
k, x = [int(_) for _ in input().split()]
a = max([x-k+1, -1000000])
b = min([x+k-1, 1000000])
print(' '.join([str(_) for _ in range(a, b+1)]))

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

K -= 1 
if  -1000000 <= X-K:
	start = X-K 
else:
	start = -1000000

if X+K <= 1000000:
	goal = X+K
else:
	goal = 1000000


ans = list(range(start,goal+1,1))
print(' '.join(map(str,ans)))

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

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

if L < -1000000:
    L = -1000000

if R > 1000000:
    R = 1000000

for x in range(L,R+1):
    print(x, end=" ")

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

Solution (Python):
def main():
    K, X = map(int, input().split())
    for i in range((X-K+1), (X+K)):
        if (i>=((-1)*1000000)) & (i<=1000000):
            print(i, end=" ")
    return 0

if __name__ == '__main__':
    main()

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())
pos = [i for i in range(x-k+1, x+k)]
print(*pos, sep=" ")

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

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

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

_range = list(range(X-(K-1),X+K))



ans = " ".join([str(n) for n in _range])

print(ans)

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

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

ans = []

for i in range(X-K+1,X+K):
    ans.append(str(i))
print(' '.join(ans))

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

min_ = max(-a, X - (K - 1))
max_ = min(a, X + (K - 1))

for i in range(min_, max_ + 1):
  print(i, end ="")
  if i != max_:
    print("",end=" ")

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

ans = list(range(x - k + 1, x + k))

print(*ans)

Solution (Python):



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


s = max(-1000000, X - K)
e = min( 1000000, X + K)
res = ' '.join([str(e) for e in range(s+1, e)])


print(res)

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().strip().split())
for i in range(x-k+1,x+k):
    print(i,end=" ")

Solution (Python):
k, x = map(int, input().split())
rad = k - 1
left = max(-1000000, x - rad)
right = min(1000000, x + rad)
for i in range(left, right+1):
    if i < right:
        print(i, end="")
        print(" ", end = "")
    if i == right:
        print(i)

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

Solution (Python):
A,B = map(int,input().split())
for i in range(B-A+1,B+A-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())

ans = 1

start = max(-1000000,X-K+1)
end = min(1000000,X+K-1)

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

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

Solution (Python):
k, x = map(int, (input().split()))
print(*list(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())
print(' '.join(map(str,[i for i in range(max(-1000000,X-K+1),min(1000000,X+K-1)+1)])))

Solution (Python):

import sys
sys.setrecursionlimit(10000000)
INF = 1<<32


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

    print(' '.join(map(str, ans)))
    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()

Solution (Python):
K, X = map(int, input().split())
S = X -(K-1)
while True:
    if S > X + (K -1):
        break
    print(str(S)+" ", end="")
    S += 1

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

Solution (Python):
n,m = list(map(int, input().split()))
if n==1:
  print(m)
else:
  ans = [m]
  for i in range(n-1):
    ans.append(m-(n-i)+1)
    ans.append(m+i+1)
  ans.sort()
  print(' '.join(map(str, ans)))

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

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

tmp = X + K
tmp2 = X - K + 1

ans = np.arange(tmp2, tmp)
for i, v in enumerate(ans):
    print(' {}'.format(v), end='') if i > 0 else print('{}'.format(v), end='')
print('')

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

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

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

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

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

print(*a)

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

A = []
for i in range(k-2, -1, -1):
    A.append(x-i-1)
for i in range(k):
    A.append(x+i)
s = ""
for i in A:
    s += str(i) + " "
print(s[:-1])

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

for i in range(k):
    lst1.append(x-i)
    lst1.append(x+i)

lst2 = sorted(list(set(lst1)))

print(' '.join([str(_) for _ in lst2]))

Solution (Python):
K, X = [int(i) for i in input().split()]

ans = list(range(X - K + 1, X + K))
print(*ans)

Solution (Python):
k, x = map(int, input().split())
m = x-k+1
M = x+k

if m < -1000000:
  m = -1000000
if M > 1000001:
  M = 1000001

print(' '.join(str(i) for i in range(m, M)))

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
def resolve():
    k,x=map(int,input().split())
    print(*range(x-k+1,x+k))
resolve()

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

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

min = x - ( k - 1 )
max = x + ( k - 1 )

if min < -1000000:
  for i in range(-1000000, max+1):
    ans.append(i)
elif max > 1000000:
  for i in ragne(min, 1000001):
    ans.append(i)
else:
  for i in range(min, max+1):
    ans.append(i)

print(*ans)

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

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())
ans=''
for i in range(x-k+1,x+k):
  ans=ans+' '+str(i)
print(ans)

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

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