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

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

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

ans.sort()
print(*list(ans))

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

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

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

Solution (Python):
k,x=map(int,input().split())
start,end=max(-1000000,x-(k-1)),min(1000000,x+(k-1))
r=range(start,end+1)
print(*r,sep=' ')

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

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

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

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

min = min if min >= -1000000 else -1000000
max = max if max <= 1000000 else 1000000

print(*range(min, max + 1))

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

out = str(X)

for i in range(1, K):
  out = str(X-i) + ' ' + out + ' ' + str(X+i)

  
print(out)

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

a = X - K + 1
b = X + K - 1

d = [str(i) for i in range(a, b+1)]

c = ' '.join(d)
print(c)

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

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

print(" ".join(ans))

Solution (Python):

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

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

Solution (Python):


import numpy as np

def resolve():
    k, x = map(int, input().split())
    for i in range(x-k+1, x+k):
        if -1000000 <= i and i <= 1000000:
            print("{} ".format(i), end="")
    print("")


if __name__ == "__main__":
    resolve()

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

Solution (Python):
k, x = map(int, input().split())
hako = []
for stone in range(-k + x + 1, k + x):
  hako.append(str(stone))
if len(hako) == 0:
  hako.append(x)
print(" ".join(hako))

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

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

Solution (Python):



import sys, os
def ac_input(*args):
    return map(int, input().split())


def main():
    k, x = ac_input()
    for i in range(k*2-1):
        print(str(x-k+i+1)+" ", end="")
    print("")
if __name__ == "__main__" :
    main()

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

k = innum[0]
x = innum[1]

minim = int(max((x - k + 1), (-1000000)))
maxim = int(min((x + k - 1), 1000000))

result = ""

for i in range(minim, maxim + 1):
    result = result + " " + str(i)
print (result)

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

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

list = []

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

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

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

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

for i in range(K-1):
  list.append(X-i-1)
  list.append(X+i+1)
  
list.sort()

print(*list)

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

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

Solution (Python):


if __name__ == "__main__":
    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())
L = [str(i) for i in range(x-k+1, x+k)]
print(' '. join(L))

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

up = x+k-1
down = x-k+1

if down < -1000000 : 
    down = -1000000
if up > 1000000 : 
    up = 1000000

for i in range(down, up+1, 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())
max=X+K-1
min=X-K+1
print(' '.join([str(a) for a in range(min,max+1)]))

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

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

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

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

Solution (Python):

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

Solution (Python):

def main():
  K, X = map(int, input().split(' '))
  print(*(range((X + 1) - K, (X + K))))

if __name__ == "__main__":
    main()

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


if __name__ == '__main__':
    print(' '.join(map(str, range(x - (k - 1), x + k))))

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

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

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

ans = []

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

ans = [str(ai) for ai in ans]
print(' '.join(ans))

Solution (Python):

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

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

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())
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 = list(range(X + 1 - K, X + K))
print(" ".join(map(str, l)))

Solution (Python):
def calc(a,b):
  return [a+b, a-b, a*b]

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

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

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

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

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

Solution (Python):
K,X = map(int,input().split())
i = X - K + 1
lis = []
while i <= X + K - 1:
  lis.append(str(i))
  i += 1

s = ' '.join(lis)
print(s)

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(i) for i in range(X-K+1, X+K)]))

Solution (Python):

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


if k == 1:
    print(x)

else:
    start = x - (k - 1)
    finish = x + k
    ans = []

    for i in range(start, finish):
        ans.append(i)

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

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

Const = 1000000

print( *[x + b for x in range(-(a-1),a) if abs(x + b) <= Const] )

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):
K, X = list(map(int, input().split()))
minimum = max(-1000000, X - (K - 1))
maximum = min(X + (K - 1), 1000000)
print(' '.join(map(str, range(minimum, maximum + 1))))

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

for k in reversed(range(K)):
  print(X - k)

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

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

Lists = [int(i) for i in range(a,b)]

for i in Lists:
    print(i)

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

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

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

Solution (Python):


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

Solution (Python):


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

leftbound= max(X-K+1,-10000)
rightbound=min(X+K-1 ,10000)

ml = [i for i in range(leftbound,rightbound+1)]

print(*ml)

Solution (Python):
result = input().split()
reslut_list = []
n1, n2 = int(result[0]), int(result[1])
min_coordinate = n2 - n1 + 1
max_coordinate = n1 + n2 
for i in range(min_coordinate, max_coordinate):
    print(i , ' ', end='')
print()

Solution (Python):
import math
import sys
import collections



def getdict(n):
    d = {}
    if type(n) is list:
        for i in n:
            if i in d:
                d[i] += 1
            else:
                d[i] = 1
    else:
        for i in range(n):
            t = ii()
            if t in d:
                d[t] += 1
            else:
                d[t] = 1
    return d
def cdiv(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a*b) // math.gcd(a, b)

a, b = mi()
print(' '.join(str(x) for x in range(max(-10**6, b-a+1), min(10**6, b+a))))

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

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

