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 = [int(v) for v in input().split()]

min_b = max(-1000000, x - (k - 1) )
max_b = min(1000000, x + (k - 1) )
ans = []
for i in range(min_b, max_b + 1):
  ans.append(str(i))
print(" ".join(ans))

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

K, X = mi()
r = [X]
for i in range(1, K):
    r.append(X - i)
    r.append(X + i)
r.sort()
print(' '.join(map(str,r)))

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


number = []
number.append(x)
for i in range(1,k):
    number.append(x+i)
    number.append(x-i)
number.sort()
for m in number:
    if m >1000000 or m<-1000000:
        number.pop(m)
for n in number:
    print(n, end=' ')

Solution (Python):
import sys
import re
INPUT = sys.stdin.readline

def SORO_INT(): return int(INPUT())
def MULT_INT_LIST(): return list(map(int, INPUT().split()))
def MULT_INT_MAP(): return map(int, INPUT().split())
def SORO_STRING(): return INPUT()
def MULT_STRING(): return INPUT().split()

K,X = MULT_INT_LIST()
ans = []
kuro_min = X-K+1
kuro_max = X+K-1
for i in range(kuro_min,kuro_max+1):
    ans.append(i)
ans = str(ans)
ans = ans.replace(",", "")
ans = ans.strip('[]') 
print(ans)

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

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

Solution (Python):
a,b=map(int,input().split())
res = []
for i in range(b-a+1,b+a):
    if i > -1000000 or i < 1000000:
        print(i,end=" ")

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

ans=[]

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

ans=set(sorted(ans))
ans=sorted(list(ans))

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

Solution (Python):
K,X=map(int,input().split())
a=[]
for i in range(K):
    a.append(X-i)
    a.append(X+i)


a.remove(X)
a.sort(reverse=False)

for j in range(2*K-1):
    x=a[j]
    print(x,end=' ')

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

minI = -(10**6)
maxI = (10**6)

Is = [0 for _ in range(2*(10**6)+1)]

for i in range(X,max(minI,X-K),-1):
	Is[i] = 1
	
for i in range(X,min(maxI,X+K)):
	Is[i] = 1
	
for i in range(minI,maxI):
	if Is[i] == 1:
		print(i,end=" ")

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

for i in range(-k + 1, 0):
  for j in range(0, k + 1):
    arr.append(i + j + x) 

sorted_list = sorted(list(set(arr)))

result =  " ".join(map(str, sorted_list))
if (k == 1):
  result = x


print(result)

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

U = 10 ** 6
K,X = map(int,input().split())

L = X - K + 1
R = X + K - 1
L = max(L,-U)
R = min(R,U)

print(*range(L,R+1))

Solution (Python):

import sys


