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())
a, b = 0,0
A = []
if X - K+1 < -1000000:
  a = -1000000
else:
  a = X - K+1

if X + K-1 > 1000000:
  b = 1000000
else:
  b = X + K-1

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

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

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

print(*list_ans)

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

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

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

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

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

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

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

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

Solution (Python):
import numpy as np
p,q= input().split()
a,b =(int(p), int(q))
list_np = np.arange(-1000000, 1000000,1)
ans_list = []
for i in range(a):
    ans_list.append(b + i)
    ans_list.append(b - i)
ans_list.pop(0)
ans_list.sort()
ans=''

for i in range(a*2 -1):
    if i < a * 2 -1 :
        ans += str(ans_list[i])
        ans +=' '
    else:
        ans +=str(ans_list[i])
        break
print(ans)

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

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

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

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

for i in range(-10**6, 10**6+1):
    if abs(i-X)<K:
        ans.append(i)

print(*ans)

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

Solution (Python):










"""def kiri(n,m):
  r_ = n / m
  if (r_ - (n // m)) > 0:
    return (n//m) + 1
  else:
    return (n//m)"""
  
def main():
  k,x = map(int,input().split())
  P = []
  
  for i in range(x-k+1,x+k):
    P.append(i)
  
  print(*P)
  
  
if __name__ == '__main__':
  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())
maxx=0
minx=0
maxx=1000000 if x+k-1>1000000 else x+k-1
minx=-1000000 if x-k+1<-1000000 else x-k+1
ans=""
for i in range(minx,maxx+1):
  ans+=str(i)+" "
print(ans)

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

under = x-(k-1)
top = x+(k-1)

ans = ''
for i in range(under,top+1):
    if i == top:
        ans += str(i)
    else:
        ans += str(i)+' '


print(ans)

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

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

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

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

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

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()
input_nums = lambda: list(map(int, input().split()))

def main():
    K, X = input_nums()
    a = [x for x in range(K*2-1)]
    m = a[len(a)//2]
    d = m - X
    print(*[x - d for x in a])

if __name__ == '__main__':
    main()

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

Solution (Python):

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



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

print(*l,sep=" ")

Solution (Python):
a,b=map(int,input().split())
min=b-(a-1) 
if min<-1000000:
  min=-1000000    
max=b+(a-1)
if max>1000000:
  max=1000000
ans=[]

for i in range(min,max+1):
  ans.append(i)
print(*ans)

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

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

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


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

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

c_min = x - k + 1
c_max = x + k - 1

if c_min < -1000000:
    c_min = -1000000
if c_max > 1000000:
    c_max = 1000000

l_ans = []
for i in range(c_min,c_max+1):
    l_ans.append(i)

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    k,x=INTM()
    ans=[]
    a=max(-1000000, x-k+1)
    b=min(1000000, x+k-1)
    for i in range(a,b+1):
        ans.append(i)
    print(*ans)
if __name__ == '__main__':
    do()

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

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

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

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

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

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

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

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

minx = x - (k -1)
maxx = x + (k -1)

print(*[i for i in range(minx,maxx+1)])

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

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

k,x = iim()
l = list(range(x-k+1,x+k))
for item in l:
    print(item,end=' ')

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

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

if X-K<-1*MaxValue:
  ans=-1*MaxValue
  while ans<X+K:
    print(ans)
    ans+=1

elif X+K>MaxValue:
  ans=X-K+1
  while ans<=MaxValue:
    print(ans)
    ans+=1
else:
  for i in range(X-K+1,X+K):
    print(i)

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

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

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

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

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

print(ans)

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

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

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 = x - k + 1
e = x + k - 1

list = []
for i in range(s, e +1):
  list.append(i)

print(*list)

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

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

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

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

x = X - (K - 1)
y = X + (K - 1)

l = []
for i in range(x, y+1):
  l.append(str(i))
ans = ' '.join(l)
print(ans)

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

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

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())
for i in range(-1000000,1000001,1):
    if abs(i-x)<k:
        print(i,end=' ')
print()

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

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

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

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

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

Solution (Python):

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

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

out=[]
for i in range(min,max+1):
    out.append(i)

out = ' '.join(map(str,out))
print(out)

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

main()

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

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

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

K, X = lr()
left = max(X-K+1, -1000000)
right = min(X+K-1, 1000000)
answer = range(left, right+1)
print(*answer)

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

min_n = x - k + 1
max_n = x + k - 1

for i in range(min_n, max_n+1):
    print(i)

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

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

min_ = x - k + 1
max_ = x + k - 1

res = ""
for i in range(min_, max_ + 1):
  res += str(i)
  res += " "
print(res)

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

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

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

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

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

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

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

mn = max(-1000000, X - K + 1)
mx = min(+1000000, X + K - 1) + 1
ans = " ".join(map(str, range(mn, mx)))

print(ans)

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

if k > 1:
  for i in range(x - k + 2, x + k):
    b.append(i)

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

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

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

Solution (Python):












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

st = x-k+1
end = x+k

ans = list(range(st,end))

print(*ans)

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

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

Solution (Python):

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())
inf = 10 ** 6
ans = [i for i in range(max(-inf, x-k+1), min(inf, x +k-1)+1)]
print(*ans)

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

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

X_min = max(-1000000, X - K + 1)
X_max = min(+1000000, X + K - 1)

block_stones = [str(X_min + i) for i in range(X_max - X_min + 1)]
print(" ".join(block_stones))

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

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

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

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

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

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

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

Solution (Python):

"""
B - One Clue
https://atcoder.jp/contests/abc137/tasks/abc137_b

"""
import sys


def solve(K, X):
    return [i for i in range(X - K + 1, X + K) if -1000000 <= i <= 1000000]


