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

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

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

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

number_str = [str(n) for n in number]

num = " ".join(number_str)
print(num)

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

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

for _ in range(k - 1):
    x = x - 1
    ans_list.append(x)

for _ in range(k - 1):
    if _ == 0:
        x = original_x
    x = x + 1
    ans_list.append(x)

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

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

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

L = []

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

print(*L)

Solution (Python):


def main():
    k, x = map(int, input().split())
    ans = range(x - k + 1, x + k)
    print(*ans)


if __name__ == "__main__":
    main()

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

Solution (Python):
def answer(k: int, x: int) -> str:
    may_be_black = map(str, range(x - k + 1, x + k))
    return ' '.join(may_be_black)


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


if __name__ == '__main__':
    main()

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

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

Solution (Python):

k,x=map(int,input().split())
b=[]


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

    b.append(str(i))

b=" ".join(b)

print(b)

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

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

answer = ' '.join(A)

print(answer)

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

Y = []

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

print(" ".join(Y))

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

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

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

def ans137(K:int, X:int):
    ansstr=""
    for i in range(-1000000,1000000):
        if abs(X-i)<K:
            ansstr+=str(i)+" "
    return ansstr[:-1]

print(ans137(K,X))

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


for i in range(-1000000, 2000000, 1):
    if i > X - K and i < X + K:
        print(i)

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

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

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

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

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

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

Solution (Python):
k, x = map(int, input().split())
a = k * 2 - 1
b = x - k + 1
ans = []

for i in range(b,b + a):
    ans.append(i)
map = map(str, ans)
print(' '.join(map))

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

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

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

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

Solution (Python):


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

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

min_ans = x-k+1
max_ans = x+k-1

for x in range(min_ans,max_ans+1):
  print(x, end=" ")

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

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

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

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

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

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

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

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

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

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

if x+(k-1) >= 1000000:
    r = 1000000
else:
    r = x+(k-1)
if x-(k-1) <= -1000000:
    l = -1000000
else:
    l = x-(k-1)

print(' '.join([str(n) for n in range(l, r+1)]))

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

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

Solution (Python):
K,X = map(int,input().split())
first = X - K + 1
second = X + K - 1
if first < -1000000:
    first = -1000000
if second > 1000000:
    second = 1000000
ans = list(range(first,second + 1))
print(*ans)

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

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

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

Solution (Python):
k,n = map(int, input().split( ))
arr = list(range(n-k+1, n+k))

print(" ".join([str(n) for n in arr]))

Solution (Python):
import sys
pin=sys.stdin.readline
pout=sys.stdout.write

K,X=map(int,pin().split())
for i in range(X-K+1,X+K):
  pout(f"{i} ")
print()

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

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

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

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

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

Solution (Python):

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

Solution (Python):
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


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

Solution (Python):
import sys
sys.setrecursionlimit(10**9)

def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))

INF=10**20
def main():
    K,X = mi()
    Z = list(range(2000001))

    x = X
    ans = set()
    for i in range(K):
        y1 = x + i 
        y2 = x - i

        for y in [y1,y2]:
            y += 1000000
            if 0<= y < len(Z):
                ans.add(y-1000000)

    ans = list(ans)
    ans.sort()

    print(*ans,sep=" ")





if __name__ == "__main__":
    main()

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

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

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

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    K, X = LI()

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

if __name__ == '__main__':
    resolve()

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

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

Solution (Python):
import sys


def main():
    input = sys.stdin.buffer.readline
    k, x = map(int, input().split())
    ans = [i for i in range(x - k + 1, x + k)]
    print(*ans)


if __name__ == "__main__":
    main()

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

xmin = X - K + 1
xmax = X + K - 1
a = []

for i in range(xmin, xmax+1):
  a.append(i)

map = map(str, a)

print(' '.join(map))

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

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

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

Solution (Python):
r=input().split()
K=int(r[0])
X=int(r[1])
S=""
for i in range(2*K-1):
    ans=X-K+i+1
    if -1000000<=ans<=1000000:
        S+=str(ans)+" "
print(S.rstrip())

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    K, X = map(int, readline().split())
    res = [x for x in range(X - K + 1, X + K)]
    print(*res)


if __name__ == '__main__':
    main()

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

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

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

range1=(x-k)+1
range2=(x+k)-1

for i in range(range1,range2+1):
    print(i,end=' ')

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

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

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

l = l[::-1]
for i in l:
    print(i,end=" ")

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

k_min=x-k+1
k_max=x+k-1

k_list=[str(i) for i in range(k_min, k_max+1)]

print(" ".join(k_list))

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

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

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


if __name__ == "__main__":
    main()

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

    left = max(x - k + 1, -1000000)
    right = min(x + k - 1, 1000000)

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


if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

l = max(X-K+1,-1000000)
r = min(X+K-1,1000000)

ans = []

for i in range(l,r+1):
    ans.append(str(i))

ans = " ".join(ans)

print(ans)

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

Solution (Python):
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
out = lambda x: print('\n'.join(map(str, x)))

n, k = inm()
print(*[i for i in range(k-n+1, n+k)])

Solution (Python):
def mapt(fn, *args):
    return tuple(map(fn, *args))


def Input():
    return mapt(int, input().split(" "))


def main():
    k, x = Input()
    return " ".join(map(str, list(range(x-(k-1), x+k))))


print(main())

Solution (Python):




