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

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

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

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

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

Solution (Python):

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

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

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

(A,B) = (int(i) for i in input().split(" "))
print(" ".join([str(i) for i in range(B-A+1,B+A)]))

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

Solution (Python):
import sys

stdin = sys.stdin

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

k, x = na()
y = max(-1000000, x-k+1)
z = min(1000000, x+k-1)
for u in range(y, z+1):
    sys.stdout.write(str(u) + " ")

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

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 x in range(x-k+1,x+k)]
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, sep=' ')

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

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

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

print("")

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

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

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

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

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

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

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

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

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

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

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

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

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

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


from collections import deque
import itertools as ite
import sys
import math

sys.setrecursionlimit(1000000)

INF = 10 ** 18
MOD = 10 ** 9 + 7

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

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
from functools import reduce
import sys
import math
import bisect
import random
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return list(map(float, sys.stdin.readline().split()))
def LS():return sys.stdin.readline().split()
def SR(n): return [list(sys.stdin.readline())[:-1] for i in range(n)]
def IR(n): return [int(sys.stdin.readline()) for i in range(n)]
def LIR(n): return [list(map(int, sys.stdin.readline().split())) for i in range(n)]
def LSR(n): return [list(map(list, sys.stdin.readline().split())) for i in range(n)]
_gcd = lambda x, y: _gcd(y, x%y) if (x%y) else y
_lcm = lambda x, y: x*y // _gcd(x, y)
def gcd(*numbers):
    return reduce(_gcd, numbers)
def lcm(*numbers):
    return reduce(_lcm, numbers)
sys.setrecursionlimit(1000000)
INF = float('inf')
mod = 1000000007
dire4 = [(1,0), (0,1), (-1,0), (0,-1)]
dire8 = [(1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1)]

K, X = LI()

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)

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

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

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

Solution (Python):

import sys


def solve(K: int, X: int):
    left = X-K+1
    right = X+K-1
    print(" ".join(map(str, range(left, right+1))))
    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 = ' '.join(
    str(i)
    for i in range(X - K + 1, X + K)
)

print(ans)

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

Solution (Python):


import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline 

a,b = [int(i) for i in readline().split()]


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

print(*ans)

Solution (Python):
import bisect
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

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

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7

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

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

print(*range(l, r + 1))

Solution (Python):

import sys
INF = float("inf")


def solve(K: int, X: int):
    print(*range(X-K+1, X+K))

    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    K = int(next(tokens))  
    X = int(next(tokens))  
    solve(K, X)


if __name__ == '__main__':
    main()

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

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res

def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007


def A():
    a,b = LI()
    print(max(a+b,a-b,a*b))
    return


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


def C():

    return


def D():

    return


def E():

    return


def F():

    return


if __name__ == "__main__":
    B()

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

ans = []

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

print(*ans)

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

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

def getN():
    return int(input())
def getList():
    return list(map(int, input().split()))
import math

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

Solution (Python):



import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

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

Solution (Python):
K, X = [int(i) for i in 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(i)

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

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

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

for i in range(2*k-2):
    print(arr[i],end=" ")
print(arr[-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())
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):
L=lambda:list(map(int,input().split()))
k,x=L()
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)