Solution (Python):
from sys import stdin
def ii(): return int(stdin.readline())
def mi(): return map(int, stdin.readline().split())
def li(): return list(mi())
a, b=mi()
x=b-a+1
y=b+a
for i in range(x, y):
	print(i, end=' ')

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

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

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

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

Solution (Python):
values = input()
s = [int(i) for i in values.split()]
r = [i for i in range(-1000000, 1000001)]
print(' '.join(str(i) for i in r[1000001+s[1]-s[0]:1000000+s[1]+s[0]]))

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

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

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

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

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

Solution (Python):
k,x=map(int,input().split(" "))
possible = []
x2 = x - k + 1
while k + x2 - 1 < 10000 and x2 != k + x:
    possible.append(str(x2))
    x2 += 1
print(" ".join(possible))

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

Solution (Python):
k,x=list(map(int,input().split()))
min_x=x-k+1
max_x=x+k-1

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

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

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

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

print(*ans)

Solution (Python):
import numpy as np

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

B=np.array(range(-K+X+1,K+X,1))

for i in B:
  print(i)

Solution (Python):
import numpy as np

Y,D=map(int,input().split())

B=np.array(range(-Y+D+1,Y+D,1))

for i in B:
  print(i)

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

Solution (Python):

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

Solution (Python):
import numpy as np

Y,D=map(int,input().split())

B=np.array(range(-Y+D+1,Y+D,1))

for i in B:
  print(i)

Solution (Python):
k, x = map(int, input().split())
mx = 1000000
ans = ''
ma = 0
mi = 0

mi = (-1) * (k - 1)
ma = k
    
for a in range(mi, ma):
  if a == ma:
    ans += str(x + a)
  else:
    ans += str(x + a) + ' '
  
if k == 1:
  ans = str(x)
  
print(ans)

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

Solution (Python):
import numpy as np

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

B=np.array(range(-K+X+1,K+X,1))

for i in B:
  print(i)

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

Solution (Python):
import sys

number, index = map(int, input().split())

xMin = index - number + 1
if xMin < -1000000:
  xMin = -1000000

xMax = index + number
if xMax > 1000000:
  xMax = 1000000

list = []

for i in range(xMin, xMax):
  list.append(str(i))

print(" ".join(list))

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


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

    ans = solve(k, x)
    print(ans)


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())
l=range(x-k+1,x+k)
print(' '.join(map(str,l)))

Solution (Python):
k, x = map(int, input().split())
l = []
for i in range(k):
    l.append(x+i)
    if i > 0:
        l.append(x-i)
l = sorted(l)
for j in range(2*k-1):
    print(l[j], end=" ")

Solution (Python):
import sys

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

start_pos = X -K +1
end_pos = X +K -1

if start_pos < -1000000:
    start_pos = -1000000

if end_pos > 1000000:
    end_pos = 1000000

for i in range(start_pos, end_pos):
    sys.stdout.write("%d "%i)

print end_pos

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

Solution (Python):
def main():
     a,b=map(int,input().split())
     print(" ".join(list(map(str,range(b-a+1,a+b)))))
     
if __name__ == '__main__':
     main()

Solution (Python):
import numpy as np

k,x = map(int,input().split())
Min = x-k+1
Max = x+k-1
list_1 = []
for i in range(Min,Max+1):
    list_1.append(str(i))
list_2 = ' '.join(list_1)
print(list_2)

Solution (Python):




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

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

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

l = max(-1000000, x-k+1)
r = min(1000001, x+k)

print(*[i for i in range(l,r)])

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

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

K,X = inpl()
print(' '.join(map(str,list(range(X-K+1,X+K)))))

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

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

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

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

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

Solution (Python):
k, x = (int(i) for i in input().split())
front_number = x-k+1
end_number = x+k

for i in range(front_number, end_number):
    print(i, end=" ")

Solution (Python):
K,X = map(int, input().split())
stones = [X]
for i in range(K):
  if i != 0:
  	stones.append(X+i)
  	stones.append(X-i)
stones.sort()
for s in stones:
	print(s)

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

if K==1:
    print(X)

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

Solution (Python):

number = list(map(int,input().split()))
start = number[1]-number[0]+1
last = number[1]+number[0]-1
for i in range(start,last+1):
    if i == last:
        print(i,end="")
    else:
        print(i,end=" ")

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

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

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

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

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

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

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

print(*ans)

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

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

print(*ans)

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

for i in range(a,b+1):
    if -1000000 <= i <= 1000000:
        c.append(i)

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

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

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

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

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

Solution (Python):
x = input()

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

result = []

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

result_1 = ' '.join(result)

print(result_1)

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

for j in range(2):
	for i in range(k):
		buf = x + i * (-1) ** j
		if buf not in seq:
			seq.append(buf)
		
seq.sort()
print(*seq)

Solution (Python):
src = input().split()
k = int(src[0])
x = int(src[1])
a = ''
min = x-k+1
max = x+k-1
pos = list(range(min,max+1))
for i in pos:
  a = a + str(i) + ' '