def solve(K: int, X: int):
    res = [X]

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

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

    for i, x in enumerate(sorted(res)):
        print(x, end='')
        if not res.__len__() == i + 1:
            print(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()

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

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

output_list = []

for diff in range(X-(K-1), X+(K)):
    output_list.append(str(diff))
print(" ".join(output_list))

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

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

Solution (Python):
K,X = [int(i) for i in input().split(" ")]
li = []
li1 = []
for i in range(K):
    ans = X - i
    li.append(ans)
    ans1 = X + i
    li1.append(ans1)
    
k = li[::-1] + li1[1:]
for ele in k:
    print(ele , end = " ")

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

Solution (Python):



def main():

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

    saisyo = x - k 

    saidai = x + k -1

    res = []
    while True:
        if saisyo >= saidai:
            break
        saisyo = saisyo + 1
        res.append(saisyo)

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


    

    
if __name__ == "__main__":
    main()

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

maxPoint = X+K
minPoint = X-K+1

list=list(range(minPoint,maxPoint,1))
for i in list:
    print(i, end=" ")

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

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

Solution (Python):
_kx = input().split()
x = int(_kx[0])
k = int(_kx[1])

i_beg = k-(x-1)
i_end = k+(x-1)

str_ret = ''
for i in range(i_beg, i_end+1):
  if i >= -1000000 and i <= 1000000:
    str_ret += str(i) + ' '
print(str_ret.strip())

Solution (Python):


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



P = X - (K - 1) 

R = K * 2 - 1 

if R < 0:
  print(X)
  
else: i = 0 
while i < R:
    print(P)
    P = P + 1
    i = i + 1

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

start = x - k + 1
last = x + k - 1

result = []
result.append(start)

for i in range(1, last - start + 1):
    result.append(start + i)
for i in result:
    if i == start:
	    output = str(i)
    else:
        output = output + " " + str(i)

print(output)

Solution (Python):

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

mini = -1000000
maxi = 1000000

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

if left < mini:
    right = right + (abs(left) - abs(mini))
    left = mini
if right > maxi:
    left = left - (maxi - right)
    right = maxi

while left<=right:
    print(left,end=" ")
    left+=1

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

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

e = list(reversed(d))

f = e + c

g = [str(h) for h in f]

i = " ".join(g)

print(i)

Solution (Python):
k,x=map(int,input().split())
w=x-(k-1)
while(w<x+k):
  print(w,end=" ")
  w=w+1
print()

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

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

k = K-1
count = X - k
for x in range(k*2+1):
    print(count)
    count += 1

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

Solution (Python):


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

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

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

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

if start < -1000000:
    start = -1000000
if end > 1000000:
    end = 1000000

for i in range(start, end + 1):
    if i == end:
        print(str(i))
    else:
        print(str(i) + " ", end="")

Solution (Python):
k,x=map(int,input().split())
l=[]
if x-k>-1000000 and x+k<1000000:
  l=list(range(x-k+1,x+k))
elif x-k<=-1000000:
  l=range(-1000000,x+k)
elif x+k>=1000000:
  l=range(x-k+1,1000000+1)
for i in l:
  print(str(i)+' ',sep='',end='')

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

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

min_val = max(-1000000, X - (K - 1))
max_val = min(1000000, X + (K - 1))

print(" ".join([str(x) for x in list(range(min_val, max_val+1))]))

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

ans = []
a = x - k + 1


for i in range(0, 1+(k-1)*2):
  ans.append(a+i)

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

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

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

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

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

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

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

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

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

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

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

ans = []
for i in range(X-K+1, X+K):
    if -1000000 <= i <= 1000000:
        ans.append(i)
print(" ".join(map(str, ans)))

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

Solution (Python):
a,b=map(int,input().split())
mylist = []
for row in range(a):
  c = row+b
  mylist.append(c)
for row in range(a):
  c = -row+b
  mylist.append(c) 
mylist = sorted(set(mylist))
for row in mylist:
	print(row,end=' ')

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

for i in range(max(X-K+1+1000000, 0),min(X+K+1000000, 2000001)):
  print(i-1000000)

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

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

Solution (Python):
K,X = map(int, raw_input().split())
s,e = max(X-K+1,-1000000), min(X+K-1, 1000000)
print " ".join(map(str, range(s,e+1)))

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

max_ = X + (K-1)
min_ = X - (K-1)

res = ""
for i in range(min_, max_+1):
    if i <= 1000000 and i >= -1000000:
        res += (str(i) + " ")

print(res[:-1])

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

Solution (Python):

from __future__ import print_function
 
k, x = map(int, raw_input().split())
 
for i in range(x-(k-1),x+k):
    print (str(i) + " " ,end="")

Solution (Python):
import numpy as np

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

ans = []
for k in range(2*K-1):
  ans.append(X - (K - 1) + k)

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

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

K = S[0]
X = S[1]


A = X-K+1
B = X+K

for i in range(A, B, 1):
  print(i, end="")
  print(" ", end="")

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

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

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

mini = x - k + 1
maxi = x + k

l = list(range(max([mini,-1000000]),min([1000000,maxi])))
if not l:
  print(x)
else:
  for a in range(len(l)):
    print(l[a],end=" ")

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

Solution (Python):
import sys

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

if K==1:
  print(X)
  sys.exit()

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

Solution (Python):
k,x=map(int, input().split())
a=[x+i for i in range(-k+1,k)]
b=[]
for i in range(len(a)):
    if a[i]>=-(10**6) and a[i] <= 10**6:
        b.append(a[i])
print(" ".join(map(str, b)))

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

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

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

k = int(k)
x = int(x)

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

numbers = list(range(start, end+1))
strs = map(lambda v: str(v), numbers)

text = ' '.join(strs)

print(text)

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

Solution (Python):
def main():
    l = input().split()
    k, x = int(l[0]), int(l[1])
    min_x = x - (k - 1)
    max_x = x + (k - 1)
    all = list(range(min_x, max_x+1))
    asn = " ".join([str(s) for s in all])
    print(asn) 
    
if __name__=="__main__":
    main()

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

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

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

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

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

Solution (Python):
K,X=map(int,input().split())
s=[]
for n in range(1,K):
  a=X+n
  b=X-n
  s.append(a)
  s.append(b)
s.append(X)
s=sorted(s)
print(" ".join(map(str, s)))

Solution (Python):
a, b = map(int, input().split())
x = max(-10000,b-a+1)
y = min(10000,b+a-1)

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

print(*ans)

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

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

Solution (Python):
from sys import stdin

def main():
    k, x = [int(x) for x in stdin.readline().rstrip().split()]
    ans = [x]

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

    print(*ans)


if __name__ == '__main__':
    main()

Solution (Python):
def B_OneClue():
    K, X = map(int, input().split())
    point_min = max(X - K +1,  -1000000)
    point_max = min(X + K - 1, 1000000)
    for x in range(point_max - point_min + 1):
        print(x + point_min, end=" ")
    
if __name__ == "__main__":
    B_OneClue()

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

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

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

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

list = []
if K != 1:
  for i in range(min, max + 1):
    list.append(i)
else:
  print(X)
for i in list:
  print(i)

Solution (Python):
K, X = map(int, input().split())
l = X-(K-1) if X-(K-1)>=-1000000 else -1000000
r = X+(K-1) if X+(K-1)<=1000000 else 1000000
print(" ".join(map(str, range(l, r+1))))

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

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

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

if K == 1:
  print(X)
else:
  for i in range(X , X + K):
    arr.append(i)
    
  for j in range(X - K + 1 , X):
    arr.append(j)
    
arr.sort()
map_result = map(str, arr)
result = ' '.join(map_result)
print(result)

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

if K == 1:
  print(X)
else:
  for i in range(X , X + K):
    arr.append(i)
    
  for j in range(X - K + 1 , X):
    arr.append(j)
    
arr.sort()
map_result = map(str, arr)
result = ' '.join(map_result)
print(result)

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

anslist = range(max(-1000000, x-k+1), min(1000001, x+k))
anslist = map(str, anslist)

print(" ".join(anslist))

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

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

output = ''
for i in range(min, (max+1)):
  hoge = str(i) + ' '
  output += hoge

output.rstrip()

print(output)

Solution (Python):
num = input().split()
a, b = int(num[0]), int(num[1])
tmp = []
for i in range(b-a+1,b+a):
  tmp.append(str(i))
print(' '.join(tmp))

Solution (Python):


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

output = ''
n_max = max(-100000, x - k + 1)
n_min = min(100000, x + k)

for i in range(n_max, n_min):
    output += str(i)
    output += ' '

if n_max == n_min:
    print(n_max)
else:
    print(output[:-1])

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

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

Solution (Python):
k,x =map(int,input().split())
min=x-k+1
max=x+k
ans=[None]*(2*k-1)
for i in range(min, max ,1):
  if i == max-1:
    print(i)
  else:
    print(i, end=" ")

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

ans = list()

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

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

r = ""
for item in sorted(set(ans)):
    r += str(item)+" "

print(r)

Solution (Python):
k,x = map(int,input().split())
c = [str(x)]
for y in range(k):
  if k == 1:
    break
  elif y == 0:
    continue
  else:
    if x+y < 1000000:
      c.append(str(x+y))
    if x-y > -1000000:
      c.insert(0,str(x-y))
print(' '.join(c))

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

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

Solution (Python):



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

K = input[0]
X = input[1]


ans = []

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

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

Solution (Python):
inp = input().split(" ")
inp = list(map(int, inp))
K = inp[0]
X = inp[1]
r = list(range(X - K + 1, X + K))
print(*r)

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

P=X-K+1
Q=X+K
L=np.arange(P,Q)
print(*list(L))

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

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

list=[]
for i in range(min,max+1,1):
    list.append(i)

ans=" ".join(map(str,list))

print(ans)

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

if 1000000>=y:
   if x>=-1000000:
        for i in range(x,y,1):
            print(i, end=" ")
   else:
        for i in range(-1000000,y,1):
            print (i, end=" ")
else:
     if x>=-1000000:
        for i in range(x,1000000,1):
            print(i, end=" ")
     else:
        for i in range(-1000000,1000000,1):
            print (i, end=" ")

Solution (Python):
import sys

for line in sys.stdin:
  [a,b] = map(lambda x:int(x),line.split(' '))
  print(' '.join(map(lambda x:str(x),range(b-a+1,b+a))))

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

l = [0]
ans = ''


for i in range(1, k):
    l.append(-i)
    l.append(i)
    
l.sort()

for j in range(len(l)):
    l[j] = l[j] + x
    
for m in l:
    ans += str(m)+' '
    
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())
first, last = 0, 0
first = X - K + 1
last = X + K - 1
l = []
cnt = last - first + 1
for i in range(cnt):
  l.append(str(first+i))
  
