Misha walked through the snowy forest and he was so fascinated by the trees to decide to draw his own tree!

Misha would like to construct a rooted tree with n vertices, indexed from 1 to n, where the root has index 1. Every other vertex has a parent p_i, and i is called a child of vertex p_i. Vertex u belongs to the subtree of vertex v iff v is reachable from u while iterating over the parents (u, p_{u}, p_{p_{u}}, ...). Clearly, v belongs to its own subtree, and the number of vertices in the subtree is called the size of the subtree. Misha is only interested in trees where every vertex belongs to the subtree of vertex 1.

Below there is a tree with 6 vertices. The subtree of vertex 2 contains vertices 2, 3, 4, 5. Hence the size of its subtree is 4. 

<image>

The branching coefficient of the tree is defined as the maximum number of children in any vertex. For example, for the tree above the branching coefficient equals 2. Your task is to construct a tree with n vertices such that the sum of the subtree sizes for all vertices equals s, and the branching coefficient is minimum possible.

Input

The only input line contains two integers n and s — the number of vertices in the tree and the desired sum of the subtree sizes (2 ≤ n ≤ 10^5; 1 ≤ s ≤ 10^{10}).

Output

If the required tree does not exist, output «No». Otherwise output «Yes» on the first line, and in the next one output integers p_2, p_3, ..., p_n, where p_i denotes the parent of vertex i.

Examples

Input


3 5


Output


Yes
1 1 


Input


4 42


Output


No


Input


6 15


Output


Yes
1 2 3 1 5 

Note

Below one can find one of the possible solutions for the first sample case. The sum of subtree sizes equals 3 + 1 + 1 = 5, and the branching coefficient equals 2.

<image>

Below one can find one of the possible solutions for the third sample case. The sum of subtree sizes equals 6 + 3 + 2 + 1 + 2 + 1 = 15, and the branching coefficient equals 2.

<image>

Difficulty: VERY_HARD
Tags: Graph algorithms

Graph traversal

Constructive algorithms

Sorting

Greedy algorithms

Tree algorithms
Skill types: Sorting

Greedy algorithms
Expected Time Complexity: O(NLOG(N))

Starter code:

Solutions:
def clc(mid):
	(sm, i, cp) = (0, 1, n)
	cur = 1
	while cp + 1 > cur:
		sm = sm + i * cur
		i += 1
		cp -= cur
		cur = cur * mid
	return sm + i * cp
(n, s) = map(int, input().split())
sm = n * (n + 1) // 2
dp = [0] * 100005
x = [0] * 100005
y = [0] * 100005
x[0] = 1
if s + 1 < 2 * n:
	print('No')
	exit()
if s > sm:
	print('No')
	exit()
else:
	print('Yes')
l = 0
r = n
while r - l > 1:
	mid = (r + l) // 2
	if clc(mid) > s:
		l = mid
	else:
		r = mid
i = 2
while i < n + 1:
	y[i] = i + r
	y[i] -= 2
	y[i] = y[i] // r
	x[i] = x[y[i]] + 1
	if dp[x[i]] == 0:
		dp[x[i]] = i
	i = i + 1
mx = x[n]
ip = n
s = s - clc(r)
while s != 0:
	if x[ip] != x[ip - 1]:
		ip = ip - 1
	if s > mx - x[ip]:
		y[ip] = dp[mx]
		mx = mx + 1
		s -= mx - x[ip]
		x[ip] = mx
		dp[mx] = ip
	else:
		y[ip] = dp[s + x[ip] - 1]
		s = 0
	ip = ip - 1
i = 2
while i < n + 1:
	print(y[i])
	i = i + 1


import math
EPS = 1e-06
hhh = None

def solve():
	(n, M) = [int(x) for x in input().split()]
	if out_of_solution_bounds(n, M):
		print('No')
		return
	b = find_optimal_b(n, M)
	heights = fast_find_optimal_height_distribution(n, M, b)
	parents = build_tree(n, b, heights)
	print('Yes')
	print(*parents[1:])

def out_of_solution_bounds(n, M):
	return M < 2 * n - 1 or n * (n + 1) // 2 < M

def find_optimal_b(n, M):
	begin = 1
	end = n
	while begin != end:
		mid = (begin + end) // 2
		if get_min_H_given_b(n, mid) <= M:
			end = mid
		else:
			begin = mid + 1
	b = end
	return b

