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

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

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

ans = []
for i in range(K):
    Y = X - i
    if Y >= -1000000:
        ans.append(Y)
    
for i in range(1,K):
    Y = X + i 
    if Y <= 1000000:
        ans.append(Y)

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

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

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

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

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

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

Solution (Python):
k,x =map(int,input().split())
cons=2000001
mn_cons=int(-1000000)
mx_cons=1000000


mn=x-k+1
mx=x+k

if mn<=mn_cons:
    mn=mn_cons
if mx>=mx_cons:
    mx=mx_cons+1

r=range(mn,mx)
print(" ".join(list(map(str,r))))

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

s = x-k + 1
e = x+k

print(' '.join(map(str, range(s, e))))

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

kazu = k-1

if x-kazu<=-1000000:
    min = -1000000
else:
    min = x-kazu

if x+kazu>=1000000:
    max=1000000
else:
    max=x+kazu

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

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

Solution (Python):

L = map(int, raw_input().split())
K = L[0]
X = L[1]

f = X - K + 1
l = X + K 

ans = []

for i in range(f, l):
    ans.append(str(i))

print " ".join(ans)

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

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

if __name__ == '__main__':
    main()

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

place = b
deff = a - 1

below_pls = place - deff
above_pls = place + deff
if below_pls < -1000000:
    below_pls = -1000000
if above_pls > 1000000:
    above_pls = 1000000

lst = list(range(below_pls, above_pls + 1))
print(' '.join(map(str, lst)))

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

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

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

st = max(x-k,-1000000)
gl = min(x+k, 1000000)

for i in range(st+1,gl):
	print(i)

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


left = X - (K-1)
right = X + (K-1)

print(' '.join(map(str, range(left, right+1))))

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

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

Solution (Python):
if __name__ == '__main__':
    k, x = map(int, input().split())
    k = k-1
    max = k+x+1
    min = x -k
    a =range(min,max,1)
    ans = ""
    for i in a:
        if len(ans) > 0:
            ans = ans + " "+ str(i)
        else:
            ans = str(i)
    print(ans)

Solution (Python):


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


min_x = -1000000
max_x = 1000000

mod_min_x = X - (K-1)
mod_max_x = X + (K-1)

x_list = ""
while mod_min_x <= mod_max_x:
    x_list = x_list + "%s " % mod_min_x
    mod_min_x = mod_min_x + 1

print(x_list)

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

a = 2000001
n = 1000000

A = [str(i - n) for i in range(a)]

b_min = max(-n, x - k + 1) + n
b_max = min(n, x + k) + n

C = A[b_min : b_max]
C =" ".join(C)
print(C)

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

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

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

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

print(*ans)

Solution (Python):
s_min = -1000000
s_max = 1000000
K, X = map(int, input().split())


b_min = X - K + 1
while b_min < s_min:
    b_min += 1

b_max = X + K - 1
while b_max > s_max:
    b_max -= 1


for i in range(b_min, b_max+1):
    if i == b_max:
        print(i)
    else:
        print(i, end=' ')

Solution (Python):
i = list(map(int,input().split()))
s = i[0] - 1
g = []

mn = i[1] - s
mx = i[1] + s

for f in range(mn,mx+1):
    g.append(str(f))

L=' '.join(g)
print(L)

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

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

for s in li:
    print(s, end =" ")

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

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

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

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

for i in range(k):
  ans.insert(0, str(x - i))

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

print(' '.join(ans))

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

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

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

s = []

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

s = map(str, s)

l = ' '.join(s)

print(l)

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

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

Solution (Python):
k, x = [int(col) for col in input().split(' ')]
max_prob = x + k - 1
min_prob = x - k + 1

rslt = [str(col) for col in range(min_prob, max_prob + 1)]
rslt = ' '.join(rslt)
print(rslt)

Solution (Python):

a = list(map(int, input().split(" ")))
x = a[0] - 1
y = a[1] - x
z = x * 2 + 1
p = y

for i in range(z):
    if i > 0:
        print(" ", end="")
    print(p, end="")
    p = p + 1

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

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

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

Solution (Python):
k,x=map(int,input().split(" "))
if x-(k-1)<-1000000:
    mi=0
else:
    mi=x-(k-1)
s=[x-(k-1)]
i=1
while i!=2*k-1:
    if (x-(k-1)+i)>1000000:
        break
    else:

        s.append(x-(k-1)+i)
        i+=1
print(" ".join(map(str,s)))

Solution (Python):
import math

K,X=list(map(int,input().split()))
imin = X-K+1
imax = X+K-1
rmin = -1000000
rmax = 1000000
if imin >= rmin and imax <=rmax:
    for i in range(imin,imax+1):
        print(i,end=" ")