result = " ".join(l)
print(result)

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())
L = 2*K
cnt = X - K + 1
ans = ''
for i in range(L):
    if i < L-2:
        ans += str(cnt) + ' '
        cnt += 1
    elif i == L-1:
        ans += str(cnt)
print(ans)

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

x_min = X - K + 1
x_max = X + K - 1

xs = []
for i in range(x_min, x_max+1, 1):
	xs.append(str(i))

print(' '.join(xs))

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

Solution (Python):
def main(text):
    a = list(map(int, text.split()))
    b = []
    for i in range(a[1]-a[0]+1, a[1]+a[0]):
        b.append(i)
    print(" ".join(map(str, b)))


main(input())

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 = x - k + 1
b = x + k - 1

r = list(range(a, b+1))

if a == b:
    print(a)
else:
    print(' '.join(map(str, r)))

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

if(X-K+1 < -1000000):
    ans = range(-1000000, X+K)
elif(X+K-1 > 1000000):
    ans=range(X-K+1,1000000+1)
else:
    ans=range(X-K+1,X+K)

b = list(ans)
print(' '.join(map(str, b)))

Solution (Python):
import numpy as np

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

ans = np.arange(X-K+1, X+K)

print(*ans)

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

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

Solution (Python):
input_data = input().split()
k = int(input_data[0])
x = int(input_data[1])


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

