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

cand = [X]
for i in range(1, K):
    if X+i <= 1000000:
        cand.append(X+i)
    if X-i >= -1000000:
        cand.append(X-i)
cand.sort()
print(*cand)

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

Solution (Python):
k, x = map(int, input().split())
list = []
for i in range(0, k):
    list.append(x-i)
for j in range(0, k):
    list.append(x+j)
list.sort()
list.remove(x)

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

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

Solution (Python):



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

print(*[i for i in range(X - K + 1, X + K) if (i > -1000000 and i < 1000000)])

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()

def main():
    k, x = map(int, input().split())
    ans = [x]
    for i in range(1, k):
        ans.append(x+i)
        ans.append(x-i)
    ans = filter(lambda x: -1000000 <= x <= 1000000, ans)
    print(*sorted(ans))

if __name__ == '__main__':
    main()

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

ans = [X]; tmp1 = X; tmp2 = X
for i in range(K-1):
    ans.append(tmp1+1)
    tmp1 += 1
    ans.append(tmp2-1)
    tmp2 -= 1
    
print(' '.join([str(num) for num in sorted(ans)]))

Solution (Python):
import sys

num = list(map(int,input().split()))
K = num[0]
X = num[1]

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

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

Solution (Python):
(A, B), = [list(map(int, s.split())) for s in open(0)]
nums = []
for i in range(B - A + 1, B + A):
    if (i >= - 1e6) and (i <= 1e6):
        nums.append(i)
print(*nums)

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

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

Solution (Python):
a = []
tmp = []
A,B = map(int,input().split())
b = B-(A-1)
for i in range(A*2-1):
  if A == 1:
    a.append(B) 
  else:
    a.append(b+i)
while a:
  e = a.pop()
  if e <= 10000000 and e>=-10000000:
    tmp.append(e)
tmp = sorted(tmp)
tmp = [str(n) for n in tmp]
p =' '.join(tmp)
print(p)

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(x-(k-1),x+k):
    ans.append(str(i))
print(" ".join(ans))

Solution (Python):
k,x=map(int,input().split())
a=list()
for i in range(k):
    if i==0:
        a.append(x)
        continue
    a.append(x+i)
    a.append(x-i)
b=sorted(a)
print(*b)

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())
lst=[]
for i in list(range(x-(k-1),x+k)):
  lst.append(str(i))
print(" ".join(lst))

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

a_=[]
for i in range(1,2*k):
    result=x-k+i
    if result<-1000000 or 1000000<result:
        continue
    else:
        a_.append(x-k+i)

print(*a_)

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

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

	mae = x-k+1
	ato = x+k-1

	if mae <= -1000000:
		mae = -1000000
	if ato >= 1000000:
		ato = 1000000
	print(' '.join(map(str,list(range(mae,ato+1)))))

if __name__ == '__main__':
	main()

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

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

numbers = [str(i) for i in range(X-K+1, X + K) if i <= 1000000 and i >= -1000000]
output = ' '.join(numbers)
print(output)

Solution (Python):
K,X=map(int,input().split())
A=[]
if X-K+1 < -1000000:
  B= range(-1000000, X+K)
  for i in B:
    A.append(i)
elif 1000000 < X-K+1:
  C= range(X-K+1,1000001)
  for i in C:
    A.append(i)
else:
  D=range(X-K+1,X+K)
  for i in D:
    A.append(i)
print(*A)

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

s = max(-1000000, X - K + 1)
e = min(1000000, X + K - 1)

ans = list(map(str, [i for i in range(s, e+1)]))

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

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

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

x_min = -1000000
x_max = 1000000

a_min = x - k + 1
a_max = x + k - 1
if a_min < x_min:
    a_min = x_min
    a_max = x_min + k - 1
if a_max > x_max:
    a_max = x_max
    a_min = x_max - k + 1
ans = str(a_min)
t = 0
while(t != (a_max - a_min)):
    t += 1
    ans += " " + str(a_min+t)

print(ans)

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

