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

Solution (Python):
K,X = list(map(int,input().split()))
a = X-K+1
b = X+K-1
I = list(range(a,b+1))
print(' '.join(str(ans) for ans in I))

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

bot = max(x - k + 1, -1000000)
top = min(x + k - 1, 1000000)

print(' '.join(str(ans) for ans in list(range(bot, top + 1))))

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

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

ans = 0
for i in range(-1000000,1000000+1):
    if abs(i-X) <= K-1:
        print(i, " ", end="")

Solution (Python):
a,b=map(int,input().split())
A=list()
for n in range(b-a+1,b+a):
  A.append(n)
print(' '.join(map(str,A)))

Solution (Python):

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

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

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

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

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

print(ans)

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

max = count + x
min = x - count + 1

array = list(range(min, max))
array = map(str, list(range(min, max)))

print(' '.join(array))

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

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

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

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()
L=[str(k) for k in a]
L=" ".join(L)
print(L)

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

Solution (Python):
max_num = 1000000
min_num = -1000000
k,x = map(int, input().split())
if x + k > 1000000:
    min_num = x - k + 1
elif x - k < -1000000:
    max_num = x + k - 1
else:
    min_num = x - k + 1
    max_num = x + k - 1

ans = ""
for i in range( min_num, max_num + 1 ):
    ans = ans + str(i) + " "

print( ans )

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

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

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

Solution (Python):
n,k=map(int,input().split())
i=k-n+1
while i<k+n:
    print(i,end=" ")
    i +=1

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

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

S = max(X-K+1,-1000000)
G = min(X+K-1,1000000)

for n in range(S,G+1):
    print(n,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())
min = x - k + 1
max = x + k
a = list(map(str, list(range(min, max))))
print(' '.join(a))

Solution (Python):
import math
N,X = list(map(int,input().split(" ")))

nums = []
for i in range(N-1,0,-1):
    nums.append(X - i)


for i in range(N):
    nums.append(X + i)



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

Solution (Python):
import numpy as np

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

upper = x + k - 1
lower = x - k + 1 

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

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

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

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

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

if 1 > k and k > 100:
	raise 
if 0 > x and x > 100:
	raise

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

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

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

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

Solution (Python):


SELECT = "AB"[1]

if SELECT == "A":  

    a, b = map(int, input().split())
    plu = a + b
    dis = a - b
    multi = a * b
    print(max(plu, dis, multi))

else:  

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

Solution (Python):
MAX = 1000000
MIN = -1000000

K,X = map(int, input().split())
range_min = max(MIN, X-(K-1))
range_max = min(MAX, X+(K-1))

for i in range(range_min, range_max+1):
    print(i, end=" ")

Solution (Python):
delta, base = map(int, raw_input().split())
lines = range(base - delta + 1, base + delta)
print ' '.join([str(i) for i in lines])

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

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

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

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

l = x - k + 1
m = x + k

for i in range(l, m):
    print(i)

Solution (Python):


SELECT = "AB"[1]

if SELECT == "A":  

    a, b = map(int, input().split())
    plu = a + b
    dis = a - b
    multi = a * b
    print(max(plu, dis, multi))

else:  

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

Solution (Python):
k,x=map(int, 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, n = map(int,input().split())

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

Solution (Python):

a, b = map(int, input().split())

startp = b - a + 1

ans = []
for i in range(a + a - 1):
    if ( startp + i >= -1000000 and startp + i <= 1000000):
        ans.append(str(startp + i))

print ( ' '.join(ans) )

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

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=[]
st=x-k+1
ed=x+k-1
while st<=ed:
    ans.append(st)
    st+=1
for a in ans:
    print(a, end=" ")

Solution (Python):
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())
A=X-K+1
B=X+K-1
L=[]
for i in range(A,B+1):
  if i > 1000000 or i < -1000000:
    continue
  L.append(str(i))
print(*L)

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

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

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

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

plus_max = X + (K-1)
minus_max = X + -(K-1)
ret_list = []
for i in range(plus_max-minus_max+1):
  ret_list.append(str(minus_max+(i)))

print(' '.join(ret_list))

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

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

m1 = n2 - n1 + 1

r1 = ""
for i1 in range((2 * n1) - 1):
    r1 += str(m1 + i1)
    if i1 != ((2 * n1) - 2):
        r1 += " "

print(r1)

Solution (Python):











