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, raw_input().split())

mi = max(-10 ** 6, x - k + 1)
mx = min(10 ** 5, x + k - 1)

print (' '.join(map(str, range(mi, mx + 1))))

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

Solution (Python):
import sys

def solve(k, x):
  min_x = max(-1000000, x - k + 1)
  max_x = min(x + k - 1, 1000000)
  ans = [i for i in xrange(min_x, max_x + 1)]
  print " ".join(map(str,ans))


if __name__ == '__main__':

  k, x = map(int, sys.stdin.readline().strip().split(" "))
  solve(k, x)

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

print()

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

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

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

Solution (Python):


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

mn = x - k + 1
mx = x + k - 1

ans = ""
for i in range(mn, mx+1):
    ans += str(i) + " "

ans = ans.rstrip()
print(ans)

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

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

list = []

for i in range(k-(n-1), k+(n-1)+1, 1):
    list.append(i)

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

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

Solution (Python):


import sys

debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    token = lines[0].split()
    k = int(token[0])
    x = int(token[1])

    return (k, x)


def solve(k, x):


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

    result = " ".join([str(i) for i in range(start, end + 1)])
        

    return result


def main():
    

    print("%s" % solve(*parse_input()))

if __name__ == '__main__':

    main()

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

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

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

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

Solution (Python):
import numpy as np

k, x = map(int, input().split())
idx = x + 1000000
a = np.arange(-1000000,1000001)
for i in range(2*k-1):
  print(a[idx-k+1+i], end=" ")

Solution (Python):

k,x = map(int,input().split())
ans = []
for i in range(2*k-1):
    if x -k + i +1  < -1000000:
        continue
    elif x -k + i + 1 > 1000000:
        continue
    else:
        ans.append(x-k+i+1)
print(*ans)

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


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

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

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

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

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

shift = -K+1
for i in range(2*K-1):
    if X+shift< -1000000 or X+shift > 1000000:
        continue
    ans.append(X+shift)
    shift += 1
    
for s in ans:
    print(s,end=" ")

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

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

string = [str(i) for i in range(min_X, max_X+1)]
print(' '.join(string))

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

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

K = int(k)
X = int(x)

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

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

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

start = max(-1000000, X - K + 1)
end = min(1000000, X + K - 1)

A = [i for i in range(start,  end + 1)]
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())

a = x-k+1
b = x+k-1

h = list(range(a, b+1))
f = []
for i in h:
    f.append(str(i))
print(' '.join(f))

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

lb = X-(K-1)
ub = X+(K-1)

lb = max(-1000000,lb)
ub = min(1000000,ub)

L = list(range(lb,ub+1))

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

Solution (Python):
K,X=map(int, input().split())
L=-10**6
R=10**6
mini=max(L,X-K+1)
maxi=min(R,X+K-1)
for i in range(mini, maxi+1):
  print(i, end=" ")
print()

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

l=[]
for i in range(-k+1,k):
    a=x-i
    if a>=-1000000 and a<=1000000:
        l.append(a)
    else:
        pass
l.sort()

print(*l)

Solution (Python):





K, X = map(int, input().split())
res = ""
for i in range(X - K + 1, X + K):
    if i != X + K:
        res = str(res + str(i) + " ") 
    else:
        res = str(res + str(i)) 

print(res)

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

ans = []



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

Solution (Python):
import sys
K, X = map(int, raw_input().split())

assert(1<= K <= 100)
assert(0<=X<=100)

left = X - (K - 1)
left = max(left, -1000000)

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

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

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

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

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

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

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

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

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

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

for i in range(X-K+1, X+K):
    sys.stdout.write(str(i) + ' ')

Solution (Python):

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

m, M = x-k, x+k
if m < -100000:
    m = -100000
if M > 100000:
    M = 100000

for i in range(m+1, M-1):
    print(str(i) + ' ', end="")
print(M-1)

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

diff = k-1

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

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

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

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

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