min_nm = b-a+1
max_nm = b+a

l = np.arange(min_nm,max_nm,1).tolist()
ans = map(str,l)
print(' '.join(ans))

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

wrk_min = x + 1 - k 
wrk_max = x - 1 + k 

for i in range(wrk_min,wrk_max + 1):
    if (i >= -1000000) or (i <= 1000000):
        print(i,end=' ')

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

min_n = X - (K - 1)
max_n = (K - 1) + X


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

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

Min = x-k+1
Max = x+k

List = [str(i) for i in range(Min, Max)]

print(*List)

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

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

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

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

Solution (Python):
list = input().split()
k = int(list[0])
x = int(list[1])
min_num = x-k+1
max_num = x+k-1
ans_list = [num for num in range(min_num, max_num+1)]
ans = [ans_list]
print(*ans[0])

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

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

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

print(' '.join(list(map(str,list(range(max(-10**5,X-K+1), min(X+K,10**5+1)))))))

Solution (Python):



_MIN = -1000000
_MAX = 1000000

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


candidate_min = max(X - K + 1, _MIN)
candidate_max = min(X + K - 1, _MAX)

print(" ".join(map(str, range(candidate_min, candidate_max + 1))))

Solution (Python):
while True:
    L=lambda:list(map(int,input().split()))
    k,x=L()
    if x>=0 and x<=100 and k>=1 and k<=100:
        break
c =[]
for i in range(x-k+1,x+k,1):
    c.append(i)
c = [str(int) for int in c]
print(' '.join(c))

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=' ')
print('')

Solution (Python):
import sys

if sys.platform =='ios':
	sys.stdin=open('Untitled.txt')
input = sys.stdin.readline
def INT(): return int(input())
def MAP(): return [int(s) for s in input().split()]

a, b = MAP()
c = list(range(b-(a-1),b+(a)))

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

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

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

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

a = [0] * (K*2 -1)

for i in range(X - (K - 1), X + (K - 1) +1) :
    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())
a = [i for i in range(X-K+1,X+K)]
for i in range(X-K+1,X+K):
    print(i, end=' ')

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

base=[]

if X<=-1000000+K:
    for i in range(K):
        base.append(-1000000+K)
        if X+i>-1000000+K:
            base.append(X+i)
    answer=sorted(base)
else:
    for j in range(K):
        base.append(X-j)
        if j>=1:
            base.append(X+j)
    answer=sorted(base)

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

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

a = [x for x in range(x - k + 1, x + k)]
print(*a)

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

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

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

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

Solution (Python):
data = list(map(int,input().split()))
K = data[0]
X = data[1]

min = X - K + 1
max = X + K

coordination = list(map(str,list(range(min,max))))
ans = ' '.join(coordination)
print(ans)

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

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

Solution (Python):

kx = list(map(int,input().split()))
k = kx[0]
x = kx[1]

lower_lim = x - k + 1
upper_lim = x + k - 1

ans = list(range(int(lower_lim), int(upper_lim+1)))
print(*ans)

Solution (Python):
K, N = map(int, input().split())
L = [v for v in range(N - K + 1, N, 1)]
R = [v for v in range(N, N+K, 1)]
L.extend(R)
set(L)
LLL = sorted(list(L))
print(" ".join(list(map(str, LLL))))

Solution (Python):
L=[]
K,X=map(int,input().split())
if X-(K-1)<=-1000000:
  S=-1000000
  for i in range(S,S+(K*2-1)):
    L.append(str(i))
  print(" ".join(map(str,L)))
elif X+(K-1)>=1000000:
  E=1000000
  for i in range(E,E-(K*2-1),-1):
    L.append(str(i))
  print(" ".join(map(str,L)))
else:
  S=X-(K-1)
  for i in range(S,S+(K*2-1)):
    L.append(str(i))
  print(" ".join(map(str,L)))

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

max=X+(K-1)
min=X-(K-1)

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

print("")

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

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