import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf=float('inf')
mod = 10**9+7
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    K,X = MI()
    ans = [X-K+1+i for i in range(2*K-1)]
    print(*ans)
if __name__ == '__main__':
    main()

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
k,x=map(int,input().split())
ans=[]
for i in range(k*2-1):
    ans.append(x-k+i+1)
    
print(" ".join(map(str,ans)))

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

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

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

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

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

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

for i in range(x-k+1, x+k):
  if i >= -1000000 and i <= 1000000:
    s += ' ' + str(i)

print(s.lstrip())

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

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

minimum = x - k + 1
maximum = x + k - 1
for i in range(minimum, maximum + 1):
    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())
res = list(range(x - k + 1, x + k))
res = ' '.join(map(str, res))
print(res)

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

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

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

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

x_min = X - K + 1
x_max = X + K - 1

for i in range(x_min, x_max):
    print(str(i)+' ', end='')

print(x_max)

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

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

ans = x - k + 1

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

print("")

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

list_b = []

for i in range(2*k-1):
    list_b.append(x-k+i+1)

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

Solution (Python):
k, x = map(int, input().split())
li = []
li1 = []
li2 = []
for i in range(k):
    li.append(x-i)
for i in range(k):
    li1.append(x+i)
li2 = li + li1
li2 = set(li2)
li2 = sorted(li2)
for i in range(len(li2)):
    print(li2[i], end=' ')

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

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