elif imin < rmin and imax <=rmax:
    for i in range(rmin,imax):
        print(i,end=" ")
elif imin >= rmin and imax >rmax:
    for i in range(imin,rmax):
        print(i,end=" ")

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

s = x - k + 1
e = x + k - 1
ls = []
for i in range(s, e+1):
  ls.append(i)
print(" ".join(map(str, ls)))

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

m = [str(i) for i in range(x-k+1,x+k)]

s = ''

for i in range(len(m)):
    s = s+m[i]+' '

print(s)

Solution (Python):
katamari, known = map(int, input().split())

bottom = max(-100000, known-katamari+1)
top = min(100000, known+katamari)
i = bottom
while i < top:
    print(i, end = " ")
    i += 1

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

print(' '.join([str(i) for i in range(max(-1000000,x-k+1),min(1000000,x+k-1)+1)]))

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

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

Solution (Python):
K, M = [int(s) for s in input().split()]
lb = max([-1000000, M-K+1])
ub = min([1000000, M+K-1])
print(' '.join([str(i) for i in list(range(lb, ub+1))]))

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

Solution (Python):
n = [int(i) for i in input().split()]
x_plus = n[1] + 1000000
res = []
for i in range(x_plus-n[0]+1, x_plus+n[0]):
    res.append(str(i-1000000))
print(" ".join(res))

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

if x-k+1>=-100000:
  if x+k-1<=100000:
    for i in range(2*k-1):
      print(x-k+1+i)

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

else:
  for i in range(x-100000+k-1):
        print(-100000+i)

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

Solution (Python):
n = 2000001
kagen = -1000000
jogen = 1000000
k, x = map( int, input().split() )

ans = ""
for i in range( x - (k-1),  x + (k-1)+1 ) :
	if i < kagen :
		continue
	if jogen < i :
		continue
	ans += str( i ) + " " 


print( ans.strip() )

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

l = x-k+1
r = x+k-1

ans = []
a = ""

if l < -1000000:
    l = -1000000
if r > 1000000:
    r = 1000000
for i in range(l,r+1):
    ans.append(i)
for i in range(len(ans)):
    a += " " + str(ans[i])
print(a)

Solution (Python):
k, x = input().split(' ')
k, x = int(k), int(x)   
arr = []
         
for i in range(k): 
  arr.append(x-i)
  arr.append(x+i)
arr = list(set(arr))
arr.sort()
text = ""
for i in range(len(arr) - 1):
  text += str(arr[i]) + " "
print(text + str(arr[len(arr) - 1]))

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

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