z = [int(x)]
for i in range(1,int(k)):
  small = int(x) - i
  large = int(x) + i
  z.append(small)
  z.append(large)
  
ans = sorted(z)
print(*ans)

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

for i in reversed(range(K)):
    if X - i >= -1000000:
        print(X - i, end=" ")
        
for i in range(1, K):
    if X + i <= 1000000:
        print(X + i, end=" ")

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

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

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

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

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

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

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

for i in range(2*k-1):
	
	print( i + (x-k+1) )

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

result = range(X - K + 1, X + K)

print(*result)

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

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())
ans=""
for i in range(1,2*k):
    if -1000001<x-k+i<10000001:
        ans += str(x-k+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())
for i in range(-K+1,K):
    print(X+i)

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

Solution (Python):
def main():
    i = list(map(int, input().split()))

    k = i[0]
    x = i[1]

    if not(1 <= k and k <= 100 and 0 <= x and x <= 100):
        return

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

    for j in range(max - min + 1):
        print(j + min)
    

if __name__ == "__main__":
    main()

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)
    k, x = map(int, input().split())
    for i in range(x - k+1, x + k):
        print(i, end=' ')


if __name__ == '__main__':
    main()

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

start = x - k+1
end = x + k-1

ans = ''
for i in range(start,end+1):
    ans += '{} '.format(i)
ans = ans[:-1]

print(ans)

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

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());print(*range(x-k+1,x+k))

Solution (Python):
k,x = map(int,input().split())
a = []
if x-k+1<-1000000:
  i = -1000000
else:
  i = x-k+1
while i<=x+k-1:
  a.append(i)
  if i >= 1000000:
    break
  i += 1
print(*a)

Solution (Python):
k,x = map(int, input().split())
below = max([-1000000, x-(k-1)])
upper = min(1000001, x+k)
r= range(below,upper,1)

for i in r:
  print(i, end=' ')

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

Solution (Python):
K, X = list(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)

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 = ["0"] * (k*2-1)
for i in range(k*2-1):
    ans[i] = str(x-k+1+i)
print(" ".join(ans))

Solution (Python):
n,k=map(int,input().split())
d=[i for i in range(k-n+1,k+n)]
s=[]
for i in range(len(d)):
  if -1000000<d[i]<1000000:
    s.append(d[i])
print(*s)

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(" "))
b_min=x-k+1
b_max=x+k
b_list=list(range(b_min,b_max))
print(' '.join(map(str, b_list)))

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

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

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

Solution (Python):

k, x = [int(s) for s in input().split()]
coodinations_black = ''

for i in range(x - k + 1, x + k):
    coodinations_black += str(i) + ' '

print(coodinations_black[:-1])

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())
A = []
for i in range(X-K+1, X+K):
  A.append(str(i))
  
print(" ".join(A))

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

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

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

Solution (Python):

import sys
def input():
    return sys.stdin.readline().rstrip()

def main():
    K, X = map(int, input().split())

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


if __name__ == '__main__':
    main()

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())
A=[]
for i in range(X-K+1,X+K):
  A+=[i]
print(*A)

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

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

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

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

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

Solution (Python):
ko,x=map(int,input().split())
s=max(x-ko+1,-1000000)
print(*list(range(x-ko+1,x+ko)),sep=" ")

Solution (Python):
ko,x=map(int,input().split())
s=max(x-ko+1,-1000000)
print(*[s for s in range(x-ko+1,x+ko)],sep=" ")

Solution (Python):
ko,x=map(int,input().split())
s=max(x-ko+1,-1000000)
while True:
  print(s,end=" ")
  s+=1
  if s>min(ko+x-1,1000000):break

Solution (Python):

import sys



from bisect import bisect_left as bi_l, bisect_right as bi_r






def main():
    k, x = [int(x) for x in sys.stdin.readline().split()]
    stones = range(-10**6, 10**6+1)
    x_place = bi_l(stones, x)
    ans = stones[x_place-(k-1):x_place+(k-1)+1]
    for c in ans:
        print(c, end=' ')
    
