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):
import os,re,sys,operator
from collections import Counter,deque
from operator import itemgetter
from itertools import accumulate,combinations,groupby
from sys import stdin,setrecursionlimit
from copy import deepcopy
import heapq

setrecursionlimit(10**6)

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

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())
print(str(list(range(X - K + 1, X + K))).replace(",", " ")[1:-1])

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

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

max = 1000000
min = -1000000
ans_list = []

if x-k+1 < min:
    bottom = min
else:
    bottom = x-k+1

if x+k-1 > max:
    head = max
else:
    head = x+k-1


for number in range(bottom, head+1):
    ans_list.append(number)

print(*ans_list)

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

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

for i in range(0,2*K-1):
    b=range(X-(K-1),X+K,1)
    print(b[i])

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

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

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

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

Solution (Python):
import glob
import numpy as np



REL_PATH = 'ABC\\137\\B'


TOP_PATH = 'C:\\AtCoder'

class Common:

    problem = []
    index = 0

    def __init__(self, rel_path):
        self.rel_path = rel_path

    def initialize(self, path):
        file = open(path)
        self.problem = file.readlines()
        self.index = 0
        return

    def input_data(self):
        try:
            IS_TEST
            self.index += 1
            return self.problem[self.index-1]

        except NameError:
            return input()

    def resolve(self):
        pass

    def exec_resolve(self):
        try:
            IS_TEST
            for path in glob.glob(TOP_PATH + '\\' + self.rel_path + '/*.txt'):
                print("Test: " + path)
                self.initialize(path)
                self.resolve()
                print("\n\n")
        except NameError:
            self.resolve()


class B(Common):

    def resolve(self):

        tmp = [int(i) for i in self.input_data().split()]
        K = tmp[0]
        X = tmp[1]

        start = X - (K-1)
        if start < -1000000:
            start = -1000000
        end = X + (K-1)
        if end > 1000000:
            end = 1000000

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


solver = B(REL_PATH)
solver.exec_resolve()

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):
a, b = map(int, input().split())

lst = list(range(b-(a-1), b+(a-1)+1))
           
for i in lst:
      if i >= -1000000 and i <= 1000000:
          print(i)

Solution (Python):
"""
 // Author : snape_here - Susanta Mukherjee

"""
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
else:
    _str = str
    str = lambda x=b"": x if type(x) is bytes else _str(x).encode()

    


from math import ceil,floor,log,sqrt,factorial,pow,pi






  



def ii(): return int(input())
def fi(): return float(input())
def si(): return input()
def mi(): return map(int,input().split())
def li(): return list(mi())

def main():
    
    k,x=mi()
    a=x-k+1 
    b=x+k-1 
    l=[]
    for i in range(a,b+1):
        l.append(i)
    print(*l)
        


BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def _fill(self):
        s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
        self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
        return s

    def read(self):
        if self.buffer.tell():
            return self.buffer.read()
        return os.read(self._fd, os.fstat(self._fd).st_size)

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", b" "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", b"\n"))
    if kwargs.pop("flush", False):
        file.flush()


sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
input = lambda: sys.stdin.readline().rstrip(b"\r\n")



if __name__ == "__main__":
    main()

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

sita=int(X-K+1)
ue=int(X+K-1)

sita=max([sita, -1000000])
ue=min([ue, 1000000])
ans=[i for i in range(sita, ue+1)]

for i in range(len(ans)):
  print(ans[i], end=' ')

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

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

Solution (Python):
def Printer(K, X):
    start = X - K+1
    ans = ''
    for start in range(start, X + K):
        ans += str(start) + ' '

    print (ans)

def main():
    inp = input()
    inp = inp.split()
    K = int(inp[0])
    X = int(inp[1])
    Printer(K, X)



if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys

K,X = map(int,sys.stdin.readline().split())
left=max(-1000000, X-K+1)
right=min(1000000, X+K-1)

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

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

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

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

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

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

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

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):
i = list(map(int, input().split()))