def main(args):
    K, X = map(int, input().split())
    ans = solve(K, X)
    print(*ans)


if __name__ == '__main__':
    main(sys.argv[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())
s=[x-i for i in range(k)]
t=[x+i for i in range(1,k)]
print(*sorted(s+t))

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

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

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

print(" ".join(l))

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

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

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

Solution (Python):
import sys
from bisect import *
from heapq import *
from collections import *
from itertools import *
from functools import *

sys.setrecursionlimit(100000000)
input = lambda: sys.stdin.readline().rstrip()

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

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

Solution (Python):
def solve():
    N, M = map(int, input().split())
    l = [i for i in range(M-(N-1), M+(N-1)+1)]
    print(*l)




solve()

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

print(" ".join(map(str,list(range(X-K+1,X+K)))))

Solution (Python):
x,y=list(map(int, input().split()))
z=[0]*(x*2-1)

for i in range(x*2-1):
	z[i]=y-(x-1)
	y=y+1
print(*z)

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

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

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

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

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

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

print(*C)

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

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

print(*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())
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(i, end=" ")

print()

Solution (Python):
K, X = map(int, input().split())
start = (X - (K - 1))
end = (X + (K - 1))
upper = 1000000
lower = -1000000

if start < lower:
    start = lower

if end > upper:
    end = upper

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

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

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

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

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

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

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

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

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

Solution (Python):
K, X = map(int, input().split())
ans = list()
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,K):
    print(i+X,end=" ")

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

for i in range(X-K+1, X+K):
    ans.append(i)
print(' '.join(map(str, ans)))

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

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

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

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

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

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

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

Solution (Python):

 
import math
import itertools
import sys
import copy

 







K, X = map(int, input().split())
rmin = -1* (10 ** 6)
rmax = (10 ** 6)

lmin = max(rmin, X-K+1)
lmax = min(rmax, X+K-1)

ans = str(lmin)
for i in range(lmin+1, lmax+1) :
  ans += " " + str(i)

print (ans)

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

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

if __name__ == "__main__":
    main()

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




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

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

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

for i in range(l, r+1):
    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):
from sys import stdin

k, x = (int(x) for x in stdin.readline().rstrip().split())

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

print(*[i for i in l if -1e7 <= i <= 1e7])

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()
print(' '.join(map(str, l)))

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

l = []
for i in range(1,2*k):
    t = x-k+i
    l.append(str(t))
print(' '.join(l))

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):
import sys
import os


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

    K, X = list(map(int, sys.stdin.readline().split()))

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

    print(*ret)

if __name__ == '__main__':
    main()

Solution (Python):
import sys
import os


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

    K, X = list(map(int, sys.stdin.readline().split()))
    MAX = 1000000
    MIN = -1000000

    ret = [X]
    for i in range(1, K):
        if X + i <= MAX:
            ret.append(X+i)
        else:
            ret.append(X - K)

        if X - i >= MIN:
            ret.append(X-i)
        else:
            ret.append(X + K)

    print(*sorted(set(ret)))

if __name__ == '__main__':
    main()

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

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

print(*ans)

Solution (Python):
k,x=map(int,input().split())
mi=max(-1000000,x-k+1)
mx=min(1000000,x+k-1)
a=[]
for i in range(mi,mx+1):
    a.append(i)


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

ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)

def main():
    k, x = list(map(int,ipti().split()))
    minlim = x - (k-1)
    maxlim = x + (k-1)

    ans = [_ for _ in range(minlim, maxlim + 1)]
    print(*ans)

if __name__ == '__main__':
    main()

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

MIN=K-N+1
MAX=K+N-1

for i in range(MIN,MAX+1,1):
    print(i,end=" ")

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

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

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

arr = list(range(x-k+1,x+k))
for i in range(len(arr)-1):
    print(arr[i],end = ' ')
print(arr[-1])

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

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

Solution (Python):
k, x = map(int, input().split())
print(*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))
    
print(" ".join(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())
p = [x-k+1+i for i in range(2*k-1)]
q = [str(j) for j in p]
r = " ".join(q)
print(r)

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

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

print()

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

num = 2*K -1
ans =[]

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


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

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

[print(x, end=' ') for x in list(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= map(int,input().split())

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

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

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

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

ans = []

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

print(" ".join(ans))

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

print(*list(range(st,en)))

Solution (Python):
k,x=map(int,input().split())
ans_min=max(-1000000,x-k+1)
ans_max=min(1000000,x+k-1)
ans=""
for i in range(ans_min,ans_max+1):
    if i==ans_min:
        ans+=str(i)
    else:
        ans+=" "+str(i)
print(ans)

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

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

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

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

L = X-K+1
R = X+K-1

print(' '.join(map(str,range(L,R+1))))

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

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())
black = []

for i in range ((max(-1000000,X-K+1)),min(1000001,X+K)):
    black.append(str(i))

ans = " ".join(black)
print(ans)

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

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

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

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

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

res = []

for i in range(-(x-1)+y, x+y):
    res.append(i)

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

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

ans = list(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):
    print(i,end=" ")

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

for i in range(x-k+1, x+k):
    if i > 1000000 or i < -1000000:
        pass
    else:
        print(i)

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

Solution (Python):
import sys

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

def main():
    l = max(-10 ** 6, x - (k - 1))
    r = min(10 ** 6, x + (k - 1))
    return range(l, r + 1)

if __name__ == '__main__':
    ans = main()
    print(*ans, sep =' ')

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

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

m = max(-1000000, X - K + 1)
M = min(1000000, X + K - 1)

print(" ".join(str(i) for i in range(m, M + 1)))

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

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

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

ans = ''

for i in range(1, 2*k):
  ans += str(x-k+i) + ' '
  
print(ans.rstrip())

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

Solution (Python):
import math


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


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

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

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

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

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