There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.

Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.

There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).

In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.

Input

The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.

The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.

Output

In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).

In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.

If there are multiple answers, print any of them.

Examples

Input


2 6
1 5


Output


8
-1 2 6 4 0 3 


Input


3 5
0 3 1


Output


7
5 -2 4 -1 2 
import os, sys, math
import collections

if os.path.exists('testing'):
	name = os.path.basename(__file__)
	if name.endswith('.py'):
		name = name[:-3]
	src = open(name + '.txt', encoding='utf8')
	input = src.readline

def solve():
	global xs
	xs = list(sorted(xs))
	min_region_index = xs[0] - 1
	max_region_index = xs[-1] + 1
	border_index = 2 * 10 ** 9
	
	prev = None
	regions = []
	for x in xs:
		if prev is not None and x - prev > 1:
			regions.append((prev + 1, x - 1))
		prev = x
	
	ys = []
	min_dist = 0
	current_dist = 1
	while len(ys) < m:
		region_index = 0
		if len(ys) < m and -border_index <= min_region_index:
			ys.append(min_region_index)
			min_dist += current_dist
			min_region_index -= 1
		if len(ys) < m and max_region_index <= border_index:
			ys.append(max_region_index)
			min_dist += current_dist
			max_region_index += 1
		while len(ys) < m and region_index < len(regions):
			a, b = regions[region_index]
			if a < b and len(ys) + 2 <= m:
				ys.append(a)
				ys.append(b)
				a += 1
				b -= 1
				min_dist += current_dist * 2
				if a <= b:
					regions[region_index] = (a, b)
				else:
					regions[region_index] = regions[-1]
					regions.pop()
					continue
			else:
				ys.append(a)
				min_dist += current_dist
				regions[region_index] = regions[-1]
				regions.pop()
				continue
			region_index += 1
		current_dist += 1
	return min_dist, ys

def integers():
	return map(int, input().strip().split()) 

def array_of_integers(q):
	return [
		tuple(map(int, input().strip().split())) for _ in range(q)
	]

n, m = integers()
xs = list(integers())
res, ys = solve()
print(res)
print(' '.join(map(str, ys)))


# . . . . . . . . . . . . . . 
# * *   *       * * *
#   *   *   *       * * *