for j in range(i[1] + 1 - i[0], i[1] + i[0]):
    print(j, end=" ")

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

Solution (Python):
a, b = (int(i) for i in input().split()) 
s = b - (a-1)
e = b + (a-1)
lst = list(range(s, e+1))
lst.sort()
print(*lst)

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

Solution (Python):
K,X=[int(e) for e in input().split(' ')]
for i in range(2*(K-1)+1):
    print("{} ".format(X-(K-1)+i),end='')

Solution (Python):


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

min_range = X - K + 1
max_range = X + K

ans = []

for i in range(min_range, max_range):
    ans.append(i)
for i in range(0, len(ans)):
    print(ans[i], end=" ")

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

min_X = max(-1000000, X - K + 1)
max_X = min(1000000, X + K - 1)

stays = list(range(min_X, max_X+1))

print(' '.join([str(s) for s in stays]))

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

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

if __name__ == "__main__":
    f_b()

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

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

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

Solution (Python):

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

if __name__ == '__main__':
    main()

Solution (Python):


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

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

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

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

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

Solution (Python):
lines = range(-1000000,1000001)
k, x = [int(n) for n in input().split()]
print(*list(lines[1000000+(x-k+1):1000000+(x+k)]))

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

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

min1 = max([X-K+1,-1000000])
max1 = min([X+K-1,1000000])
for i in range(min1,max1+1):
    print(i,end=" ")

Solution (Python):
from sys import exit, stdin
K, X = [int(_) for _ in stdin.readline().rstrip().split()]
print(*[i for i in range((X-K+1), (X+K))])

Solution (Python):
def iread():
    return int(input())


def sread():
    return input()


def aread(t="int"):
    if t == "int":
        ret = [int(i) for i in input().split()]
    elif t == "str":
        ret = list(input())
    return ret


def scan():
    return list(map(int, input().split()))
    


def main():
    k, x = scan()
    r = range(x - k + 1, x + k, 1)
    for i in r:
        print('{} '.format(i), end="")
    print("")

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())
START=X-K+1
GOAL=X+K
LIST=[]
for i in range (START,GOAL):
  LIST.append(i)
print(*LIST)

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

    min_n = max(-1000000, x - k + 1)
    max_n = min(1000000, x + k - 1)

    print(' '.join(map(str, range(min_n, max_n + 1))))


if __name__ == "__main__":
    main()