Solution (Python):
k,x = list(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 = []
for i in range(X-K+1, X+K):
    if (-1000000 <= i) and (i <= 1000000):
        ans.append(i)
print(*ans)

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

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

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

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

Solution (Python):
def solve():
    k, x = read()
    result = think(k, x)
    write(result)


def read():
    return read_int(2)


def read_int(n):
    return list(map(lambda x: int(x), read_line().split(' ')))[:n]


def read_float(n):
    return list(map(lambda x: float(x), read_line().split(' ')))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(k, x):
    minimum = -1000000
    maximum = 1000000

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

    return list(range(left, right + 1))


def write(result):
    print(' '.join(map(str, result)))


if __name__ == '__main__':
    solve()

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

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

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

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

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

Solution (Python):

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

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

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

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

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

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

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

ans = [str(n) for n in range(s, (X + K))]
print(" ".join(ans))

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

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

ans = [x]

for a in range(1, n):
    ans.append(ans[0] + a)
    ans.append(ans[0] - a)

print(*sorted(ans), sep=' ')

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(max(-10**6, X-K+1), min(10**6+1, X+K)):
    if i != min(10**6+1, X+K)-1:
        print(i, end=' ')
    else:
        print(i)

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

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

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

list=[]

for i in range(2*k-1):
    list.append(x-k+i+1)
    
print(*list)

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

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

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

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

Solution (Python):


_input = list(map(int, input().split()))
k = _input[0]
x = _input[1]
_min = (x - k + 1 if x - k + 1 >= -1000000 else -1000000)
_max = (x + k - 1 if x + k - 1 <= 1000000 else 1000000)

print(*range(_min, _max + 1))

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

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

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

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

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

neg_inf, pos_inf = -1000000, 1000000

start, end = max(x-k+1, neg_inf), min(x+k, pos_inf+1)

arr = [i for i in range(start, end)] 
print(*arr)

Solution (Python):




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

first = max(-1000000, x-k+1)
end = min(1000000, x+k-1)

for i in range(first, end+1):
    print(i)

Solution (Python):

"""
Created on Wed Aug 21 22:46:44 2019

@author: Yamazaki Kenichi
"""

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

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys
import bisect

mod = 10**9+7
sys.setrecursionlimit(mod) 

def LI(): return list(map(int, sys.stdin.readline().split()))


k,x = LI()


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

print("")

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

black_first = max(-1000000, x-k+1)
black_last = min(1000000, x+k-1)

for i in range(black_first, black_last+1):
    print(i)

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

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

Solution (Python):
K, X = map(int, input().split())
p = []
p.append(X)
a = X
b = X
for _ in range(K-1):
  a = a-1
  b = b+1
  p.append(a)
  p.append(b)
p.sort()
p_str = [str(n) for n in p]
print(' '.join(p_str))

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

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

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

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

Solution (Python):

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

A = X + (K - 1)
B = X - (K - 1)

print(' '.join(map(str, range(B, A+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 = list(map(int, input().split()))

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

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

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

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

Solution (Python):
k, x = tuple(map(int, input().split()))
values = []
count = (k - 1) * 2 + 1
value = x - (k - 1)
for i in range(count):
    values.append(str(value))
    value += 1

print(" ".join(values))

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

Solution (Python):
K,X = map(int,input().split())
ans = [str(num) for num in range(X-K+1,X+K) if -1000000<=num<=1000000]
print(" ".join(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):
  c.append(i)
print(*c)

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

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

mn = x-k+1
if mn<-1000000:
    mn = -1000000
mx =x+k-1
if mx>1000000:
    mx=1000000
ans = list(range(mn,mx+1))
print(' '.join(map(str, ans)))

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

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

print(mojiretu)

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

Solution (Python):
k,x=map(int,input().split())
if x-k+1<-10000:
  n=10000 
else:
  n=x-k+1
if x+k-1>10000:
  ma=10000
else:
  ma=x+k-1
while n<ma+1:
  print(n, end=" ")
  n+=1

Solution (Python):
k,x = map(int,input().split())
if x + k - 1 > 1000000:
  up = 1000000
else:
  up = x + k - 1
    
if x - k + 1 < -1000000:
  down = -1000000
else:
  down = x - k + 1

for i in range(down, up+1):
  print(i, end = " ")

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

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

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

X-(K-1)
X+(K-1)


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

str_list= [str(n) for n in list_a]

print(' '.join(str_list))

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


if __name__ == '__main__':
  main()

Solution (Python):
k, x = map(int, input().split())
minus = x - k + 1
plus = x + k - 1
all_list = list()
while True:
  if plus < minus:
    break
  else:
    all_list.append(str(minus))
    minus += 1
print(' '.join(all_list))

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_k = int(x-k+1)
max_k = int(x+k)
lis = list(range(min_k,max_k))
print(*lis)

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 = []

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

print(*a)

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

cnt=(K-1)*(-1)

while(1):
  print(X+cnt,end=" ")
  cnt+=1
  if(cnt==K):
    break

print( )

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

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

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

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

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

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


minnum = t[1] - t[0] + 1
length = t[0]*2 - 1

output=[]
for i in range(length):
    output.append(minnum+i)

print(*output)

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

Solution (Python):
k, x = tuple([int(i) for i in 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(X-K+1,X+K):
    
    if i < X+K-1:
        print(i,end=' ')
    else:
        print(i)

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):

MOD = 10 ** 9 + 7

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

ans = (str(x) for x in range(X - K + 1, X + K) if -1000000 <= x <= 1000000)

print(' '.join(ans))

Solution (Python):

MOD = 10 ** 9 + 7

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

ans = (str(x) for x in range(X - K + 1, X + K) if -1000000 <= x <= 1000000)

print(' '.join(ans))

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

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

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

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

min_val = X-K+1
max_val = K+X-1

min_val = -1000000 if min_val < -1000000 else min_val
max_val = +1000000 if max_val > +1000000 else max_val

for val in range(min_val, max_val+1):
	if val == max_val:
		print(val)
	else:
		print(val, end=' ')

Solution (Python):

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

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

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

Solution (Python):
k, x = map(int, input().split())
k_min = max([-1000000,x-k+1])
k_max = min([1000000,x+k-1])

ans = ' '.join([str(i) for i in range(k_min,k_max+1)])
print(ans)

Solution (Python):

from sys import stdin




def _li(): return list(map(int, stdin.readline().split()))
def _li_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def _lf(): return list(map(float, stdin.readline().split()))
def _ls(): return stdin.readline().split()
def _i(): return int(stdin.readline())
def _f(): return float(stdin.readline())
def _s(): return stdin.readline()[:-1]


K, X = _li()

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

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

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

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

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

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

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

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

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

for i in range(k-n+1,n+k):
    l.append(str(i))
    
print(' '.join(l))

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

K, X = MAP()

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

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

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

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

myans = []

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

print(*myans)

Solution (Python):
a,b=map(int,input().split(' '))
c=[]
for i in range(a):
    c.append(b-i)
for i in range(a):
    c.append(b+i)
m=set(c)
m=list(m)
m.sort()
for i in m:
    print(i,end=' ')

Solution (Python):



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

r = []

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

s = ""

for c in r:
    s += str(c)
    s += " "

print(s[:-1])

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

b = [n[1]]
for i in range(1, n[0]):
    b.append(n[1] + i)
    b.append(n[1] - i)
b=sorted(b)

for i in b:
    print(i,end=" ")

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