def get_min_H_given_b(n, b):
	if b == 1:
		return n * (n + 1) // 2
	m = math.floor(math.log((b - 1) * n + 1) / math.log(b) + EPS)
	nl = round((b ** m - 1) / (b - 1))
	return (m * b ** (m + 1) - (m + 1) * b ** m + 1) // (b - 1) ** 2 + (m + 1) * (n - nl)

def fast_find_optimal_height_distribution(n, M, b):
	begin = 0
	end = n + 1
	H_fn = lambda L: L * (L + 1) // 2 + get_min_H_given_b(n - L, b) + (L > 0) * (n - L)
	while begin != end:
		mid = (begin + end) // 2
		if H_fn(mid) <= M:
			begin = mid + 1
		else:
			end = mid
	L = begin - 1
	if L == n:
		return [1 for _ in range(n)]
	unif_branch_h = uniform_height_distribution(n - L, b)
	if L == 0:
		h = unif_branch_h
	else:
		h = [int(i < L) for i in range(n)]
		for (i, x) in enumerate(unif_branch_h, 1):
			h[i] += x
	return locally_increase_H(h, M, b)

def uniform_height_distribution(n, b):
	h = [0 for _ in range(n)]
	h[0] = 1
	i = 0
	to_fill = n - 1
	while to_fill > 0:
		i += 1
		h[i] = min(b * h[i - 1], to_fill)
		to_fill -= h[i]
	return h

def locally_increase_H(h, M, b):
	i = 1
	while not (b * h[i - 1] >= h[i] - 1 and b * (h[i] - 1) >= h[i + 1] + 1):
		i += 1
	H = sum((i * x for (i, x) in enumerate(h, 1)))
	while H < M:
		if b * (h[i - 1] - 1) >= h[i] + 1:
			i -= 1
		else:
			while not b * (h[i] - 1) >= h[i + 1] + 1:
				i += 1
		h[i] -= 1
		h[i + 1] += 1
		H += 1
	return h

def build_tree(n, b, h):
	p = [None for _ in range(n)]
	p[0] = 1
	i = 1
	j = 0
	for k in range(1, n):
		if j == h[i]:
			i += 1
			j = 0
		p[k] = k - j - h[i - 1] + j // b + 1
		j += 1
	return p
solve()


import math

def f(n, k):
	if k == 1:
		return n * (n + 1) // 2
	a = math.floor(math.log(n, k))
	b = sum((k ** i for i in range(a + 1)))
	c = sum(((i + 1) * k ** i for i in range(a + 1)))
	if n < b:
		return c - (b - n) * (a + 1)
	else:
		return c + (n - b) * (a + 2)
(n, s) = map(int, input().split())
if s == n * (n + 1) // 2:
	print('Yes')
	a = [str(i + 1) for i in range(n - 1)]
	print(' '.join(a))
elif s > n * (n + 1) // 2:
	print('No')
elif s < 2 * n - 1:
	print('No')
