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

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

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


min_x = max(X-K+1,-1000000)

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

text = ""
for i in range(min_x,max_x+1):
    text += "{} ".format(i)

print(text[:-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())




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





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

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

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

Solution (Python):

k,x = map(int, input().split())
MIN = max(x-k+1, -1000000)
MAX = min(1000000, k+x-1)

ans = [x for x in range(MIN,MAX+1)]

print(*ans)

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

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

print(*ans)

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

minb = X - K + 1
maxb = X + K - 1

for i in range(minb, maxb + 1):
	print(i, end="")
	print(" ", end="")
print("\n")

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

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

print(' '.join(l))

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

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

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

print(" ".join(ans))

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

Solution (Python):
import sys

def main():
    input = sys.stdin.readline
    K, X = map(int, input().split())
    ans = []
    start = X - K + 1
    end = X + K
    for i in range(start, end):
        ans.append(i)

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


if __name__ == '__main__':
    print(main())

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

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

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

min_num = x - k + 1
max_num = x + k
array = []

for i in range(min_num, max_num):
    array.append(i)

print(*array, sep=' ')

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

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

Solution (Python):
K,X = list(map(lambda x: int(x),input().split()))
l = max(-10**6,X-K+1)
r = min(10**6,X+K-1)
lst = [str(i) for i in range(l,r+1)]
print(" ".join(lst))

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

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

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

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

K, X = MAP()

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)

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

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

Solution (Python):

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

start = max(-10**6,X-K+1)
end = min(10**6,X+K-1)
ans = [i for i in range(start,end+1)]
print(' '.join(map(str,ans)))

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

p = X - K + 1
q = X + K - 1

for i in range(p, q+1):
    print(i, end=" ")

Solution (Python):
def int_multiple():
    return  [int(c) for c in input().split()]

def int_single():
    return int(input())

def str_multiple():
    return [c for c in input().split()]

def str_single():
    return input()



k, x = int_multiple()

s = ""

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

