Problem:
 Score : 200 points    Problem Statement There are 2000001 stones placed on a number line. The coordinates of these stones are -1000000, -999999, -999998, \ldots, 999999, 1000000 .  Among them, some K consecutive stones are painted black, and the others are painted white.  Additionally, we know that the stone at coordinate X is painted black.  Print all coordinates that potentially contain a stone painted black, in ascending order.      Constraints  1 \leq K \leq 100  0 \leq X \leq 100  All values in input are integers.         Input Input is given from Standard Input in the following format:  K  X       Output Print all coordinates that potentially contain a stone painted black, in ascending order, with spaces in between.        Sample Input 1 3 7      Sample Output 1 5 6 7 8 9  We know that there are three stones painted black, and the stone at coordinate 7 is painted black. There are three possible cases:   The three stones painted black are placed at coordinates 5 , 6 , and 7 .  The three stones painted black are placed at coordinates 6 , 7 , and 8 .  The three stones painted black are placed at coordinates 7 , 8 , and 9 .   Thus, five coordinates potentially contain a stone painted black: 5 , 6 , 7 , 8 , and 9 .       Sample Input 2 4 0      Sample Output 2 -3 -2 -1 0 1 2 3  Negative coordinates can also contain a stone painted black.       Sample Input 3 1 100      Sample Output 3 100

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

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

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

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

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

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

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

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

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

Solution (Python):

import sys
input = sys.stdin.readline
K_black_num,X_coordinate = (int(x) for x in input().split())


start = X_coordinate -K_black_num +1
finish =X_coordinate +K_black_num -1

x =[i for i in range(start,finish+1) ]
print(*x)

Solution (Python):

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

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

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

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

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

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

Solution (Python):


def main():
    K, X = map(int, open(0).read().split())

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


main()

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

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

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

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

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

ans=X-K+1

print(ans,end="")

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

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

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

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

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

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

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

Solution (Python):
import sys
from math import ceil, floor, sqrt, sin, cos, pi
from itertools import accumulate, permutations, combinations
from fractions import gcd 
from collections import deque, Counter
from operator import itemgetter
from heapq import heappop,heappush
sys.setrecursionlimit(10**7)
def lcm(x, y): return ((x * y) // gcd(x, y)) 


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

Solution (Python):


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

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

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

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

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



main()

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

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

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

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

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

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

    else:
        ans += str(l[i]) + ' '
print(ans)

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

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 else print(i)

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

wa = A + B - 1
sa = B - A + 1

for i in range(sa, wa+1):
    print(i, end=" ")

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

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

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

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

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

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

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

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

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

l = []
cnt = -(k-1)

for i in range(k+k-1):
    l.append(x+cnt)
    cnt+=1

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

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())
start = X - (K - 1)
end = X + (K - 1)
for i in range(start, end+1):
    print("%d " % i, end="")
print()

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

Solution (Python):

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

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

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

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

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

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

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

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

A=[]
B=[]

for i in range(0,a):
  A.append(b+i)
  B.append(b-i)
C=A+B
D=sorted(set(C))
D=[str(a) for a in D]
D=' '.join(D)
print(D)

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

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

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

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

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

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

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

point = []
point.append(num[1])
for i in range(num[0] - 1):
  point.append(num[1] + i + 1)
  point.append(num[1] - i - 1)

m = 0
for i in range(len(point)):
  if point[i - m] > 1000000 or point[i - m] < -1000000:
    del point[i - m]
    m = m + 1

point.sort()

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

Solution (Python):
K,X = map(int,input().split())
for a in range(X-K+1,X+K):
    print(a,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(map(str, ans)))

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

    k,x = map(int, input().split())
    l = x-k+1
    r = x+k-1
    res = []
    for i in range(l, r+1):
        if -1000000<=i<=1000000:
            res.append(i)
    print(*res)

if __name__ == '__main__':
    main()

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

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

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

a = int(a)
b = int(b)

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

Solution (Python):
import sys
input = sys.stdin.readline
def main():
    K, X = map(int, input().split())
    LOWER = max(X - K + 1, -1000000)
    UPPER = min(X + K - 1, 1000000)
    ans = [str(i) for i in range(LOWER, UPPER+1)]
    print(" ".join(ans))

if __name__ == '__main__':
    main()

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

Solution (Python):

K, X = [int(s) for s in 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):
  if i < X + K - 1:
    print(i, end=' ')
  else:
    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 = list(map(int, input().split()))
print(*[i for i in range(x - k + 1, x + k)])

Solution (Python):

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

ans = []

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

ans = ' '.join(ans)

print(ans)

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

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

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

Solution (Python):


import sys



















def main():
    mod = 1000000007                  
    inf = float('inf')
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():  return int(input())
    def mi():  return map(int, input().split())
    def mi_0(): return map(lambda x: int(x)-1, input().split())
    def lmi(): return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():  return list(input())
    
    
    k, x = mi()
    for i in range(x - (k-1), x + (k-1) + 1):
        print(i, end=' ')
    print('')

if __name__ == "__main__":
    main()

Solution (Python):
import sys
import os
import math
import string

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

MOD = 10 ** 9 + 7


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    K, X = il()
    B = set(range(X - K + 1, X + 1))
    A = set(range(X, X + K))
    for i in sorted(B | A):
        print(i)


if __name__ == '__main__':
    main()

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

s=k*(-1) + 1

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

print()

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

L = X - K
R = X + K

answer = []

for i in range(-1000000, 1000001):
  if L < i < R:
    answer.append(i)

print(' '.join(str(x) for x in answer))

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