for i in range(min_x, max_x +1):
  print(i, end=" ")

Solution (Python):
import sys
sys.setrecursionlimit(10000000)
def input():
    return sys.stdin.readline()[:-1]
from bisect import *
from collections import *
from heapq import *
from fractions import Fraction

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

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

Solution (Python):
K,X=[int(item) for item in input().split()]
first=max(-1000000,X-K+1)
last=min(1000000,X+K-1)
print(" ".join([str(item) for item in range(first,last+1)]))

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

begin = x - k + 1
end   = x + k - 1

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

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


Ans=[]

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

print( " ".join( repr(e) for e in Ans ) )

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

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

if len(li) == 1:
  print(x)
else:
  print(li[i+1])

Solution (Python):

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

ans_1 = X-N+1
ans_2 = X+N
ans_int = list(range(ans_1, ans_2, 1))

ans=[str(a) for a in ans_int]
ans=" ".join(ans)
print(ans)

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

Solution (Python):


import re
from collections import deque
from functools import reduce
from itertools import permutations
from math import pi
from operator import itemgetter
from operator import mul
from operator import xor
from os import linesep
from queue import PriorityQueue
from sys import stdin


def rline() -> str:
    return stdin.readline().strip()


def rlines(hint: int = 1):
    ret = ['' for i in range(hint)]
    for i in range(hint):
        ret[i] = rline()
    return ret


def htokens(hint: int = 1):
    lns = rlines(hint)
    ret = list(map(lambda ln: ln.split(), lns))
    
    if hint == 1:
        
        ret.append([])
    return ret


def vtokens(hint: int = 1):
    m, _ = htokens()
    wint = len(m)
    ret = [[None] * hint for i in range(wint)]
    for y in range(hint):
        if y != 0:
            m, _ = htokens()
        
        x = 0
        for v in m:
            ret[x][y] = v
            x += 1
    
    if wint == 1:
        
        ret.append([])
    return ret


def rint(radix: int = 10) -> int:
    return int(rline(), radix)


def hints(hint: int = 1, radix: int = 10):
    ret = htokens(hint)
    for i in range(len(ret)):
        ret[i] = list(map(lambda v: int(v, radix), ret[i]))
    return ret


def vints(hint: int = 1, radix: int = 10):
    ret = vtokens(hint)
    for i in range(len(ret)):
        ret[i] = list(map(lambda v: int(v, radix), ret[i]))
    return ret


def mat(hint: int, wint: int):
    return [[None]*wint for i in range(hint)]


def filllist(lst, value: int) -> None:
    
    for i in range(len(lst)):
        lst[i] = value


def isprime(n: int) -> bool:
    if n <= 1:
        return False
    if n in (2, 3, 5):
        return True
    if n % 2 == 0:
        return False
    if n % 3 == 0:
        return False
    lst = int(n**0.5)
    f = 5
    while f <= lst:
        if n % f == 0:
            return False
        if n % (f + 2) == 0:
            return False
        f += 6
    return True


