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

num_min = max(-1000000, x-k+1)
num_max = min(1000000, x+k-1)

for i in range(num_min, num_max+1):
    print("{} ".format(i), end="")

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

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

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

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

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

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

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

t=[0]*(2*k-1)

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

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

L = - (10 ** 6)
H = 10 ** 6

ans_L = max(L, x - k + 1)
ans_H = min(H, x + k - 1)

ans = []
for i in range(ans_L, ans_H + 1):
    ans.append(str(i))

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

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

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

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

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

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

Solution (Python):





k, x = map(int, input().split())
i = x - k + 1
cnt = 1
while cnt < k*2:
    print(i, end=" ")
    cnt += 1
    i += 1

Solution (Python):
N,place=map(int,input().split())

for x in range(place-N+1,place+N):
  print(x,end=' ')

Solution (Python):
k,x = map(int,input().split())
if k==1:
  print(x)
else:
  list_ = list(range(max(-1000000,x-(k-1)),min(1000000,x+(k-1))+1))
  list_=[str(i) for i in list_]
  answer = " ".join(list_)
  print(answer)

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

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

print(*result)

Solution (Python):


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

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

print(' '.join(output))

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

Solution (Python):
a,b=map(int,input().split());q=max(-1000000,b-a+1);w=min(1000000,b+a-1);A=[i for i in range(q,w+1)]
for i in range(len(A)):
  print(A[i])

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

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

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

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

for val in range(r):
	print(val+min)

Solution (Python):

K, X = map(int, input().split())
ans=""
for i in range(X-K+1, X+K):
  ans += "{} ".format(i)
print(ans)

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

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

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

mi = max(-1000000,x-k+1)
ma = min(1000000,x+k-1)

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

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

aa = []

for i in range(X-K+1, X+K):
    aa.append(i)
    
print(*aa)

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)

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

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

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

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

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

a = max(-1000000, X - K + 1)
for i in range(2*K-1):
    print(a + i, end=' ')

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

Solution (Python):
kx = [int(i) for i in input().split()]
k,x = kx[0],kx[1]
c = k*2 - 1
g = [j + x - k + 1 for j in range(c)]
ss = ""
for s in g:
	ss += str(s) + " "
print(ss.strip())

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

A = x-k+1
B = x+k-1

while A != B+1:
    print(A, end=' ')
    A = A + 1

Solution (Python):

import numpy

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


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

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

for i in range(2*k-1):
    if 1000001 > x+i-k+1 > -1000001:
        print(x+i-k+1, end = " ")
    else:
        continue

Solution (Python):


def solve():
    K, X = list(map(int, input().split()))
    left = X - (K-1)
    right = X + (K-1)

    s = ""
    for i in range(left, right+1):
        s += "{} ".format(i)
    print(s[:-1])


if __name__ == "__main__":
    solve()

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

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

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

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

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

k = il[0]
x = il[1]

minusLimit = x - k + 1
plusLimit = x + k - 1

i = minusLimit

s = ""

while minusLimit <= i <= plusLimit :
  s =  s + str(i) + " "
  i = i + 1
s[:-1]
print(s)

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

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

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

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

Solution (Python):
import sys
import bisect
input = sys.stdin.readline
 
def main():
    x,y = map(int,input().split())
    
    print(" ".join(map(str, list(range(y - x + 1, x + y)))))
    
main()

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

Solution (Python):

if __name__ == "__main__":
    K = list(map(int,input().split()))
    X = K[1]
    K = K[0]
    maxX = (X + (K-1))
    minX = (X - (K-1))
    if maxX > 1000000:
        maxX = 1000000
    elif minX < -1000000:
        minX = -1000000
    for i in range(maxX - minX + 1):
        print(minX + i, end = " ")

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

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

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

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

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

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

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

Solution (Python):
def solve(string):
    k, x = map(int, string.split())
    return " ".join(list(map(str, range(x - k + 1, x + k))))


if __name__ == '__main__':
    print(solve(input()))

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

Solution (Python):
def stones(input):
    k, x = map(int, input.split())
    if k is 1:
        print(x)
        return x
    j = [i for i in range(x - k + 1, x + k)]
    s = ' '.join(map(str, j))
    print(s)
    return
 
 