print(' '.join(map(str, 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())
minnum=x-k+1
for i in range(2*k-1):
  print(minnum+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())

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

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

Solution (Python):
from sys import stdin


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


res = []
for i in range(k-1):
    n = x-(i+1)
    if -1000000 <= n and n <= 1000000:
        res.append(n)
res.append(x)
for i in range(k-1):
    n = x+(i+1)
    if -1000000 <= n and n <= 1000000:
        res.append(n)
res.sort()
res = map(str, res)
print(" ".join(res))

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

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

print(*result)

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

min = k-1
n = x - min

for a in range(min *  2 + 1):
  print(n)
  n = n + 1

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

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=list(map(int,input().split()))
L=[str(i) for i in range(X-K+1,X+K)]
L=' '.join(L)
print(L)

Solution (Python):
import sys


def input():
    return sys.stdin.readline()[:-1]


def main():
    k, x = map(int, input().split())
    f = x-k+1 if x-k+1 > -1000000 else -1000000
    l = x+k-1 if x+k-1 < 1000000 else 1000000
    ans = [i for i in range(f, l+1)]
    print(*ans)


if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

x1 = x - k + 1
x2 = x + k

l = list(map(str, list(range(x1, x2))))
s = ' '.join(l)
print(s)

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

stt = x - (k - 1)
end = x + k
intrange = range(stt, end)
strrange = [str(i) for i in intrange]

print(' '.join(strrange))

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

Solution (Python):
k,x = map(int,input().split())
n = 2*(10**6)+1

l = []

for i in range(x-k+1,x+k):
    l.append(i)
else:
    print(" ".join(map(str, l)))

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

Solution (Python):
k,x=map(int,input().split())
mi = max(-1000000,x-k+1)
ma = min(1000000,x+k-1)
l = list(range(mi,ma+1))

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

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

a = max(X - K + 1, -1000000)
b = min(X + K -1, 1000000)

res = []
for i in range(a, b + 1):
    res.append(str(i))

print(" ".join(res))

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

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

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

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

a=x-k
b=list()

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

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

result=''

for i in reversed(range(k)):
  result+=str(x-i) + ' ' 

for j in range(1, k):
  if j==k-1:
    result+=str(x+j)
  else:
    result+=str(x+j) + ' ' 
  
print(result)

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

Solution (Python):
A,B = map(int,input().split())
print(str(list(range(B-(A-1),A+B))).strip('[').strip(']').replace(',',''))

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

M = min(X + K - 1, 1000000)
m = max(X - K + 1, -1000000)

A = [i for i in range(m, M + 1)]
print(' '.join(map(str, A)))

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

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

K = KX[0]
X = KX[1]

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

lis = list(range(MIN,MAX))

for i in range(len(lis)):
    print("{}".format(lis[i]), end="")
    if i == len(lis)-1:
        
        continue
    else:
        print(" ", end="")

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

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

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

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

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

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

a = M - N + 1
b = M + N
c= list(range(a,b))
print(' '.join(map(str, c)))

Solution (Python):

import sys


def solve(K: int, X: int):
    print(' '.join(map(str, range(X - K + 1, X + K))))


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(X-K+1, X+K):
  if -1000000 <= i and i <= 1000000:
    ans.append(str(i))
print(" ".join(ans))

Solution (Python):
K, X = map(int, input().split())
MIN = -1000000
MAX = 1000000+1

print(*list(range(max(MIN, X - K + 1), min(MAX, K + X))))

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

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

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

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

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

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

sita=max(-1000000,x-k+1)
ue=min(1000000,x+k-1)
l=[]

for i in range(sita,ue+1):
  l.append(i)
print(*l)

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

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

st = ""
for i in range(200000):
    if (X-K+1) <= i-100000 and i-100000<= (X+K-1):
        st = st +str(i-100000)+" "

print(st)

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

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

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

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

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

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):
array = input().split()
K = int(array[0])
X = int(array[1])
Start = X - K + 1
Goal = X + K
for i in range(Start, Goal):
  print(str(i) + " ", end = "")

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

ans = []

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

ans.append(str(X))

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

print(' '.join(ans))

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

if k ==1:
	print(x)
else:
	a = x - k + 1
	b = x + k
	z = list(range(a,b))
	print(' '.join(map(str, z)))

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

Solution (Python):
def main():
    ins = input().split(' ')
    k = int(ins[0])
    x = int(ins[1])
    xs = range(max(x-k+1, -1000000), min(x+k, 1000001))
    xxx = list(map(lambda s: str(s), xs))
    print(' '.join(xxx))


if __name__ == '__main__':
    main()

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

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

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

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


ans = []
n = 0
start = a[1]-a[0]+1
for i in range(a[0]*2-1):
  ans.append(start+n)
  n+=1

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

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

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

Solution (Python):
import numpy as np

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

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

if X-K+1 >= -1000000:
    if X+K-1 <= 1000000:
        print(*S)
    else:
        print(*np.arange(X-K+1, 1000001))
else:
    if X+K-1 <= 1000000:
        print(*np.arange(-1000000, X+K))
    else:
        print(*np.arange(-1000000, 1000001))

Solution (Python):
"""
https://atcoder.jp/contests/abc137/tasks/abc137_b
"""

import numpy as np


def calc(K: int, X: int) -> np.ndarray:
    _min_num = -1000000
    _stop_num = 1000000 + 1
    min_ = max(_min_num, X - (K - 1))
    stop = min(_stop_num, X + K)
    return np.array(range(min_, stop))


def load_input_as_int_array() -> np.ndarray:
    return np.array([int(v) for v in input().split(" ")])


def main() -> None:
    K, X = load_input_as_int_array()
    result = calc(K, X)
    print(" ".join([str(v) for v in result]))


main()

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

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

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

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


width = k - 1

left = x - width
right = x + width

if left < -1000000:
  left = -1000000
if right > 1000000:
  right = 1000000

print(' '.join([str(i) for i in range(left, right+1)]))

Solution (Python):

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


minimum = max(X-K+1,-1000000)
maximum = min(X+K-1,1000000)

correct= list(range(minimum,maximum+1))

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

Solution (Python):
import sys

sys.setrecursionlimit(10**9)
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def LIST(): return [int(x) for x in input().split()]
MOD = 10**9 + 7

K, X = LIST()

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

L = list(range(start, end+1))
print(' '.join(map(str, L)))

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

print(ans)

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

Solution (Python):
k,x = map(int, raw_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(2*(k-1)+1):
    ans += str(x-k+1+i)
    if i != 2*(k-1)+1: 
        ans += ' '
print(ans)

Solution (Python):
a=[]
for x in input().split(" "):
    a.append(int(x))

b=[]
if a[1]-a[0]+1<-1000000:
    i=-1000000
    while i<a[1]+a[0]:
        b.append(str(i))
        i+=1
elif a[1]+a[0]-1>1000000:
    i=a[1]-a[0]+1
    while i<1000000:
        b.append(str(i))
        i+=1
else:
    i=a[1]-a[0]+1
    while i<a[1]+a[0]:
        b.append(str(i))
        i+=1

print(' '.join(b))

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

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

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

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

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

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

for i in range(xmin,xmax+1):
    print(i,"",end="")

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

mi = x - (k-1)
ma = x + (k-1)

res = ""
for i in range(max(mi, -1000000), min(ma, 1000000)+1):
    res += str(i) + " "

print(res)

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

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

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

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

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

Solution (Python):
import logging

logging.basicConfig(level=logging.INFO, format="%(message)s")


def main():
    K, X = map(int, input().split())
    logging.info("Hello!")

    min_x = X - K + 1
    max_x = X + K - 1

    ans = ""
    for i in range(min_x, max_x + 1):
        if i < -1000000:
            continue
        elif i > 1000000:
            break

        ans += str(i)
        ans += " "

    print(ans)
    
if __name__ == "__main__":
    main()

Solution (Python):

"""
Created on Sat Aug 10 21:04:27 2019

@author: kato yugo
"""

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

a = k-1

b = x-a
c = x+a

for i in range(b,c+1):
    if (-100000 <= i <= 1000000):
        print(i, end="")
        print(" ", end="")

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



head = x-(k-1)
tail = x+(k-1)

ans = str(head)
for i in range(head+1,tail+1):
    ans = 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):
    ans.append(i)
print(*ans)

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

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

ans = []
for i in range(start, end):
    ans.append(i)

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

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

Solution (Python):
import numpy as np
N = input().split()

K=int(N[0])
X=int(N[1])

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

for  item in num:
    print(item,end=' ')

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

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


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

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

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

print(" ".join(map(str, x)))

Solution (Python):
a,b=map(int, input().split())
hoge = max([b - abs(a-1),-1000000])
fuga = min([b + abs(a),1000000])
res = [str(i) for i in range(hoge, fuga)]
print(" ".join(res))

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

mostMin = max(-1000000, X+1-K)
leastMax = min(1000000, X+K)

print " ".join([str(x) for x in xrange(mostMin, leastMax)])

Solution (Python):
import sys

INPUT = lambda: sys.stdin.readline().rstrip()
MAP = lambda: map(int, INPUT().split())

sys.setrecursionlimit(10 ** 9)


def main():
    K, X = MAP()
    ans = [0] * (2*K - 1)

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

    print(*ans, sep=" ")

if __name__ == '__main__':
    main()

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

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

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

ans=''
for i in range(len(l)):
        ans+=str(l[i])+' '
print(ans)

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

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

for i in range(min, max+1):
  r.append(str(i))

ans = ' '.join(r)
print(ans)

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

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

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

Solution (Python):



import sys

input = sys.stdin.readline

def main():
    K, X = map(int, input().split())
    n = map(lambda x: str(x), filter(lambda x: x >= -1000000 and x <= 1000000, [i for i in range(X-(K-1), X+K)]))
    print(" ".join(n))

main()

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

for i in range(X-K+1,X+K):
  if i <-1000000:
    pass
  elif i>1000000:
    break
  else:
    list.append(i)

print(*list)

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

_max = x + k -1
_min = x - k + 1
print(' '.join(str(i) for i in range(_min, _max + 1)))

Solution (Python):
k, x = map(int, input().split())
min_x = x-k+1
list_x = [0]*(2*k-1)
count = 0
for i in range(2*k-1):
    list_x[i] = str(min_x + count)
    count += 1

print(" ".join(list_x))

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())
maxlim = 1000000
minlim = -1000000
minx = X-K
maxx = X+K
ans_l = [str(i) for i in range(minx+1,maxx)]
print(" ".join(ans_l))

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

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

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

k_1 = k - 1

for n in range(x-k_1,x+k_1+1):
    n = str(n)
    ans.append(n)

aa = " ".join(ans)    
print(aa)

Solution (Python):
import sys

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

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

Solution (Python):
from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)

from math import factorial
import heapq, bisect


from math import factorial

def combinations_count(n, r):
    return factorial(n) // (factorial(n - r) * factorial(r))

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

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




if __name__ == '__main__':
    main()

Solution (Python):



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

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

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return list(map(int, sys.stdin.readline().split()))
def II(): return int(sys.stdin.readline())
def LS(): return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]

def main():
    k, x = LI()
    min_ = max(-1000000, x - k + 1)
    max_ = min(1000000, x + k - 1)
    print(" ".join([str(i) for i in list(range(min_, max_ + 1))]))

if __name__ == '__main__':
    main()