Solution (Python):
k, x=map(int, input().split())
ans=""
for i in range(x-k+1, x+k):
    print(str(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())
tmp = [str(y) for y in range(x-k+1, x+k)]
print(' '.join(tmp))

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

Solution (Python):

K,X = (int(x) for x in input().split())


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

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


if __name__ == "__main__":
    main()

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

Solution (Python):

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

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

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

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

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

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

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

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

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

Solution (Python):
x=input().split()

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

for i in range(x[1]-x[0]+1,x[1]+x[0]):
    print(i)

Solution (Python):
a = []

a = input().split()

K = int(a[0])

X = int(a[1])

b = []

for i in range(2 * K -1) :
	b.append(X - (K - 1 - i))
	print(b[i], ' ', )

Solution (Python):

k, x = map(int, input().split())
print(" ".join(map(str, [i for i in 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, end =" ")

Solution (Python):
k, x = map(int, input().split())
print(" ".join(map(str, [i for i in 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):



mn,mx = -1000000,1000000

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

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

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

Solution (Python):
from sys import stdin

K, X = [int(x) for x in stdin.readline().rstrip().split()]
ans = [x for x in range(max(X - (K - 1), -1000000), min(X + K, 1000001))]
print(*ans)

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

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

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

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

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

K = inputNum[0]
X = inputNum[1]

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):
    if i == X + K - 1:
        print(i)
    else:
        print(i, end = " ")

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

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

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

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

minint = max(-1000000, x-k+1)
maxint = min(1000000, x+k)

for i in range(minint, maxint):
    print(i, end=' ')

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

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

Solution (Python):


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

Solution (Python):
n = list(map(int, input().split()))
k = n[0]
x = n[1]
s1 = x - k + 1
s2 = x + k - 1
a1 = list(range( (s1), (s2 + 1)  ))
print(" ".join(list(map(str, a1))))

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

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())
lowest = max(-10000000, X - K + 1)
highest = min(10000000, X + K - 1)
ans = list(map(str,[i for i in range(lowest, highest+1)]))
print(" ".join(ans))

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

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

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

min = 1000000*-1
max =  1000000


if x-k+1 > min:
  min = x-k+1

if x+k < max:
  max = x+k

for i in range(min,max):
	print(i,end=' ')
print()

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

Solution (Python):
Len, Pos = map(int, input().split())
Left = -1000000
Right = 1000000

candL = max(Pos-Len+1, Left)
candR= min(Pos+Len-1, Right)

cand = [x for x in range(candL, candR+1)]
ans = ''

for s in cand:
  ans += str(s) + ' '
  
print(ans.rstrip())

Solution (Python):
''' بِسْمِ اللَّهِ الرَّحْمَٰنِ الرَّحِيمِ '''
gi = lambda : list(map(int,input().split()))
a, b = gi()
print(*range(b - a + 1, b + a))

Solution (Python):
def main():
  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())
ans = []
for i in range(max(x - k + 1, -1000000), min(x + k - 1, 1000000) + 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):
    if i < X + K - 1:
       print(i, end=' ')
    else:
       print(i)

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

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

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

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


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



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

Solution (Python):
k, x = map(int, input().split())
res = []
N = 1000000
if x - k + 1 < -N:
	res = list(range(-N, -N + k))
elif x + k - 1 > N:
	res = list(range(N - k + 1, N + 1))
else:
	res = list(range(x - k + 1, x + k))
print(" ".join([str(x) for x in res]))

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

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

Solution (Python):
a,b=map(int,input().split())
if(a==1):
    print(b)
else:
    e=b-(a-1)
    while(e<=(b+(a-1))):
        print(e,end=' ')
        e+=1

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

Solution (Python):

def main():
    K, X = tuple(map(int, input().rstrip().split()))
    mi, ma = max(-1000000, X - K + 1), min(1000000, X + K - 1)
    ans = [i for i in range(mi, ma + 1)]
    print(*ans)


if __name__ == "__main__":
    main()

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

Solution (Python):
from sys import stdin

readline = stdin.readline


def main():
    k, x = map(int, open(0).readline().split())
    print(*range(x-k+1, x+k))


if __name__ == "__main__":
    main()

Solution (Python):
k, x = [int(_) for _ in input().split()]
print(*list(range(max(x - k + 1, -1000000), min(x + k, 1000001))))

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

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

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

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(' '))
List = []
for i in range(X,X+K):
  List.append(i)
for j in range(X-1,X-K,-1):
  List.append(j)
List.sort()
print(*List)

Solution (Python):
k, x = map(int, input().split())
END = 10**7
dx = k-1
ans = [str(i) for i in range(max(x-dx, -END), min(x+k, END))]
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());print(*range(x-k+1,x+k))

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

Solution (Python):
k, x = (int(i) for i in input().split())
l = x - k + 1
r = x + k - 1
if l < -1000000:
  l = -1000000
if r > 1000000:
  r = 1000000
print(*list(range(l,r+1)))

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

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

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

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

min_n = max(-1000000, x-k+1)
max_n = min(1000000, x+k-1)
ans = list(range(min_n, max_n+1))
ans = [str(x) for x in ans]
print(" ".join(ans))

Solution (Python):
while True:
    try:
        K, X = map(int, input().split())
        print(' '.join(map(str, range(X - K + 1, X + K))))
    except EOFError:
        break

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

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

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

Solution (Python):
K, X = list(map(int, input().split()))
minimum = X - (K-1)
MAXIMUM = X + (K-1)
if minimum < -1000000:
  minimum = -1000000
if MAXIMUM > 1000000:
  MAXIMUM = 1000000
  
for x in range(minimum,MAXIMUM+1):
  print(str(x), end=" ")
  
print()

Solution (Python):
import numpy as np

K, X = map(int, input().split())
Ans = np.arange(X-K+1, X+K)
print(*Ans)

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

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

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

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

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

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

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

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

a=max(-100000,x-k+1)
b=min(100001,x+k)

res=list(range(a,b))
res=[str(i) for i in res]
print(" ".join(res))

Solution (Python):
def find(K,X):
    left=-10**6
    right=10**6
    ans=[]
    for i in range(X-K+1,X+K):
        if i>=left and i<=right:
            ans+=[str(i)]
    print(" ".join(ans))
K,X=list(map(int,input().strip().split(' ')))
find(K,X)

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

Solution (Python):
import sys



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

raw_input = sys.stdin.readline

if __name__ == '__main__':
	
	main()

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

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

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

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())
left = x - k + 1
right = x + k - 1

ptn = []
for i in range(left, right+1):
    ptn.append(i)

print(*ptn)

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

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

Solution (Python):
k, x = map(int, input().split())
print(*range(max(-1000000, x - k + 1), min(1000000, 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(X - K + 1, X + K):
  if i < X + K - 1:
    print(i, end=' ')
  else:
    print(i)

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

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

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

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


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

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

print()

Solution (Python):
import numpy as np
i = list(map(int, input().split()))
K = i[0]
X = i[1]
start_point = X - K+1
end_point = X + K
result = np.arange(start_point, end_point)
for i in result:
    print(i)

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

nmin = x - k + 1
nmax = x + k - 1

ans = [i for i in range(nmin,nmax + 1)]
print(*ans)

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

Solution (Python):
import numpy as np
i = list(map(int, input().split()))
K = i[0]
X = i[1]
start_point = X - K+1
end_point = X + K
result = np.arange(start_point, end_point)
for i in result:
    print(i)

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

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

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

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

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

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

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

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

st = X - K + 1

en = X + K - 1

if st <= -1000000: st = -1000000

if en >= 1000000: en = 1000000

for i in range(st, en + 1):
    print(i, end = ' ')

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

minx = max([x-k+1, -1000000])
maxx = min([x+k-1, +1000000])

i = minx
while i <= maxx:
    print (i)
    i += 1

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

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

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

Solution (Python):

K, X = map(int,input().split())
ans = []

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

Solution (Python):
K,X = map(int,input().split())
if K == 1:
    print(X)
    exit()
checkpoint = X
result = set()
start = checkpoint - K + 1
for i in range(K):
    for i in range(K):
        result.add(start + i)
    start = start + 1
result = sorted(result)
L=[str(a) for a in result]
L=" ".join(L)
print(L)

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

k = int[0]
x = int[1]

p=x + 1 
q=p - k
r=x + k

s =list(range(q,r))
print(*s)

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

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

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

def SORO_INT(): return int(INPUT())
def MULT_INT_LIST(): return list(map(int, INPUT().split()))
def MULT_INT_MAP(): return map(int, INPUT().split())
def SORO_STRING(): return INPUT()
def MULT_STRING(): return INPUT().split()
 
K,X = MULT_INT_LIST()
ans = []
kuro_min = X-K+1
kuro_max = X+K-1
for i in range(kuro_min,kuro_max+1):
    ans.append(i)
ans = str(ans)
ans = ans.replace(",", "")
ans = ans.strip('[]') 
print(ans)

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

c = b + a - 1
d = b - a + 1

n_list = []

if c == d:
    print(c)
elif c != d:
    max_n = max(c,d)
    min_n = min(c,d)
    for i in range(min_n, max_n+1):
        n_list.append(i)
    


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

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