stones(input())

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

low = X - K
hight = X + K

a = []
for x in range(low + 1, hight, 1):
    a.append(str(x))
print(' '.join(a))

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

low = X - K
hight = X + K

a = set()
for x in range(low + 1, hight, 1):
    a.add(x)
a = sorted(a)
a = [str(x) for x in a]
print(' '.join(a))

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

low = X - K
hight = X + K

a = set()
for x in range(low + 1, hight, 1):
    a.add(x)
print(' '.join([str(x) for x in sorted(a)]))

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

low = X - K
hight = X + K

a = set()
for x in range(low + 1, hight, 1):
    a.add(x)
a = sorted(a)
b = [str(x) for x in a]
print(' '.join(b))

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

low = X - K
hight = X + K

a = set()
for x in range(low + 1, hight, 1):
    a.add(x)
a = sorted(a)
b = [str(x) for x in a]
print(' '.join(b))

Solution (Python):
def solve(string):
    k, x = map(int, string.split())
    return " ".join([str(i) for i in range(x - k + 1, x + k)])


if __name__ == '__main__':
    print(solve(input()))

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

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

Solution (Python):
K,X = map(int, input().split())
hajime=X-(K-1)
owari=X+(K-1)
if hajime<-1000000:
    hajime=-1000000
if owari>1000000:
    owari=1000000

kotae = [str(i) for i in range(hajime,owari+1)] 
print(" ".join(kotae))

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

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

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

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

Solution (Python):
K,X = map(int,input().split())
lower = X-(K-1) if X-(K-1)>-1000001 else -1000000
upper = X+(K-1) if X+(K-1)<1000001 else 1000000
result=""
for i in range(lower,upper+1):
    result = result+str(i)+" "
print(result[:-1])

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

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

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

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

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

Solution (Python):
K,X = map(int, input().split())
ans = list(range(X-K+1,X+K))
aa = ans.copy()
for a in aa:
    if  -10**6 > a or 10**6 < a:
        ans.remove(a)

print(*ans)

Solution (Python):
import math, heapq
INF = float("inf")
MOD = int(1e9 + 7)

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

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

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

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

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

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

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

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

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

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

l = [str(x) for x in range(xmin+1, xmax)]
L = " ".join(l)
print(L)

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

if X + K - 1 > MAX:
    X -= X + K - MAX - 1

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

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

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

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

Solution (Python):
import sys
import math
import bisect
import atexit
import io
import heapq
from collections import defaultdict, Counter
MOD = int(1e9+7)





def main():
    k, x = map(int, raw_input().split())
    for i in range(-k+1, k):
        print x+i,

main()

Solution (Python):
import sys
sys.setrecursionlimit(100000)
input=sys.stdin.readline
def intinput():return map(int,input().split())

k,x=intinput()
s=[str(i) for i in range(x-k+1,x+k)]
print(" ".join(s))

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

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


answer = []

if X-K< -1000000:
    answer = [i for i in range(-1000000,X+K+1)]
elif X+K>1000000:
    answer = [i for i in range(X-K+1,1000000)]
else:
    answer = [i for i in range(X-K+1,X+K)]

for i in range(len(answer)):
    print("{} ". format(answer[i]))

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

bound = 1000000

upper = min(X + K - 1, bound)
lower = max(X - K + 1, -bound)
res = map(str, range(lower, upper + 1))
print(' '.join(res))

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

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

for i in range(min, max):
    print("{} ".format(i))

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

blacks = {}
blacks[X] = True
for i in range(K):
    if -1000000 <= i and i <= 1000000:
        blacks[X - i] = True
        blacks[X + i] = True

blacks_list = list(blacks.keys())
print(' '.join([str(x) for x in sorted(blacks_list)]))

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

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

for i in range(min , max ):
    print("{} ". format(i))

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

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

L = []
for i in range(-1000000,1000001):
    if i <= X+K-1 and X-K+1 <= i:
        L.append(i)
print(*L)

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

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

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

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

print(' '.join(ans))

Solution (Python):
K, X = [int(i) for i in input().split()]
s = set()
for i in range(K):
    s.add(X+i)
    s.add(X-i)

for i in sorted(list(s)):
    print(i, end=" ")

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

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