k, x = map(int, input().split())
L = []
for i in range(k):
    y = x + i
    z = x - i
    if y > 1000000:
        y = x
    L.append(y)
    if z < -1000000:
        z = x
    L.append(z)
I = set(L)
L = list(sorted(I))
for s in L:
    print(s,end = " ")

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

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

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

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

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

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

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

Solution (Python):


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

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

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

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

minx,maxx = -1000000, 1000000

if minx + (k-1) > x:
    l = [i for i in range(minx,minx+x+1)]
elif maxx - (k-1) < x:
    l = [i for i in range(maxx-x,maxx+1,-1)]
else:
    l = [i for i in range(x-(k-1),x+(k-1)+1)]

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

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

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

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

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

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

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

min_x = max(X-(K-1), -1000000)
max_x = min(X+(K-1), 1000000)

ans = list(range(min_x, max_x+1))

print(*ans)

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

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

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

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

l=0
r=0

if x-(k-1)<-1000000:
  l=-1000000

if x-(k-1)>=-1000000:
  l=x-(k-1)

if x+(k-1)>1000000:
  r=1000000

if x+(k-1)<=1000000:
  r=x+(k-1)

ans=list(range(l,r+1))
s=' '.join([str(n) for n in ans])
print(s)

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

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

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

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

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

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

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

ans += str(X+(K-1))
print(ans)

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

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

Solution (Python):
import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))

k,x=mp()
m=max(-1000000,x-(k-1))
M=min(1000000,x+k-1)
print(*[i for i in range(m,M+1)])

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

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

Solution (Python):


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

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

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

res = " ".join(A)
print(res)

Solution (Python):
k, x = map(int, input().split())
for i in range(2 * k - 1):
    print(int(x - k + 1 + 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())
result = [i for i in range(x-k+1,x+k)]
for j in result:
    print(j,end=' ')

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

Solution (Python):
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))

k,x=nii()

left=max(-1000000,x-k+1)
right=min(1000000,x+k-1)

ans=[i for i in range(left,right+1)]
print(*ans)

Solution (Python):





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

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

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

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

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(list(map(str, list(range(x-k+1, x+k))))))

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

K, X = mapint()
print(*range(max(-10000000, X-K+1), min(10000001, X+K)))

Solution (Python):
import sys

K, X = map(int, sys.stdin.readline().split())

left = max(-1000000, X - K + 1)
right = min(1000000, X + K - 1)

ans = [i for i in range(left, right+1)]
print(*ans)

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

print(*sorted(list(ans)))

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

Solution (Python):
import math
import collections
import fractions
import itertools
import functools
import operator
import bisect

def solve():
    k, x = map(int, input().split())
    ans = []
    for i in range(max(-1000000, x-k+1), min(1000000, x+k)):
        ans.append(str(i))
    print(" ".join(ans))
    return 0

if __name__ == "__main__":
    solve()

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

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

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

for n in range(X-K+1,X+K):
  A.append(n)

print(*A)

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

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

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

X_min = X - K + 1
X_max = X + K

print(*list(range(X_min,X_max)))

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

if k == 1:
    print(x)
else:
    lower = []
    upper = []
    for i in range(1, k):
        lower.append(x-i)
        upper.append(x+i)
    
    res = lower[::-1] + [x] + upper

    r = [str(x) for x in res]
    print(" ".join(r))

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
inp=list(map(int,input().split()))
k=inp[0]
x=inp[1]
a=max(x-k+1,-1*pow(10,6))
b=min(x+k-1,pow(10,6))
for i in range(a,b+1):
  print (i,end=" ")

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

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

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

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

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

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

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

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

Solution (Python):
import sys
lines = [s.rstrip("\n") for s in sys.stdin.readlines()]
k, x = [int(num) for num in lines.pop(0).split(" ")]
lis = [str(n) for n in range(x - k + 1, x + k)]
print(" ".join(lis))

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7) 
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque, defaultdict


from collections import Counter

from itertools import accumulate,combinations,permutations,product

from heapq import heapify,heappop,heappush

from functools import reduce,lru_cache

from decimal import Decimal

def input(): 
    x=sys.stdin.readline()
    return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def binr(x): return bin(x)[2:]
def bitcount(x): 
    x= x - ((x >> 1) & 0x5555555555555555)
    x= (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x= (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f 
    x+= (x >> 8); x+= (x >> 16); x+= (x >> 32) 
    return x & 0x7f

def main():
    mod = 1000000007
    

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

    l=[i for i in range(max(X-K+1,-1000000),min(1000000,X+K-1)+1)]
    print(*l)



if __name__ == "__main__":
    main()

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

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

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

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

for i in l:
  print(i)

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

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

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

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

a = []
for i in range(k):
  a.append(x-i)
for i in range(k-1):
  a.append(x+1+i)
a.sort()
res = ''
for i in range(len(a)):
  res += str(a[i])
  if i != len(a)-1:
    res += (' ')
  
print(res)

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

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

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

Solution (Python):






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

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

Solution (Python):

def input2():
	return map(int,input().split())

k,x=input2()

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

print(*ans)

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

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

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

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

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())
n = k - 1
data = []
for i in range(1, n+1):
    data.append( x - i )
data.append(x)
for i in range(1, n+1):
    data.append( x + i )

data.sort()

print(*data)

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 = map(int, 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())

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

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

ans=[K]

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

ans.sort()


print(*ans)

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


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

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

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

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

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

print(*a)

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

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

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

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

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

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

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

ans=[x-k+i+1 for i in range(2*k-1)]
print(*ans)