if __name__ == "__main__":
    main()

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

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

k = ab[0]
x = ab[1]

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

print(" ".join(ans))

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

ans = 0

start = x - k + 1
end = x + k - 1

ans_array = [str(num) for num in range(start, end+1)]

print(' '.join(ans_array))

Solution (Python):
a = list(map(int,input().split()))
for x in range(a[0]*2-1):
    print(a[1]-a[0]+x+1, end=" ")

Solution (Python):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
import numpy as np
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

[K,X] = inpl()
print(*list(range((X-K+1),(X+K))))

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

coordinate = str(X - K + 1)

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

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

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


def solve():
    _min_tmp = (x - k + 1)
    _max_tmp = (x + k - 1)
    _min = max(-1000000, _min_tmp)
    _max = min(1000000, _max_tmp)

    ans = list(map(str, range(_min, _max + 1)))

    return ' '.join(ans)


print(solve())

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


def solve():
    _min = -1000000
    _max = 1000000

    if (x - k + 1) > _min:
        _min = x - k + 1
    if (x + k - 1) < _max:
        _max = x + k - 1

    ans = list(map(str, range(_min, _max + 1)))

    return ' '.join(ans)


print(solve())

Solution (Python):
import numpy as np
K,X=map(int,input().split(' '))
res=list(map(str,list(np.array(range(2*K-1))+X-K+1)))
print(' '.join(res))

Solution (Python):
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b



def sum_of_arithmetic_progression(s, d, n):
    return n * (2 * s + (n - 1) * d) // 2



def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)



def lcm(a, b):
    g = gcd(a, b)
    return a / g * b


def main():
    K, X = map(int, input().split())
    ans = []
    for i in range(X, X + K):
        ans.append(i)

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

    print(*sorted(ans))


if __name__ == '__main__':
    main()

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

Solution (Python):
limit=1000000
n,a=map(int,input().split())
res=[a-n+1+i for i in range(n*2-1)]
print(*res)

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

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

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())
res = range(x - k + 1, x + k)
print(*res)

Solution (Python):
import sys
input = sys.stdin.readline
def print_ans(K, X):
    """Test Case
    >>> print_ans(3, 7)
    5 6 7 8 9
    >>> print_ans(4, 0)
    -3 -2 -1 0 1 2 3
    >>> print_ans(1, 100)
    100
    """
    ans = [i for i in range(X - K + 1, X + K)]
    print(" ".join(list(map(str,ans))))
if __name__ == '__main__':
    K, X = map(int,input().rstrip().split())
    print_ans(K, X)

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

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

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

Solution (Python):
mi = lambda : map(int, input().split())

k, x = mi()

if x+k>1000000 and x-k+1>=-1000000:
    ans = list(range(x_k+1, 1000001))
elif x+k<=1000000 and x-k+1<-1000000:
    ans = list(range(-1000000, x+k))
elif x+k>1000000 and x-k+1<-1000000:
    ans = list(range(-1000000, 1000001))
else:
    ans = list(range(x-k+1, x+k))

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())
ans = []
for i in range(X - K + 1, X + K):
    ans.append(i)
print(*ans)

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

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

K, X = map(int, input().split())
min_X = X - K + 1
max_X = X + K - 1

print(*[i for i in range(min_X, max_X+1)])

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())
x=a*-1+1
for i in range(0,a*2-1,1):
    print(b+x,end=" ")
    x=x+1

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

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

for i in range(max(left,-10000000),min(right+1,1000000)):
  print(i,end=" ")

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

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

Solution (Python):



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

    
    first = x - (k - 1)
    last = x + (k - 1)
    while first < last:
        print(first, end=' ')
        first += 1
    print(first)

if __name__ == '__main__':
    main()

Solution (Python):
k, x = map(int, input().split())
xl = [x + i for i in range(-k+1,k) if -1000000 <= i+x and i+x <= 1000000]

for i in xl:
    print(i,end = ' ')

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