print(s[:-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 = (int(i) for i in input().split())

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

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

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

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

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

x_min = max(X - K + 1, -1000000)
x_max = min(X + K - 1, 100000)

L = map(str, list(range(x_min, x_max + 1)))
print(' '.join(L))

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

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

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

K, X = [int(item) for item in input().split()]
out = [str(item) for item in list(
    range(max(X - K + 1, -1000000), min(X + K - 1, 1000000) + 1))]
print(" ".join(out))

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

print(" ".join([str(_) for _ in range(max(-1000000,x-k+1),min(1000001,x+k))]))

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

Solution (Python):
import sys

def input():
    return sys.stdin.readline().rstrip()

if __name__ == "__main__":
    k, x = map(int, input().split())

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

    ans = [i for i in range(left, right+1)]

    print(*ans)

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

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

Solution (Python):
k,x=map(int,input().split())
if x-k<-1000000:
	a=-1000000
else:
	a=x-k+1
if x+k>1000000:
	b=1000000
else:
	b=x+k-1
aa=[]
for i in range(a,b+1):
	aa.append(i)
print(*aa)

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

Solution (Python):


def readInts():
  return [int(s) for s in input().split(" ")]

def main():
  K, X = readInts()
  left = X - K + 1
  right = X + K - 1
  ans = " ".join([str(x) for x in range(left, right + 1)])
  print(ans)

if __name__ == "__main__":
  main()

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

print(*range(x - k + 1, x + k), sep=" ")

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline






















def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

def main():
	K,X = inputMap()

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

	print(*ans)



if __name__ == "__main__":
	main()

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

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

for i in range(L,R):
    print(i,end=' ')

print(R)

Solution (Python):
k, x = map(int, input().split())
i = max(x - k + 1, -1000000)
c = 0
while (c < 2 * k - 1):
    print(i, end=' ')
    c += 1
    i += 1

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

print(*ans)

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

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

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

ans = ""

for n in range(X - K + 1, X + K):
  ans += " {}".format(n)
  
print(ans[1:])

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[:-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):
import math
import copy


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









kotae = [0 for i in range(2*k-1)]

for i in range(0,2*k-1) :
    kotae[i] = x-k+1+i

print(*kotae)

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

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

print(" ".join(li))

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

T = X - K + 1

ans = []

for i in range(K*2 - 1):
    ans.append(T)
    T += 1

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

Solution (Python):
import sys
from operator import itemgetter
import math
stdin = sys.stdin

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

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

Solution (Python):

k, x = map(int, input().split())
lst = list(range(x-(k-1), x+k))
print(' '.join(map(str, lst)))

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

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

Solution (Python):

from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip


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

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




BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

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

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

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

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


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


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


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")



if __name__ == "__main__":
    main()

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

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

Min = max(X-K+1,-1000000)
Max = min(X+K-1,1000000)

Ans = [x for x in range(Min,Max+1)]

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

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

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

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

N = len(ans)
for i in range(N):
  print(ans[i], end = "")
  if i == N - 1:
    print()
  else:
    print(" ", end = "")

Solution (Python):


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

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

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

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

print(*ans)

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

Solution (Python):
import math
import copy
from operator import mul
from functools import reduce
from collections import defaultdict
from collections import Counter
from collections import deque

from itertools import product

from itertools import permutations

from itertools import combinations

from itertools import accumulate
from bisect import bisect_left, bisect_right

import re







def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
 
def i_inpl(): return int(input())
def l_inpl(): return list(map(int, input().split()))
def line_inpl(x): return [i_inpl() for _ in range(x)]

INF = int(1e30)
MOD = int(1e9)+7 


def create_grid(H, W, value = 0):
    return [[ value for _ in range(W)] for _ in range(H)]



def main():
    K, X = l_inpl()
    ans = []
    print(" ".join([ str(i) for i in list(range(X-K+1, X+K))]))
    
if __name__ == "__main__":
    main()

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

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

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

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())
st = max(-1000000,x-k+1)
gl = min(1000000,x+k-1)
ans = []
for i in range(st,gl+1):
  ans.append(i)
print(' '.join(list(map(str,ans))))

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

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

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

ans = []
for k in range(max(X-K+1, -1000000), min(X+K, 1000000)):
    ans.append(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=[int(i) for i in input().split()]
a,b=max(x-k+1,-1000000),min(x+k-1,1000000)
c=list(range(a,b+1))
print(" ".join([str(i) for i in c]))

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

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

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

print(*ans)

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

Solution (Python):

import numpy as np
import math
import copy
import re
import sys


inf = float("inf")
prime = 1

def check_print(check_flag, text, end="\n"):
  if check_flag:
    print(text, end=end)

def c2i(x):
    if str.isdecimal(x):
        return int(x)
    else:
        return x

def cout(*args):
  arglist = []
  for arg in args:
    if hasattr(arg, "__iter__"):
      arglist.extend(arg)
    else:
      arglist.append(arg)
      
  arglist = list(map(str, arglist))
  print(" ".join(arglist))
  
def count2(num):
  count=0
  while num%2==0:
    num/=2
    count+=1
  return count

def ketasum(num):
  nums = [int(s) for s in str(num)]
  return sum(nums)


def gcd(a, b): 
  while b:
    a, b = b, a % b
  return a

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

def gcd3(lis): 
  ans = lis[0]
  for li in lis:
    ans = gcd(ans,li)

def lcm3(lis): 
  ans = lis[0]
  for li in lis:
    ans = lcm(ans,li)

def divisor(n): 
  i = 1
  table = []
  while i * i <= n:
    if n%i == 0:
      table.append(i)
      table.append(n//i)
    i += 1
  table = list(set(table))
  return table

def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(i)
    i += 1
  if n > 1:
    table.append(n)
  return table

def is_prime(n):
  for i in range(2, n + 1):
    if i * i > n:
      break
    if n % i == 0:
      return False
  return n != 1


"""
n = int(input())


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

d=[]
for i in range(n):
  d[i]=int(input())


a = [list(map(int, input().split())) for i in range(n)]

s = input()
ss =  [int(si) for si in s]
"""


"""
a = sorted(a)
a = sorted(a, reverse=True)

"""


"""
pattern = ""
result = re.search(pattern, s)

result = re.fullmatch(pattern, s)

result = re.finditer(pattern, s)
for res in result:
    print res.group()   
    print res.start()   
    print res.end()     
    print res.span()    
"""


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

cout(ret)

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

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

if K ==1:
  print(X)
else:
  for i in range(X-K+1,K+X):
    print(i)

Solution (Python):

def main():
    K, X = [int(f) for f in input().split()]
    
    for row in range(X-K+1, X+K):
        print(row, end=" ")
    print("")

if __name__ == "__main__":
    main()

Solution (Python):

import sys


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

Solution (Python):









import sys
inf = float("inf")





mod,MOD=1000000007,998244353










def get_array(): return list(map(int , sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()

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

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

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline






















def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

def main():
	K,X = inputMap()

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

	print(*ans)



if __name__ == "__main__":
	main()

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

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

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

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

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

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

Solution (Python):
K,X = list(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())

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

Solution (Python):

import sys, math, fractions, itertools


def solve(K: int, X: int):
    A = []
    for i in range(2*K-1):
        A.append(str(X-K+i+1))
    print(' '.join(A))
    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 = map(int, input().split())
ans = []
for i in range(max(-1000000, X - K + 1), min(1000000, X + K - 1) + 1):
    ans.append(i)
    
print(" ".join(list(map(str, ans))))

Solution (Python):




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

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

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

arr = list(range(x-k+1,x+k))
s=''
for i in arr:
  s+=str(i)+' '
print(s)

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

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

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

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

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

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

hidari = x - k + 1

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

print(" ".join(str(i) for i in ans))

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

A = max(-1000000,X-(K-1))
B = min(1000000,X+(K-1))

print(" ".join([str(x) for x in range(A,B+1)]))

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

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

  return ' '.join([str(x) for x in ans])


print(main())

Solution (Python):
from heapq import heappush, heappop
import re
from collections import deque
import sys
import math
input = sys.stdin.readline


def int_raw():
    return int(input())


def ss_raw():
    return input().split()


def ints_raw():
    return tuple(map(int, ss_raw()))


DIV = 10**9+7


def mod_inv_prime(a, mod=DIV):
    return pow(a, mod-2, mod)


def mod_inv(a, b):
    r = a
    w = b
    u = 1
    v = 0
    while w != 0:
        t = r//w
        r -= t*w
        r, w = w, r
        u -= t*v
        u, v = v, u
    return (u % b+b) % b


def ncr(n, r, mod=DIV):
	r = min(r, n-r)
	ret = 1
	for i in range(1, r+1):
		ret = ret * (n-i+1) % mod
		ret = ret * mod_inv(i, mod) % mod
	return ret


def main():
    K,X = ints_raw()
    return " ".join([str(i) for i in range(X-K+1,X+K)])
    
print(main())

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

Solution (Python):
import sys
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

K,X = IL()

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

debug = True


def dprint(*objects):
    if debug == True:
        print(*objects)

def solve():
    k, x = LI()

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

solve()

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa == x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))

k,x = l()

p = [x + i for i in range(2*k - 1)]

for i in range(len(p)):
    p[i] -= k - 1 

print(jo(p))

Solution (Python):

import sys


def solve(K: int, X: int):

    print(" ".join(map(str,[i for i in range(X-K+1,X+K) if abs(i) <= 1000000])))
    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):
def main():
    k, x = map(int, input().split())
    print(*[i for i in range(x-k+1, x+k)])


main()

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

print(' '.join([str(t) for t in range(max(x - k + 1, -1000000), min(x + k, 1000001))]))

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

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

stone = [0 for i in range(-1000000, 1000001)]
for i in range(X-K+1, X+K):
    if i >= -1000000 and i <= 1000000:
        stone[i] = 1

for i in range(-1000000, 1000001):
    if stone[i] == 1:
        print(i)

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

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

Solution (Python):
k, x = list(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())
K-=1
print(*list(range(max(-1000000,X-K),min(1000000,X+K)+1)))

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

Solution (Python):
from collections import Counter,defaultdict




a,b=map(int,raw_input().split())
c=b-a+1
d=a+b
for i in range(c,d):
    print i,

Solution (Python):
import numpy as np
import math
import sys
sys.setrecursionlimit(10000000)

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


if __name__ == '__main__':
    main()

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