print(a)

Solution (Python):
k, x = map(int, input().split())
l = max((k - 1) * -1 + x, -1000000)
r = min((k - 1) + x, 1000000)
res = ""
for i in range(l, r + 1):
  res += str(i)
  if i != r:
    res += " "
print(res)

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

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

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

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

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

print(*list)

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

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

Solution (Python):
K, X = map(int, input().split())
a = ''
for i in range(-1000000, 1000001):
    if i > X - K and i < X + K:
        j = str(i)
        a = a + ' ' + j
    else:
        continue
print(a)

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

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

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

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

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

Solution (Python):

INPUT_SENTENCES = 1
ss = [input() for i in range(INPUT_SENTENCES)][0].split()
K = int(ss[0])
X = int(ss[1])

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

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

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

Solution (Python):
TOTAL = 2000001

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

r = k - 1

p1 = x - r
p2 = x + r + 1

res = ''

for i in range(p1, p2):
    res =  res + str(i) + " "

print('{}'.format(res))

Solution (Python):
from collections import deque

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

ans = deque()

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

anstext = ''
for i in ans:
    anstext += '{}'.format(i) + ' '

print(anstext[:-1])

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

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

Solution (Python):
from functools import reduce

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

RF = X - K + 1
RL = X + K - 1

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

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

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

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

a-=1

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

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

ans = list(range(min_num,max_num))
print(*ans)

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

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

ans = list(range(left,right+1))
ans = map(str, ans)

print(' '.join(ans))

Solution (Python):
a, b = [int(i) for i in input().split(' ')]

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

print(' '.join(result))

Solution (Python):

import sys


def solve(K: int, X: int):
    output = ''
    for i in range(X - K + 1, X + K):
        output += str(i) + ' '
    print(output[:-1])
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    K = int(next(tokens))  
    X = int(next(tokens))  
    solve(K, X)

if __name__ == '__main__':
    main()

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

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

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 = input().split()

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

upper = 0
lower = 0

if x - k < -1000000:
    lower = -1000000
    upper = x + k
elif x + k > 1000000:
    upper = 1000000
    lower = x - k
else:
    upper = x + k
    lower = x - k

ans = ""
for num in range(lower + 1, upper):
    ans = ans + " " + str(num)

print(ans)

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())
L1 = list(range(X-K+1,X+K))
L1_str = [str(n) for n in L1]
L2 = ' '.join(L1_str)
print(L2)

Solution (Python):
def solve(k, x):
    res = []
    for i in range(2*k-1):
        y = x-k+1+i
        if -1000000 <= y <= 1000000:
            res.append(y)
    return " ".join(map(str, res))

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

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

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

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

k = a[0]
x = a[1]

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

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

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

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

Solution (Python):
input_num=input().split()
input_num=[int(num) for num in input_num]

K=input_num[0]
X=input_num[1]

min_cons=-10**6
max_cons=10**6

max_num=X+K-1
min_num=X-(K-1)

if min_num<min_cons:
    min_num=min_cons

if max_num>max_cons:
    max_num=max_cons

num_list=[i for i in range(min_num,max_num+1)]
print(*num_list)

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

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

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

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

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

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

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

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

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

if a[1]-a[0]+1<-10000:
  if a[1]+a[0]-1>10000:
    b=[i for i in range(-10000,10001)]
  else:
    b=[i for i in range(-10000,a[1]+a[0])]
else:
  b=[i for i in range(a[1]-a[0]+1,a[1]+a[0])]
for i in b:
  print(i,end=" ")

Solution (Python):
def main(K, X):
    num_list = [x for x in range(-1000000,1000001,1)]
    if 100 >= K >= 1 and 100 >= X >= 0:
        range_k = [j for j in range(X-K+1, X+K,1)]
    for j in range(len(range_k)):
        print(range_k[j], end=' ')

if __name__ == '__main__':
    s = list(map(int, input().split()))
    main(s[0], s[1])

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

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

Solution (Python):

import bisect
import collections
import itertools


def getint(): return int(input())
def getints(): return list(map(int, input().split()))
def getint2d(rows): return [getints() for _ in range(rows)]
def getgrid(rows): return [input() for _ in range(rows)]
def array1d(n, value): return [value for _ in range(n)]
def array2d(n, m, value): return [array1d(m, value) for _ in range(n)]

k,x=getints()

min_value = max(x - k + 1, -1000000)
max_value = min(x + k - 1,  1000000)

for i in range(min_value, max_value + 1):
    print(i, end=" ")
print("")

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

Solution (Python):
import math
from itertools import accumulate


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

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

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

if __name__ == '__main__':
  main()

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

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

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

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

Solution (Python):


import os

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

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

print(*l_i)

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

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

print(*array)

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

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

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

Solution (Python):
k, x = map(int, input().split())
ans = []
l = k-1
for i in range(k*2-1):
    if (x-l <= 1000000) and (x-l >= -1000000):
        ans.append(x-l)
    l -= 1

print(*ans)

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