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 
from bisect import bisect_left as bl
from bisect import bisect_right as br
import heapq
import math
from collections import *
from functools import reduce,cmp_to_key
import sys
input = sys.stdin.readline

# M = mod = 998244353
def factors(n):return sorted(list(set(reduce(list.__add__,([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))))
def inv_mod(n):return pow(n, mod - 2, mod)
 
def li():return [int(i) for i in input().rstrip('\n').split(' ')]
def st():return input().rstrip('\n')
def val():return int(input().rstrip('\n'))
def li2():return [i for i in input().rstrip('\n').split(' ')]
def li3():return [int(i) for i in input().rstrip('\n')]




n, m = li()
l = sorted(li())
cnt = Counter(l)
temp = set(l)
# print(l)
ans = 0
leftcounter = deque()
for i in range(n):
    if cnt[l[i] - 1] == 0:
        cnt[l[i] - 1] = 1
        ans += 1
        m -= 1
        leftcounter.append([l[i] - 2,2,-1])
        if not m:break
    if cnt[l[i] + 1] == 0:
        cnt[l[i] + 1] = 1
        ans += 1
        m -= 1
        leftcounter.append([l[i] + 2,2,1])
        if not m:break
# print(cnt)

while m:
    curr,steps,change = leftcounter.popleft()
    if curr not in cnt:
        cnt[curr] = 1
        ans += steps
        m -= 1
    if curr + change not in cnt:
        leftcounter.append([curr + change,steps + 1,change])

    
# print('what')
print(ans)
for i in cnt:
    if i not in temp:
        print(i,end = " ")
print()
























# n = val()
# l = li()
# l1 = l[:]
# l2 = l[:]

# i = 0
# l1 = sorted(list(set(l1)))
# doit = tot1 = 0
# cn = Counter(l1)
# l = l1[:]
# while i < len(l1):
#     if cn[l[i] - 1] > 0:
#         cn[l[i]] -= 1
#         cn[l[i] - 1] += 1
#         l[i] -= 1
#         i += 1
#     else:
#         cn[l[i]] -= 1
#         cn[l[i] + 1] += 1
#         l[i] += 1
#         if i<len(l1) - 1 and l[i + 1] == l[i]:i += 2
#         else:i += 1
# # print(cn)
# tot1 = sum(1 for i in cn if cn[i])









# # print(l1)



# i = 0

# cnt = Counter(l2)
# l2 = sorted(l2)

# l = l2[:]



# for i in range(n):
#     if cnt[l[i] - 1] == 0:
#         cnt[l[i] - 1] += 1
#         cnt[l[i]] -= 1
#         l[i] -= 1
#     elif cnt[l[i]] > 1:
#         cnt[l[i] + 1] += 1
#         cnt[l[i]] -= 1
#         l[i] += 1


# tot2 = sum(1 for i in cnt if cnt[i])





# print(tot1,tot2)