def strmat(matrix, lnsep: str = linesep, fieldsep: str = ' ') -> str:
    return lnsep.join(map(lambda row: fieldsep.join(map(str, row)), matrix))


def strbool(boolval: int) -> str:
    return ['No', 'Yes'][boolval]


def solve() -> None:
    
    (k, x), _ = hints()

    
    arr = [i for i in range(x-k+1, x+k)]
    ans = [arr]

    
    print(strmat(ans))


if __name__ == '__main__':
    solve()

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

mi = X - K + 1
ma = mi + (K * 2 - 2)

mi = max(mi, -1000000)
ma = min(ma, 1000000)

print(' '.join(map(str, range(mi, ma + 1))))

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

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

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

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

Solution (Python):
import numpy as np

k, x = [int(ii) for ii in input().split()]

min_k = max(-1000000, x - (k - 1))
max_k = min(1000000, x + (k - 1))

s = ""
for ii in np.arange(min_k, max_k + 1):
    s += "{} ".format(ii)

print (s)

Solution (Python):
A, B = map(int, input().split())
 
min = B - A + 1
num = A*2-1

values = []
for i in range(num):
  values.append(min)
  min+=1

for value in values:
  print(str(value) + ' ', end="")

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

min_i = max([-1000000, x-k+1])
max_i = min([1000000, x+k-1])

print(" ".join(map(str, range(min_i, max_i + 1))))

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

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

result = np.arange(x-k+1,x+k,1,dtype = 'int')

for i in range(len(result)):
    print(result[i],end = " ")

Solution (Python):
K, X = map(int, input().split())
min_ = max([-1000000, X - K + 1])
max_ = min([1000000, X + K - 1])
print(str(list(range(min_, max_ + 1)))[1:-1].replace(",", ""))

Solution (Python):
K,X=map(int,input().split())
A=[]
i=X-K+1
while  i<=X+K-1:
  A+=[i]
  i+=1
for s in A:
  print(s, end=" ")

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

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

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

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

if start < -1000000:
    start = -1000000
if end > 1000000:
    end = 1000000

output = list(map(str,range(start,end + 1)))

print(' '.join(output))

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

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

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

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

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

Solution (Python):
k,x = map(int, input().split())
a = []
for n in range(k):
  a.append(x+n)
  a.append(x-n)
a.pop(0)
c = sorted(a)
l = [str(b) for b in c]
m = ' '.join(l)
print(m)

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

for i in reversed(range(K)):
    X -= i
    sys.stdout.write(str(X))
    sys.stdout.write(' ')
    X += i

for i in range(1, K):
    X += i
    sys.stdout.write(str(X))
    sys.stdout.write(' ')
    X -= i

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

a=list(range(X-K+1,X+K,1))
for i in a:
    if i<-10**6 or i>10**6:
        a.remove(i)

a=map(str,a)

print(" ".join(a))

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

k = int(i[0])
x = int(i[1])

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

for num in range(min, max):
	print(num, end=" ")
print(max)

Solution (Python):
K,X = [int(s) for s in input().split(" ")]
num_min =  1000000*(-1)
num_max =  1000000

blk_min = max(num_min, X - (K-1))
blk_max = min(num_max, X + (K-1))
out = ""
for i in range(blk_min, blk_max+1):
    out=out+str(i)+" "
    
print(out[:-1])

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

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

x0 = X - K + 1
x1 = X + K
n = abs(x0 - x1)
l = []
for i in range(n):
    l.append(i + x0)

print(*l)

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

Solution (Python):

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

Solution (Python):
k, x = map(int, input().split())
lis = []
for i in range(k):
  lis.append(x+i)
  lis.append(x-i)
set_lis = set(lis)
for i in sorted(list(set_lis)):
  print(i,end=' ')

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

Solution (Python):
from heapq import heappush, heappop
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations
import sys
import bisect
import string
sys.setrecursionlimit(10**6)
def SI():
    return input().split()
def MI():
    return map(int,input().split())
def I():
    return int(input())
def LI():
    return [int(i) for i in input().split()]
YN=['Yes','No']
YNeos='YNeos'
mo=10**9+7
imp='IMPOSSIBLE'
alp=string.ascii_lowercase
num=enumerate(alp)
d=dict()
for i,j in num:
    d[j]=i

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

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