else:
	mini = 1
	maxi = n - 1
	curr = 1
	while True:
		(a, b) = (f(n, curr), f(n, curr + 1))
		if b > s:
			mini = curr + 1
			curr = math.ceil((curr + maxi) / 2)
		elif a <= s:
			maxi = curr - 1
			curr = (curr + mini) // 2
		else:
			opt = curr + 1
			break
	depths = [0, 1] + [0] * (n - 1)
	ins = 1
	ind = 2
	while True:
		a = min(opt ** (ind - 1), n - ins)
		depths[ind] = a
		ind += 1
		ins += a
		if ins == n:
			break
	left = s - b
	far = ind - 1
	bulk = ind - 1
	if depths[bulk] == 1:
		bulk -= 1
	while left > 0:
		if far + 1 - bulk <= left:
			far += 1
			left -= far - bulk
			depths[far] += 1
			depths[bulk] -= 1
			if depths[bulk] == 1:
				bulk -= 1
		else:
			depths[bulk] -= 1
			depths[bulk + left] += 1
			left = 0
	verts = [None] * far
	sumi = 0
	for i in range(far):
		verts[i] = list(range(sumi + 1, sumi + 1 + depths[i + 1]))
		sumi += depths[i + 1]
	out = ''
	for i in range(1, far):
		for j in range(len(verts[i])):
			out += str(verts[i - 1][j // opt]) + ' '
	print('Yes')
	print(out)


def good(max_branch, s, n):
	nodes = 0
	can = 1
	lowest_s = 0
	depth = 1
	while nodes < n:
		added = min(n - nodes, can)
		lowest_s += added * depth
		nodes += added
		can *= max_branch
		depth += 1
	return lowest_s <= s
(n, s) = map(int, input().split())
if s < 2 * n - 1 or s * 2 > n * (n + 1):
	print('No')
else:
	(lo, hi) = (1, n)
	while lo < hi:
		mid = lo + hi >> 1
		if good(mid, s, n) == False:
			lo = mid + 1
		else:
			hi = mid
	max_branch = lo
	level_size = [1] * (n + 1)
	node_level = [i for i in range(n + 1)]
	cur_node = n
	cur_level = 1
	cur_sum = n * (n + 1) // 2
	can = 1
	while cur_sum > s:
		if level_size[cur_level] == can:
			cur_level += 1
			can *= max_branch
		if cur_sum - (cur_node - cur_level) < s:
			cur_level = cur_node - (cur_sum - s)
		node_level[cur_node] = cur_level
		level_size[cur_level] += 1
		cur_sum -= cur_node - cur_level
		cur_node -= 1
	node_list = [[] for _ in range(n + 1)]
	for i in range(1, n + 1):
		node_list[node_level[i]].append(i)
	pre = 0
	children = [0] * (n + 1)
	parent = [-1] * (n + 1)
	seen_nodes = 1
	for level in range(2, n + 1):
		idx = 0
		if not node_list[level - 1]:
			assert seen_nodes == n
			break
		cur_father = node_list[level - 1][0]
		for node in node_list[level]:
			if children[cur_father] == max_branch:
				idx += 1
				cur_father = node_list[level - 1][idx]
			children[cur_father] += 1
			parent[node] = cur_father
			seen_nodes += 1
	print('Yes')
	print(*parent[2:])


(n, s) = map(int, input().split())
if not 2 * n - 1 <= s <= n * (n + 1) // 2:
	print('No')
	exit()
print('Yes')

def ok(d):
	(dep, cur, sum, m) = (2, 1, 1, 0)
	while cur + m < n:
		m += cur
		cur = min(n - m, cur * d)
		sum += cur * dep
		dep += 1
	return sum <= s
(l, r) = (1, n)
while l < r:
	mid = (l + r) // 2
	if ok(mid):
		r = mid
	else:
		l = mid + 1
(a, me) = ([l - 1] * (n + 1), [_ for _ in range(n + 1)])
(sum, low) = (n * (n + 1) // 2, 2)
while n > low and sum > s:
	dest = min(sum - s, n - low)
	sum -= dest
	me[n] -= dest
	a[me[n] + 1] += l
	a[me[n]] -= 1
	if not a[low]:
		low += 1
	n -= 1
(me, l, dg) = (sorted(me[1:]), 0, 0)
for i in me[1:]:
	while me[l] < i - 1 or dg == r:
		dg = 0
		l += 1
	print(l + 1, end=' ')
	dg += 1


import sys
(n, s) = map(int, input().split())
if 2 * s > n * (n + 1) or s < 2 * n - 1:
	print('NO')
	sys.exit()
for i in range(n, -1, -1):
	if i == 0:
		branch = 1
		break
	tmp = 0
	tmpn = n
	j = 1
	while tmpn - i ** (j - 1) >= 0:
		tmp += j * i ** (j - 1)
		tmpn -= i ** (j - 1)
		j += 1
	tmp += j * tmpn
	if tmp > s:
		branch = i + 1
		break
tmp = 0
tmpn = n
j = 1
i = branch
dic = {}
while tmpn - i ** (j - 1) >= 0:
	tmp += j * i ** (j - 1)
	dic[j] = i ** (j - 1)
	tmpn -= i ** (j - 1)
	j += 1
tmp += j * tmpn
dic[j] = tmpn
maxi = j
while tmp < s:
	for j in range(maxi, -1, -1):
		while dic[j] > 1:
			if s - tmp + j <= maxi:
				dic[j] -= 1
				dic[s - tmp + j] += 1
				tmp = s
			else:
				dic[j] -= 1
				dic[maxi + 1] = 1
				tmp += maxi + 1 - j
				maxi += 1
			if tmp == s:
				break
		if tmp == s:
			break
b = []
for i in dic:
	for j in range(dic[i]):
		b.append(i)
b.sort()
print('YES')
children = [0] * n
ans = [-1] * n
curr = 0
pointer = 0
for i in range(1, n):
	while b[i] > b[curr] + 1:
		curr += 1
	ans[i] = curr
	children[curr] += 1
	if children[curr] == branch:
		curr += 1
finans = []
for i in range(1, n):
	finans.append(ans[i] + 1)
print(' '.join(map(str, finans)))