print(ans)

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

maxa=x+(k-1)
mina=x-(k-1)

if maxa>1000000:
  maxa=1000000
if mina<-1000000:
  mina=-1000000

a=[]
for i in range(mina,maxa+1):
  a.append(i)
  
for i in range(len(a)):
  print(a[i],end=" ")

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

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

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

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

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

Solution (Python):
K, X = map(int, input().split())
ans = list()
for i in range(-1000000, 1000001):
  if abs(i-X)<=K-1:
    ans.append(i)
print(*ans, sep=' ')

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

Solution (Python):

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

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

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

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


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

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

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

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

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

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

num = end - start + 1 

anserLsit = []
for i in range(num):
  print(start+i)

Solution (Python):
import sys
sys.setrecursionlimit(4100000)

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

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

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

r = list(range(x-k+1, x+k))
ans = ''
for i in r:
  if i != x+k-1:
    ans = ans + str(i) + ' '
  else:
    ans = ans + str(i)

print(ans)

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

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

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

print(*[i for i in range(X - K + 1, X + K)])

Solution (Python):
import sys

from operator import itemgetter

def main():
	lo=-1000000
	hi=1000000
	input = sys.stdin.readline
	k,x = [int(item) for item in input().split()]
	lst=[i for i in range(max(lo,x-k+1),min(hi,x+k-1)+1)]
	print(" ".join([str(n) for n in lst]))

main()

Solution (Python):
import math
import fractions
import copy
import numpy as np
def j(q):
    if q==1: print("Yes")
    elif q == 0:print("No")
    exit(0)
rem = pow(10,9)+7
"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def iprow():
    return [int(i) for i in input().split()]
def ips():
    return (int(i) for i in input().split())
def printrow(a):
    for i in a:
        print(i)
"""

def combinations(n,r):
    if n<r:return 0
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations(n,r):
    if n<r:return 0
    return math.factorial(n) // math.factorial(n - r)
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
"""
n,k = ips()
left = max(-100000 , k-n+1)
right = min(100000 , k+n)
a = [i for i in range(left,right)]
for i in range(len(a)-1):
    print(a[i],end = " ")
print(a[len(a)-1])

Solution (Python):
from sys import stdin


def main():
    K, X = [int(x) for x in stdin.readline().rstrip().split()]
    spam = [i + (X - K + 1) for i in range(2 * K - 1)]
    print(*spam, end=' ')
    print('')


if __name__ == "__main__":
    main()

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

absmax = 1000000

high = x + k - 1 if x + k - 1 <= absmax else absmax
low = x - k + 1 if x - k + 1 >= -absmax else -absmax

from functools import reduce
print(reduce(lambda prev, curr: "{} {}".format(prev, str(curr)) , range(low, high+1), "")[1:])

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

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

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

iMin = X - K + 1
iMax = X + K - 1
anss = list(range(max(-10**6, iMin), min(10**6, iMax)+1))

print(*anss)

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

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



ans = ""

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

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

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


if __name__ == '__main__':
    main()

Solution (Python):



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

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

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

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

lst = list(set(lst))

lst = ([i for i in lst if i  <= 1000000 and i >= -1000000])
print(' '.join(map(str,sorted(lst))))

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

ans_list = list(map(lambda test: test, range(x-k+1, x+k)))

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

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

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

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

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

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

min_ = X - K + 1 if X - K + 1 > -1000001 else -1000000
max_ = X + K - 1 if X + K - 1 < 1000001 else 1000000

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

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

Solution (Python):
k,x = map(int,input().split())
lst = [x]
for i in range(1,k):
    lst.extend([x+i,x-i])
lst.sort()
lst_s = [str(i) for i in lst]

print(" ".join(lst_s))

Solution (Python):


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

Solution (Python):


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

min_x = max(x - k + 1, -1000000)

max_x = min(x + k - 1, 1000000)

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())
r=[]
for i in range(x-(k-1),x+k,1):
  if i >= (-1000000) and i <= 1000000:
    r.append(str(i))

print(" ".join(r))

Solution (Python):
AB = input().split()
A = int(AB[0])
B = int(AB[1])

s = B - A + 1
e = B + A

list = [i for i in range(s,e)]

print(*list)

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