Solution (Python):
K,X=map(int,input().split())
for i in range(-K+1,K):
  kuro = X+i
  if kuro >= -1000000 and kuro <= 1000000:
     print(kuro)

Solution (Python):
a = list(map(int,input().split()))
for i in range(max(-1000000, a[1]-a[0]+1), min(1000000,a[1]+a[0]-1)+1) :
  print(i,end = " ")

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

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

ans = [str(i) for i in range(start, end + 1)]

print(" ".join(ans))

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

Solution (Python):
K,X = map(int, input().split())
s_list = list( range( X - K + 1, X + K ))
for i in s_list:
    if i >= -1000000 and i <= 1000000:
        print(i,end=" ")

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

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

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())
stone = " ".join([str(i) for i in range(X + 1 - K, X + K)])
print(stone)

Solution (Python):
k, x = map(int, input().split())
ans = []
t_k = k
t_x = x
while t_k >= 1:
  if t_x not in ans:
  	ans.append(t_x)
  t_x -= 1
  t_k -= 1
  
t_k = k
t_x = x

while t_k >= 1:
  if t_x not in ans:
  	ans.append(t_x)
  t_x += 1
  t_k -= 1
  
ans.sort()
for a in ans:
  print(a, 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())

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

for i in range(minimum, maximum):
    print(i, end="")
    print(" ", end="")
print(maximum)

Solution (Python):
import bisect
k, x = map(int, input().split())
stone = [i for i in range(-1000000, 1000001)]
out = map(str, stone[bisect.bisect_left(stone, x - (k - 1)) : bisect.bisect_right(stone, x + (k - 1))])
print(' '.join(out))

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

Solution (Python):
K, X = map(int, input().split())
import numpy as np
lis = []
for i in range(X-K+1, X+K):
  lis.append(i)
print(*lis)

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

start = b-a+1
loop = (a*2) -1

for i in range(loop):
    print(start + i ,end=" ")

Solution (Python):


def main():
    K,X = map(int, input().split())
    may_kuro_ishi = []
    for i in range(1,K+1):
        may_kuro_ishi.append(X - (K - i))
    for i in range(1,K):
        may_kuro_ishi.append(X+i)

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

if __name__ == "__main__":
    main()

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

for i in range(2*K-1):
    print(X-K+i+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())
for i in range(X - K + 1, X + K):
  print(i, end=' ')

Solution (Python):
kx = list(map(int, input().split()))
 
k = kx[0]
x = kx[1]
ans = [i for i in range(x-k+1, x+k, 1) if (1000000 >= i) and (i >= -1000000) ]
 
for a in ans:
    print(a, end =" ")

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

minP = x - k + 1
maxP = x + k - 1
numlist = list(range(minP, maxP + 1))
strlist = [str(letter) for letter in numlist]
print(" ".join(strlist))

Solution (Python):
K,X = map(int,input().split())
left  = max(-10**6,X-K+1)
right = min(10**6,K+X-1)
ans = " ".join([str(i) for i in range(left,right+1)])
print(ans)

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())
a = [i for i in range(x-k+1, k+x)]
aa = map(str, a)
print(" ".join(aa))

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

Solution (Python):
k, x = map(int, input().split())
min_x = x - k + 1
max_x = x + k
for i in range(min_x, max_x):
  if i < -1000000 or i > 1000000:
    continue
  print(i, end=' ')

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

min = x - (k - 1)
max = x + (k - 1)
a = np.arange(min, max+1, 1)
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 = ' ')

Solution (Python):
K, X = map(int, input().split())
M = X - K + 1
ans = []
for i in range((2 * K) - 1):
  if M + i >= -1000000:
    if M + i <= 1000000:
        print(M + i, end = ' ')

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

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

Solution (Python):
N = 2000001
k, x = map(int, input().split())
p = [i for i in range(-1000000, 1000001)]
filt = list(filter(lambda j: j >= x - (k-1) and j <= x + (k-1), p))
ans = ' '.join(list(map(str, filt)))
print(ans)