print(*a)

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

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

    a_list.sort()

    print(' '.join([str(a) for a in a_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()) 
v=[]
for i in range(2*k-1):
    v.append(x-k+1+i)
print(' '.join(map(str, v)))

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

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

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

Solution (Python):



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

length = 2 * K - 1
left = X - K + 1

for i in range(length):
    print(left + i, end=' ')

print('')

Solution (Python):
k, x = map(int, input().split())
m = 10 ** 6
x_min = max([-m, x - (k - 1)])
x_max = min([ m, x + (k - 1)])
print(' '.join(map(str, range(x_min, x_max+1))))

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

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

Solution (Python):
def main():
    kx = input().split()
    
    k, x = int(kx[0]), int(kx[1])
    l = max(-1000000, x-(k-1))
    r = min(1000000, x+(k-1))
    output = []
    for i in range(l, r+1):
        output.append(i)
    return output


if __name__ == '__main__':
    output = main()
    print(' '.join(map(str, output)))

Solution (Python):

k, x = map(int, input().split())
m = x - k + 1
l = x + k - 1

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

print(' '.join(list(map(str, ptn))))

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(2*k-1):
    a.append(x-k+1+i)
    
print(*a)

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

lis=[]

for i in range(x-k+1,x+k):
    if i>=-10000000 and i <=1000000:
        lis.append(i)

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

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

x - k + 1
x + k - 2

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

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

arr = []

for x in range(xmin, xmax+1):
    arr.append(str(x))

print(' '.join(arr))

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

Solution (Python):



def solve(K, X):
    left = max(X-K+1, -1000000)
    right = min(X+K-1, 1000000)
    ans = range(left, right+1)
    return ans


if __name__ == '__main__':
    K, X = map(int, input().split())

    ans = solve(K, X)

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

Solution (Python):

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

result = []
for i in range(-1000000,1000001):
    if x-k < i and i < x + k:
        result.append(str(i))
print("{}".format(' '.join(result)))

Solution (Python):
import sys
import numpy as np
def main():
    input = sys.stdin.readline
    KX = list(map(int, input().split()))
    K = KX[0]
    X = KX[1]

    low = X - K + 1
    up = X + K - 1

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

    ary = np.arange(start=low, step=1, stop=up+1)
    ary = ary.astype("str")
    li = list(ary)
    ans = " ".join(li)

    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):


def main():
    K,X = map(int, input().split())
    P = max(-1000000, X-(K-1))
    Q = min(1000000, X+(K-1))

    print(' '.join(map(str, [k for k in range(P, Q+1)])))


if __name__ == '__main__':
    main()

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

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

print()

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

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

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

Solution (Python):
li = list(map(int,input().split()))
K = li[0]
X = li[1]
L = list(range(X-K+1,X+K))
for l in L:
    if -10000 <= l <= 10000:
        print(l,end=' ')

Solution (Python):
"""
AtCoder
    :author: vierbein
"""
from __future__ import absolute_import, division, print_function



import sys


def pp(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)


K, X = map(int, input().split())
res = range(max(-1000000, X-K+1), min(100001, X + K))
print(*res)

Solution (Python):



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



minimum = max(X - (K - 1), -1000000)
maximum = min(X + (K - 1), 1000000)

ans = list(range(minimum, maximum + 1))

for i in ans:
    print(i, end=' ')

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

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

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

Solution (Python):
import sys
from operator import itemgetter
input = sys.stdin.readline
A,B=map(int,input().split())
for i in range(B-(A-1),A+B):
  if i != A+B-1:
    print(i,end=' ')
  else:
    print(i,end='')

Solution (Python):
k, x = map(int, input().split())
mx = max(-1000000, x - k + 1)
nums = []
for i in range(k * 2 - 1):
    if mx + i > 1000000:
        break
    nums.append(mx + i)
print(' '.join(map(str, nums)))

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

Solution (Python):


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


s = k-x+1
num = x*2-1

for i in range(num):
    print(s+i)

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

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

Solution (Python):


import copy
import sys
import math


tmp = input().split()
hoge = list(map(lambda a: int(a), tmp))

k=hoge[0]
x=hoge[1]

ans=""
for i in range(0,2*k-1):
	if((x-k+1+i) >=(-1000000))and((x-k+1+i)<=1000000):
		if(len(ans)!=0):
			ans+=" "
		ans+=str(x-k+1+i)

print(ans)

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

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

li = []

if X-K < -1000000:

  for i in range(-1000000, -1000000 + K):
    li.append(i)
elif X+K >1000000:
  for i in range(1000000 - K, 1000000):
    li.append(i)
else:
  for i in range(X-K+1, X+K):
    li.append(i)

print (' '.join(map(lambda x: str(x), li)))

Solution (Python):
n,k=map(int,input().split())
ra=range(max(-1000000,k-(n-1)),min(1000000+1,k+(n-1)+1))
li=[i for i in ra]
print(*li,sep=' ')

Solution (Python):
k,x = map(int,input().split())
k = k-1
Min = x - k
Max = x + k
if(Min<=-1000000):
  Min = -1000000
if(Max>=1000000):
  Max = 1000000
n = Min
while True:
  print(n)
  if(n==Max):
    break
  n+=1

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

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

Solution (Python):



import sys
input = sys.stdin.readline


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

    for i in range(x - (k - 1), x + (k - 1) + 1):
        if abs(i) > 1000000:
            continue

        if i != x + (k - 1):
            print("{} ".format(i), end="")
        else:
            print("{}".format(i), end="")
    print()


if __name__ == '__main__':
    main()

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

ans = ''

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

print(ans.rstrip(' '))

Solution (Python):
k,x=map(int, input().split())
a=list(range(x-(k-1), x+(k-1)+1))
b=[i for i in a if -1000000<=i<=1000000]
string=""
for v in b:
    string+=str(v)+" "
print(string)

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
k,x=map(int,input().split())
print(' '.join(str(c) for c in range(max(x-(k-1),-1000000), x+k)))

Solution (Python):
import math
import sys
import itertools
import queue
from fractions import gcd

def lcm(a, b):
    return a * b // gcd(a, b)

mod = 1000000007

"""

a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654


char_list = list("abcd") 



    = sys.stdin.readline().rstrip()
    = list(sys.stdin.readline().rstrip())


    = int(sys.stdin.readline())
    = map(int, sys.stdin.readline().split())
    = list(map(int, sys.stdin.readline().split()))
    = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  
"""

if __name__ == "__main__":
    K, X = map(int, sys.stdin.readline().split())
    ls = []
    for i in range(max(-1000000, X - K + 1), X):
        ls.append(i)
    for i in range(X, min(X + K, 1000001)):
        ls.append(i)

    print(*ls)

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 numpy as np

I=np.array(input().split(),dtype=np.int32)

K=I[0]
X=I[1]

result=""

for x in range(X-(K-1),X+K):
    result=result+str(x)+" "

print(result)

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

Solution (Python):
k, x = map(int, input().split())
l = [i for i in range(x-k+1, x+k)]
print(*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())
list = []
for i in range(X-K+1,X+K):
    list.append(i)

print(*list)

Solution (Python):

def main():
    k,x = map(int,input().split())
    ans = set()
    for i in range(k):
        if  -1000000<=x+i<=1000000:
            ans.add(x+i)
        if  -1000000<=x-i<=1000000:
            ans.add(x-i)
    ans = list(ans)
    ans = sorted(ans)
    for i in ans:
        print(i,end=" ")
if __name__ == '__main__':
    main()

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

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

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

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

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

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

Solution (Python):

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

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

print(str(X) + " ")

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

Solution (Python):
K, X = map(int, input().rstrip().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())
ans = []
for i in range(0,2*k - 1):
    ans.append(x-(k-1)+i)
print(*ans)

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

mini = S[1]-S[0]+1
deka = S[1]+S[0]
arr = [i for i in range(mini,deka)]
for i in range(len(arr)):
    print(arr[i],end=" ")

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

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

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

    print(" ".join(ans))


if __name__ == '__main__':
    p_b()

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

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

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

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

Solution (Python):


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

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

print(" ".join(results))

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

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

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

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

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

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

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

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

ans = []

for i in range(kosuu):
  ans.append(zahyou+i)
  if i != 0:
    ans.append(zahyou-i)


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

Solution (Python):
import  numpy   as  np

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

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

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

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

pos.sort()

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

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

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

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

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

left = X - (K-1)
right = X + (K-1)

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

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

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

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

K = parents[0]
X = parents[1]

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

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

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

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

k-=1

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

print(' '.join(line))

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

    answer = []
    for i in range(max(-1000000, x-k+1), min(1000000, x+k-1)+1):
        answer.append(str(i))

    print(" ".join(answer))

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

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

if x_min < -1000000:
    x_min = -1000000

if x_max > 1000000:
    x_max = 1000000


result = []
for i in range(x_min, x_max+1):
    result.append(str(i))

print(' '.join(result))

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

Solution (Python):
B = 1000000
K,X = map(int,input().split())
up = min(X+K,B+1)
down = max(X-(K-1),-B)

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

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

s= ""
for i in range(max(-100000,k-n+1), min(100000,k+n-1)+1):
  if i != max(-100000,k-n+1):
    s += " "
  s += str(i)
  
print(s)

Solution (Python):



def main():
    k, x = map(int, input().split(" "))
    saidai = x + k-1
    saishou = x - k + 1
    r = ""
    for i in range(saishou, saidai+1):
        r = r + str(i) + " "
    print(r[0:-1])

main()

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

print(' '.join(map(str,filter(lambda y: y >= -1000000 and y <= 1000000,range(x - k + 1, x + k)))))

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

l = X - K + 1
r = X + K - 1
ans = ''
for i in range(2 * K - 1):
    ans += str(l + i)
    if i != 2 * K - 1:
        ans += ' '
print(ans)

Solution (Python):
K, X = [int(kx) for kx in input().split()]
A = range(X-K+1, X+K)
ANS = []
for a in A:
  if -1000000 <= a <= 1000000:
    ANS.append(str(a))
ans = " ".join(ANS)
print(ans)

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

Solution (Python):
def A():
    a, b = map(int, input().split())
    lt = [
        a + b,
        a - b,
        a * b
    ]
    print(max(lt))


def B():
    k, x = map(int, input().split())
    
    answer = ''
    for i in range(2*k-1):
        answer += str(x-k+1+i) + ' '
    
    answer = answer[:-1]
    print(answer)
    

if __name__ == '__main__':
    B()

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())
b = x - k + 1
n = 2 * k - 1
print(' '.join([str(b + i) for i in range(n)]))