Solution (Python):
def main():
    input_line = list(map(int,input().split()))
    A = range(input_line[1]-input_line[0]+1,input_line[1]+input_line[0],1)
    for i in A:
        print(str(i),end=" ")
if __name__ == '__main__':
    main()

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

Solution (Python):
k, x = map(int, input("").split(" "))
ans_array = []
for i in range(k-1):
    ans_array.append(x-(i+1))
for i in range(k-1):
    ans_array.append(x+(i+1))
ans_array.append(x)
ans_array.sort()
for i in range(len(ans_array)):
    if i == 0:
        ans = str(ans_array[i])
    else:
        ans += " "
        ans += str(ans_array[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())

kmin = x-k+1
kmax = x+k
list1 = [i for i in range(kmin,kmax)]
stra = ""
for i in range(len(list1)):
    stra += str(list1[i]) + " "
print(stra)

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

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

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

Solution (Python):
a = list(map(int,input().split()))
K = a[0]
X = a[1]
m = X - K + 1
M = X + K - 1
size = M - m + 1
while m <= M:
  print(m)
  m += 1

Solution (Python):






k, x = map(int, input().split())
for i in range(x - k + 1, x + k):
    if i >= -1000000 and i <= 1000000:
        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):
K, X = map(int, input().split())
n = []

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

N=[str(a) for a in n]
N=" ".join(N)
print(N)

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

lis = [i for i in range(b-a+1,a+b)]
    
for i in range(len(lis)):
    print(lis[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())
q = list(range(x-k+1, x+k))
r = map(str, q)
print(' '.join(r))

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

l = list(range(x-k+1, x+k, 1))
l = list(filter(lambda x: x>=-1000000 and x<= 1000000, l))
l = [str(i) for i in l]
print(" ".join(l))

Solution (Python):

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

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

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

Solution (Python):

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

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

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

print(" ".join(list(map(str,range(b-a+1,b+a)))))

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

kagen = v[1] - v[0] + 1
jogen = v[1] + v[0]
ans = list()
for i in range(kagen, jogen):
  ans.append(str(i))
print(" ".join(ans))

Solution (Python):
import numpy as np

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

for index in range(k-1):
  x = np.append(x,initial+index+1)
  x = np.insert(x,0,initial-index-1)

if x.size > 1:
  print(" ".join(list(map(str,x))))
else:
  print(x)

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

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

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

i = X - (K - 1)
while i < K + X:
  if i == (K + X -1):
    print(i)
  else:
    print(i,end=" ")
  i += 1

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

first_point = X - K + 1
last_point = X + K - 1

if first_point < -1000000:
    first_point = -1000000
if last_point > 1000000:
    last_point = 1000000

for _ in range(first_point, last_point+1):
    print(_)

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

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

ans = [str(i) for i in range(s, e+1)]
print(" ".join(ans))

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

Solution (Python):

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

a = [str(n) for n in range (x - k + 1, x + k)]

print(" ".join(a))

Solution (Python):

K, X = map(int, input().split())
ans = [0] * (K * 2 - 1)
ans[0] = X - (K - 1)

for i in range(1, len(ans)):
	ans[i] = ans[i - 1] + 1

print(*ans)

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

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

list = [str(i) for i in range(min,max)]
s = ' '.join(list)
print(s)

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

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

arr=list(set(arr))
arr.sort()
for  i in arr:
	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())
print(' '.join([str(x) for x in range(X-K+1,X+K)]))

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

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

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

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

print(ans)

Solution (Python):
K,X = map(int, input().split())
for a in range(X-K+1, X+K, 1):
	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):
x, k = map(int, input().split())
print(*range(k-x+1, x+k), sep=' ')

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

x = int(X)-int(K)+1
while x <= int(X)+int(K)-1:
  print(x, end=' ')
  x += 1

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

Solution (Python):



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


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

Solution (Python):



from sys import stdin
import math


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


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

min_point = X - K + 1
max_point = X + K 


for i in range(min_point,max_point):
    if i == max_point-1:
        print(i,end='')
    else: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())
l=[]
cnt = x-k+1
while cnt < x+k:
  l = l + [cnt]
  print(cnt ,end=" ")
  cnt = cnt +1

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

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