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

import sys






"""Template"""


class IP:
    """
    入力を取得するクラス
    """

    def __init__(self):
        self.input = sys.stdin.readline

    def I(self):
        """
        1文字の取得に使います
        :return: int
        """
        return int(self.input())

    def S(self):
        """
        1文字の取得(str
        :return: str
        """
        return self.input()

    def IL(self):
        """
        1行を空白で区切りリストにします(int
        :return: リスト
        """
        return list(map(int, self.input().split()))

    def SL(self):
        """
        1行の文字列を空白区切りでリストにします
        :return: リスト
        """
        return list(map(str, self.input().split()))

    def ILS(self, n):
        """
        1列丸々取得します(int
        :param n: 行数
        :return: リスト
        """
        return [int(self.input()) for _ in range(n)]

    def SLS(self, n):
        """
        1列丸々取得します（str
        :param n: 行数
        :return: リスト
        """
        return [self.input() for _ in range(n)]

    def SILS(self, n):
        """
        Some Int LineS
        横に複数、縦にも複数
        :param n: 行数
        :return: list
        """
        return [self.IL() for _ in range(n)]

    def SSLS(self, n):
        """
        Some String LineS
        :param n: 行数
        :return: list
        """
        return [self.SL() for _ in range(n)]


class Idea:
    def __init__(self):
        pass

    def HF(self, p):
        """
        Half enumeration
        半分全列挙です
        pの要素の和の組み合わせを作ります。
        ソート、重複削除行います
        :param p: list : 元となるリスト
        :return: list : 組み合わせられた和のリスト
        """
        return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))

    def Bfs2(self, a):
        """
        bit_full_search2
        bit全探索の改良版
        全探索させたら2進数のリストと10進数のリストを返す
        :return: list２つ : １個目 2進数(16桁)  2個目 10進数
        """
        
        
        
        value = []
        for i in range(1 << len(a)):
            output = []

            for j in range(len(a)):
                if self.bit_o(i, j):
                    """右からj+1番目のiが1かどうか判定"""
                    
                    output.append(a[j])
            value.append([format(i, 'b').zfill(16), sum(output)])

        value.sort(key=lambda x: x[1])
        bin = [value[k][0] for k in range(len(value))]
        val = [value[k][1] for k in range(len(value))]
        return bin, val

    def S(self, s, r=0, m=-1):
        """
        ソート関係行います。色々な設定あります。
        :param s: 元となるリスト
        :param r: reversするかどうか 0=False 1=True
        :param m: （2次元配列）何番目のインデックスのソートなのか
        :return: None
        """
        r = bool(r)
        if m == -1:
            s.sort(reverse=r)
        else:
            s.sort(reverse=r, key=lambda x: x[m])

    def bit_n(self, a, b):
        """
        bit探索で使います。0以上のときにTrue出します
        自然数だからn
        :param a: int
        :param b: int
        :return: bool
        """
        return bool((a >> b & 1) > 0)

    def bit_o(self, a, b):
        """
        bit探索で使います。1のときにTrue出すよ
        oneで1
        :param a: int
        :param b: int
        :return: bool
        """
        return bool(((a >> b) & 1) == 1)

    def ceil(self, x, y):
        """
        Round up
        小数点切り上げ割り算
        :param x: int
        :param y: int
        :return: int
        """
        return -(-x // y)

    def ave(self, a):
        """
        平均を求めます
        :param a: list
        :return: int
        """
        return sum(a) / len(a)

    def gcd(self, x, y):
        if y == 0:
            return x
        else:
            return self.gcd(y, x % y)

    def lcm(self, x, y):
        return (x * y) // self.gcd(x, y)


"""ここからメインコード"""


def main():
    
    r, e = range, enumerate
    ip = IP()
    id = Idea()

    """この下から書いてね"""
    k, x = ip.IL()
    memo = []
    for i in range(x-k+1, x+k):
        memo.append(i)
    print(*memo)

main()

Solution (Python):
import numpy as np
K, X = list(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())
a=x-k+1
b=x+k-1
a=max(a,-1000000)
b=min(b,1000000)
c=[k for k in range(a,b+1)]
for i in c:
  print('%d '%i),

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

Solution (Python):

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

answer = []
for i in (range(x-k+1,x+k)):
    
    if x+i >= -10000 and i <= 10000:
        
        answer.append(i)

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

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

idx = 1
lists = [0]
for _ in range(2 * a - 1):
	lists.append(b - a + idx) 
	idx += 1
del lists[0]
maped_num = map(str, lists) 
print(' '.join(maped_num))

Solution (Python):


i = list(map(int, input().split()))

k = i[0]
x = i[1]

num_list = list(range(x-k+1, x+k, 1))
new_list = [e for e in num_list if -1000000 <= e <= 1000000]
lite_new_list = map(str, new_list)

print(' '.join(lite_new_list))

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

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

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

li.sort()
for l in li:
    print(l, end=' ')

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

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

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

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

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

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

Solution (Python):
K, X = map(int, input().split())
start = -1000000
end = 1000000
min_ = start if X - K + 1 < start else X - K + 1
max_ = end if X + K - 1 > end else X + K - 1
print(" ".join(map(str, range(min_, max_ + 1))))

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(*[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):
    if ans == "":
        ans = str(i)
    else:
        ans = ans + " " + str(i)
print(ans)

Solution (Python):
k,x=map(int, input().split())
a = list()
 
b = x+k-1
c = x-k+1
 
for i in range(c,b+1):
  if  -1000000 <= i and i <= 1000000:
    a.append(i)
  
print(*a)

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

Solution (Python):
k,x = map(int,input().split())
ls = []
for i in range(x-k+1,x+k):
    if i>=-1000000 and i<=1000000:
        print(i,end=" ")
print()

Solution (Python):
li = list(map(int,input().split()))
lists = []
for i in range(li[0]*2-1):
    lists.append(li[1]-li[0]+i+1)
moji = ""
for s in range(len(lists)):
    moji += " "+str(lists[s])
print(moji)

Solution (Python):
K , X = (int(x) for x in input().split())
st = X - (K - 1)
sp = X + (K - 1)
A = []

for i in range(st , (sp + 1)):
    print(i)

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

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

print(' '.join(str(i) for i in num))

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**9)
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

k,x = na()
a = []

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

print(' '.join([str(s) for s in 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 = (int(x) for x in input().split())

ans = [x]

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

ans.sort()

for n in range(len(ans)):
  print(ans[n], end=" ")

Solution (Python):
import numpy as np
n1, n2=input().split(' ')
n1 = int(n1)
n2 = int(n2)
n1_1 =  n1 - 1
result = ''
for  i in range(n2 - n1_1, n2 + n1_1 + 1 ,1):
    result += str(i) + ' '
print(result)

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

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

import sys

X_min = X - (K-1)
X_max = X + (K-1)

if (X_max > 1000000):
    X_max = 1000000
if (X_min < -1000000):
    X_min = -1000000

for i in range(X_max - X_min + 1):
    sys.stdout.write(str(X_min) + " ")
    
    X_min += 1

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

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

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

if __name__ == "__main__":
    main()

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

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

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

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

K = List[0]
X = List[1]
pp = []

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

print(*pp)

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

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

Solution (Python):
lis = input().split(" ")

K = int(lis[0])
X = int(lis[1])

mini = X - (K - 1)
maxm = X + (K - 1)
list_a = []
for i in range(0, (K - 1) * 2 + 1):
    list_a.append(str((X - (K - 1)) + i))

print(" ".join(list_a))

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

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

c=list(range(b-a+1,b+a))

d = [str(i) for i in c]

print(" ".join(d))

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

a = (X-K)+1
b = (X+K)-1


p = [str(i) for i in range(a,b+1)]
q = " ".join(p)
print(q)

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

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

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

l = list(range(x-k+1,x+k))

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

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

for i in range(2*k-1):
    list1.append(hidari)
    hidari=hidari+1
    
print(' '.join(map(str, list1)))

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.append(i)
  if(i == max_x):
  	print(i)
  else:
    print(i,end=" ")

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

tmp=K
while tmp>1:
	print(X-tmp+1, end=" ")
	tmp -= 1
print(X, end=" ")
tmp=1
while tmp<K:
	print(X+tmp, end=" ")
	tmp += 1

Solution (Python):



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

    mx = x + k - 1
    mi = x - k + 1

    l = [str(i) for i in range(mi, mx + 1)]
    print(" ".join(l))

main()

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

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

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

print(" ".join(ls))

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

z = str(x-k+1)

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

print(z)

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

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

p = []
l = []
for  i in range(k):
	l.append(x-i)


for i in range(k):
	for j in range(k):
		p.append(l[j]+i)
q = list(set(p))
q.sort()
print(*q)

Solution (Python):


import os
import sys

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

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

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

ans = []
for i in range(X-K+1, X):
	ans.append(i)
for i in range(X, X+K):
  	ans.append(i)
sorted(ans)
for e in ans:
  print(e, " ", end="")

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

print(" ".join(lst))

Solution (Python):
import numpy as np
def acinput():
    return list(map(int,input().split(" ")))

K,X=acinput()

print(" ".join(map(lambda x:str(x),np.arange(X-K+1,X+K))))

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

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

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

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

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

a = x-k+1
z = x+k-1

list = []
for i in range(a, z+1):
    list.append(str(i))

ans = ' '.join(list)
print(ans)

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

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

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

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

min = x - (k - 1)
max = x + (k - 1)

if min < -100000: min = -1000000

if max > 1000000: max = 1000000

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

Solution (Python):
import sys

n = list(map(int, input().split()))
k = n[0]
x = n[1]

start = min([(x - k + 1), -100])

if k is 1:
  print(x)
  quit()


i = 0
while True:
  if x - k + 1 + i == x:
    break
  print(x - k + 1 + i, end = " ")
  i += 1

j = 0
while True:
  print(x+j, end = " ")
  j += 1
  if x+j == x + k - 1:
    print(x + k - 1)
    quit()

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

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

stone = [str(i) for i in range(-1000000, 1000001, 1)]
idx = stone.index(str(x))

print(" ".join(stone[idx - k + 1: idx + k]))

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

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

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

Solution (Python):
k, x = [int(i) for i in input().split()]
minimum = 1000000 - k + 1 if x + k - 1 > 1000000 else max(x - k + 1, -1000000)
maximum = -1000000 + k - 1 if x - k - 1 < -1000000 else min(x + k - 1, 1000000)
print(*range(minimum, maximum + 1))

Solution (Python):
a,b=(int(x) for x in input().split())

l=list(range(a))

for i in reversed(l):
    print(b-i,end=' ')

l.pop(0)

for i in l:
    print(b+i,end=' ')

print()

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

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

Solution (Python):
p, q  = map(int, input().split())
l = []

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

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

L=[str(a) for a in num]
L=" ".join(L)
print(L)

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

left = X-(K-1)
right = X+(K-1)
ans = list(map(str,range(left,right+1)))
print(' '.join(ans))

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

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

Solution (Python):
def resolve():
    k,x = map(int,input().split())
    if k == 1:
        print(x+k-1)
    else:
        for i in reversed(range(k)):
            print('{} '.format(x-i),end='')
        for i in range(1,k-1):
            print('{} '.format(x+i),end='')
        print(x+k-1)
resolve()

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

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

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=(int(x) for x in input().split())
min=X-K+1
max=X+K-1

if min<=0:
  total=max-min+1
  for g in range(total):
    print(min+g,end=" ")
elif min>0:
  total=max-min+1
  for g in range(total):
    print(min+g,end=" ")

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

min_x = x - (k - 1)
max_x = x + k

ans_list = []

for i in range(min_x, max_x):
    ans_list.append(i)

ans_str = [str(a) for a in ans_list]
ans = " ".join(ans_str)
print(ans)

Solution (Python):
a = list(map(int, input().split()))
sta = a[1]
num = a[0] - 1
j = sta - num
h = sta + num
ans = ""
for i in range(j,h+1,1):
    ans = ans + " " + str(i)

print(ans)

Solution (Python):
a,b = list(map(int,input().split()))
aa= a*2-1
start = b-(a-1)
list=[]
for i in range (aa):
  list.append(start)
  start +=1
print(' '.join(map(str, list)))

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

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

Solution (Python):

import numpy as np

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

mi = x-k+1
mi = max(-1000000, mi)

ma = x+k
ma = min(1000000, ma)

list_1 = list(range(mi, ma))
print(" ".join(map(str,list_1)))

Solution (Python):
k, x = map(int, input("").split())
a = max([x-k+1, -1000000])
b = min([x+k-1, 1000000])
m = range(a, b)
m2 = list(range(a, b))
print(" ".join(map(str, list(range(a, b + 1)))))

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

ans=[]

lx=max(-1000000,x-k+1)
rx=min(1000000,x+k-1)

if k ==1:
    print(x)
else:
    for i in range(lx,x):
        ans.append(str(i))
    ans.append(str(x))
    for i in range(x+1,rx+1):
        ans.append(str(i))
    print(" ".join(ans))

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

n = int(a[0])
m = int(a[1])

a1 = m - (n - 1)
a2 = m + (n)

max = 1000000
min = -1000000

if a1 < min:
    a1 = min
if a2 > max:
    a2 = max

l = map(str, range(a1, a2))
print(' '.join(l))

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




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

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

L.append(X)

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

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

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

length = k * 2 - 1

if x - k < -1000000:
	firstNo = -1000000
elif x + k > 1000000:
	firstNo = 1000000 - length + 1
else:
	firstNo = x - k + 1
for i in range(length):
	print(str(firstNo + i) + " ", end = "")

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

Solution (Python):

"""
Created on Sat Aug 10 21:07:21 2019

@author: doppe
"""

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


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

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

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

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

print(" ".join(list(map(str, [i for i in range(l[1]-l[0]+1, l[1]+l[0])]))))

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

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

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

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

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

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

print(' '.join(ans))

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

saisyou = 0
saidai = 0

saisyou = X - K + 1
saidai = X + K - 1

for i in range(saisyou,saidai+1):
  print(i,end=" ")

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

re = list(map(lambda a: str(a+y-x+1), range(2*x-1)))

print(" ".join(re))

Solution (Python):
import sys
sys.setrecursionlimit(2**31-1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
dbg = lambda *something : print(*something) if DEBUG is True else 0
DEBUG = True

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





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

Solution (Python):
import sys
k, x= map(int, input().split())
if x-k+1 < -1000000:
	s = -1000000
else:
	s = x-k+1
if x+k-1 >1000000:
	f = 1000000
else:
	f = x+k-1
for i in range(s,f):
	sys.stdout.write(str(i))
	sys.stdout.write(" ")
sys.stdout.write(str(f))

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

Solution (Python):
inlist = input().split()
a = int(inlist[0])
b = int(inlist[1])

ans = []
for i in range(0,a):
	if (i==0):
		ans.append(b)
	else:
		if not (a-i < -1000000):
			ans.append(b-i)
		if not (a+i > 1000000):
			ans.append(b+i)
ans.sort()
string= ''
for i,a in enumerate(ans):
	string += str(a)
	if not (i==len(ans)-1):
		string += ' '

print(string)

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

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    k, x = [int(i) for i in input().split()]
    num = k - 1
    min_ = max(x - num, - 1000000)
    max_ = min(x + num + 1, 1000001)
    print(" ".join([str(i) for i in range(min_, max_)]))

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) if -1000000 <= i <= 1000000]))

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

l = x - k + 1
r = x + k - 1

mylist = []

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

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

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

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


Xmin = X-K+1
Xmax = X+K-1

if Xmin < -1000000:
  Xmin = -1000000

if Xmax>1000000:
  Xmax=1000000
  
Xrange = list(range(Xmin,Xmax+1,1))

print(" ".join( repr(e) for e in Xrange ) )

Solution (Python):
import numpy as np

K,X=input().split()

K=int(K)
X=int(X)

array=np.arange(X-K+1,X+K,1)

print(array[0],end='')

for n in range(len(array)-1):
    print(' {}'.format(array[n+1]),end='')

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

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

print(' '.join(li))

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

Solution (Python):
l = raw_input().split() 
K=int(l[0])
X=int(l[1])

min=0
max=0

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

for i in range(min,max+1):
	print(i)

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

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

s = max(-1000000, x-k+1)
e = min(x+k-1, 1000000)
for i in range(s,e+1):
    if i == e:
        sys.stdout.write("{}".format(i))
    else:
        sys.stdout.write("{} ".format(i))

Solution (Python):
i= input().split()
j=int(i[0])
k=int(i[1])
l=k-j+1
m=[]
for n in range(j*2-1):
	m.append(l+n)

print(*m)

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

lowx = x-k+1
lowy = x+k
ans_l = []

for i in range(lowx, lowy):
    ans_l.append(str(i))

print(' '.join(ans_l))

Solution (Python):
from sys import stdin


def main():

    K, X = [int(x) for x in stdin.readline().rstrip().split()]

    a = X-(K-1)
    b = X+(K-1)

    if a < -1000000:
        a = -1000000

    if b > 1000000:
        b = 1000000

    
    c = list(range(a, b+1))

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


if __name__ == "__main__":
    main()

Solution (Python):
k,x = map(int,input().split())
big = x+k-1
small = x-k+1
if small < -1000000:
  for i in range in(-1000000,big+1):
    print(i,"",end='')
elif big > 1000000:
  for i in range in (small,1000000+1):
    print(i,"",end='')
if small >= -1000000 and big <= 1000000:
  for i in range(small,big+1):
    print(i,"",end='')

Solution (Python):


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


x = list()
x.append(k)

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

x.sort()

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

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

if K == 1:
    print(X)
else:
    print(X-(K-1), end="")
    for i in range(X-(K-1)+1, (X+K)):
        print(' %d' % i, end="")

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

list=[]

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

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

start = X - K +1
end = X + K -1

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

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

count = (k - 1) * 2 + 1
ans_arr = []

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

for i in range(x, x + k):
    ans_arr.append(str(i))

print(' '.join(ans_arr))

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

right= (1000000)*(-1)
left=1000000
al=[]
for i in range(x-(k-1),x+1):
  if i<right or left<i:
    continue
  for j in range(k):
    t=i+j
    if (i+j in al)!=True and (t<right)==False and (left <t)==False:
      al.append(i+j)
  

al.sort()
print(*al)

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

Solution (Python):
k, n = (int(x) for x in input().split())

result = []
dif = n - k + 1
r = (2 * (k - 1)) + 1
for i in range(r):
    result.append(str(dif + i))

print(" ".join(result))

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

Solution (Python):

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

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

KK = K -1
KKK = K*2-1

li = []

for i in range(KKK):
    li.append(X - KK + i)

for j in li:
    print(j, end=' ')

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

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

Solution (Python):
k, x = map(int,input().split(' '))
if x-k+1 <= -100000:
    for i in range(0,k):
        print(-100000+i,sep=' ',end=' ')
elif x+k-1 >= 100000:
    for i in range(0,k):
        print(100000-i,sep=' ',end=' ')
else:
    for i in range(k,1,-1):
        print(x-i+1,sep=' ',end=' ')
    for i in range(0,k):
        print(x+i,sep=' ',end=' ')

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

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

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

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

length = K - 1

start = X - length
end = X + length

for i in range(start , end + 1):
    print(i , " " , end = '')
print()

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

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

count = i[0] + i[0] - 1
min = i[1] - i[0] + 1

for x in range(count):
    print(min+x)

Solution (Python):



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






min = X - (K - 1)
max = X + (K - 1)
len = max - min +1

result = ''
for i in range(min,max + 1):
    result = result + str(i) + ' '

print(result)

Solution (Python):
tmp = input().split(' ')

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

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

resulttmp = ''

if k == 1:
    resulttmp = str(x)
else:
    for i in range(b,c+1):
        resulttmp += str(i) + ' '

print(resulttmp)

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

for i in range(1,K):
    if X+i <= 1000000:
        ans.append(X+i)
    if X-i >= -1000000:
        ans.append(X-i)

ans = sorted(ans)
print(*ans)