Solution (Python):
icase=0
if icase==0:
    k,x=map(int,input().split())
    kmin=x-k+1
    kmax=x+k-1
    for kk in range(kmin,kmax+1):
        print(kk,end=" ")
    print()

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

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

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

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 accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
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()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

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

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

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

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

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

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

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

for i in range(A,B+1):
    ans.append(i)

for x in range(len(ans)):
  print(ans[x])

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

if __name__ == "__main__":
    main()

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

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

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

if min_num < -1000000:
    min_num = -1000000
if 1000000 < max_num:
    max_num = 1000000

num_list = list(range(min_num, max_num + 1))
num_list = [str(x) for x in num_list]
print(" ".join(num_list))

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
from itertools import permutations,  combinations, accumulate
from functools import *
from collections import deque, defaultdict, Counter
from heapq import heapify, heappop, heappush, heappushpop

INF = float('inf')
NIL = - 1

""" Input
S = input().rstrip()
N = int(input())
A = list(map(int, input().split()))
A = np.array(input().split(), dtype=np.float64)
D = [int(input()) for _ in range(N)]
AB = [[int(x) for x in input().split()] for _ in range(N)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
"""

A, B = map(int, input().split())
ans = [B]

for i in range(1, A):
    ans.append(B + i)
    ans.append(B - i)


ans = sorted(ans)
print(*ans)

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

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

Solution (Python):
import numpy as np
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**8)
INF = float('inf')
MOD = 10**9+7


def main():
  K, X = map(int, readline().split())
  left = max(-1000000, X-K+1)
  right = min(X+K-1, 1000000)
  
  print(' '.join(map(str, range(left, right+1))))
  
  
if __name__ == '__main__':
  main()

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

for a in l:
    print(a, 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())
smallest=X-(K-1)
biggest=X+(K-1)

if smallest<-100000:

    biggest+=smallest+100000
    smallest=-100000

elif biggest>100000:
    smallest+=biggest-100000
    biggest=100000



nums=[i for i in range(smallest,biggest+1)]




ans=str("")
for n in nums:
    ans+=str(n)+" "
print(ans)

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

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

s = str(x - k + 1)

for i in range(x - k + 2, x + k):
    s += " " + str(i)

print(s)

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

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

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

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 = list(map(int,input().split()))
A = [None for _ in range(2*K - 1)]
for i in range(-(K-1) ,K):
  A[i] = X - i
B = sorted(A)
print(' '.join(map(str, B)))

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

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

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

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

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

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

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

print(li)

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

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

print()

Solution (Python):
a,b=input().split()
a = int(a)
b = int(b)
ans = []
for i in range(b-a+1, b):
    ans.append(str(i))
ans.append(str(b))
for i in range(b+1, a+b):
    ans.append(str(i))
print(' '.join(ans))

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

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

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

print(" ".join(l))

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

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

Solution (Python):
import io

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

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

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

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

black_list = []

for i in range(X - K + 1, X + K):
    black_list.append(i)
    
ans = " ".join(map(str, black_list))

print(ans)

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

Solution (Python):

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

min_k = x - k + 1
max_k = x + k - 1

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

print(*ans)

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

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

"""

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

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

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

'''
for i in range(-3,10):
    print(i,end=" ")
'''

Solution (Python):



from math import *
from copy import *
from string import *				
from random import *				
from bisect import *				
from sys import stdin				
from sys import maxsize
from operator import *				
from itertools import *
from collections import Counter		
from collections import defaultdict 

'''

'''

def solve(l):
	n = len(l)
	

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

Solution (Python):
import sys


def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())

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

def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'


p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")

k,x=MI()
l=[]

for i in range(x-k+1,x+k):
    if i >= -1000000 or i <= 1000000:
        l.append(i)
p2S(l)

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

if X + K > 1000000:
    ans = range(X - K + 1, 1000001)
    print(*ans)
elif X - K < -1000000:
    ans = range(-1000000, X + K)
    print(*ans)
else:
    ans = range(X - K + 1, X + K)
    print(*ans)

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

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

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

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

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

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

L = [ str(X - K + i) for i in range(1,2*K)]

print(" ".join(L))

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

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

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

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

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

for j in range(len(ans)):
  print(ans[j],end="")
  print(" ",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(*list(range(X-K+1,X+K)))

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

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

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

ans = [X]

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

ans.reverse()
for i in range(K-1):
    ans.append(X-(i+1))

ans.reverse()
print(*ans)

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

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

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

minimum = X - K + 1
maxium = X + K - 1
from_to = abs(minimum) + abs(maxium)

for xi in range(minimum, maxium + 1):
    print(xi, end=' ')

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

c = []
for i in range(2*k-1):
    c.append(x-(k-1-i))

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

Solution (Python):
from collections import deque
K, N = map(int, input().split())
ans = deque()
ans.append(N)
for i in range(1, K):
    ans.appendleft(N-i)
    ans.append(N+i)
print(*ans)

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

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

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

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

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

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

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

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

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

Solution (Python):

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

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

Solution (Python):
import os, sys, re, math

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

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

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

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

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

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

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

num,number=[str(x-(k-1))],x-(k-1)
for i in range(k+(k-2)):
  number+=1
  num.append(str(number))
  
print(" ".join(num))

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

Solution (Python):
def q2():
    K, X = (int(i) for i in input().split())
    min_pos = X - K + 1
    max_pos = X + K
    ans = map(lambda x: str(x), range(min_pos, max_pos))
    print(' '.join(list(ans)))


if __name__ == '__main__':
    q2()

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

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

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

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

for i in range((k-1) * 2 + 1):
    num = x - k + (i + 1)
    if -(10 ** 6) <= num and num <= (10 ** 6):
        print(num, end=' ')

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

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

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

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

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