Solution (Python):


K, X = [int(x) for x in input().split()]
MIN = -1000000
MAX = 1000000

start = max(MIN, X-K+1)
end = min(MAX, X+K-1)
print(" ".join(map(str,list(range(start, end+1)))))

Solution (Python):
K, X = map(int, input().split())
m = max(X - K + 1, -1000000)
M = min(X + K - 1, 1000000)
ans = [i for i in range(m, M + 1)]
print(' '.join(map(str, 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())
for i in range(x-k+1,x+k):
    print(str(i), " ",end="")

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

m = max(X-K+1,-1000000)
M = min(X+K-1,1000000)
ans = []
while m <= M:
    ans.append(str(m))
    m += 1

print(' '.join(ans))

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

Solution (Python):
import sys, math

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

    ans = [x for x in range(X-K+1,X+K-1+1)]
    print(*ans)

if __name__=='__main__':
    main()

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

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

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

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

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

ans2 = list(range(X-(K-1), X+K))
ans = []

for a in ans2:
    if -1000000 <= a <= 1000000:
        ans.append(str(a))

print(' '.join(ans))

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

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

print(*list(range(x-k+1, x+k)))

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

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

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

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

first=x-k+1
last=x+k-1
numlist=[]

if first>=-1000000 and last<=1000000:
    for i in range(first,last+1):
        numlist.append(str(i))
elif last<=1000000:
    for i in range(-1000000,last+1):
        numlist.append(str(i))
elif first>=-1000000:
    for i in range(first,1000001):
        numlist.append(str(i))
else:
    for i in range(-1000000,1000001):
        numlist.append(str(i))
print(" ".join(numlist))

Solution (Python):

import sys


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

for a in sorted(ans):
    print(a,end=" ")
print()

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

M = 2*K-1

ansList = [X-K+1] * (M)

for i in range(M):
    ansList[i] += i

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

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

_black_list = []

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

print(' '.join([str(x) for x in _black_list]))

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

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

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

Solution (Python):


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

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

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

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

Solution (Python):

k, x = [int(el) for el in input().split(' ')]

ans = list(range(x - (k-1), x + k))
print(' '.join([str(el) for el in ans]))

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

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

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

Solution (Python):
k, x = [int(i) for i in 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())
print(*list(range(max(-1000000, x-k+1), min(x+k, 1000001))))

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

Solution (Python):
kx = list(map(int, input().split()))
k = kx[0]
x = kx[1]
right = min(x + k - 1, 1000000)
left = max(x - k + 1, -1000000)
res = range(left, right + 1)
print(" ".join(map(str, res)))

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

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