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, bisect_right
from typing import List
import collections
import bisect
import itertools
import functools
from fractions import gcd
import heapq
from math import ceil, sqrt, floor

import sys
sys.setrecursionlimit(50000)

import collections

from collections import defaultdict, deque
import collections

import bisect

from collections import defaultdict, deque
import collections
n, m = list(map(int, input().split()))

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

dic = {}
for x in xs:
    dic[x] = (x,x)


merged_intervals = []
for k,v in dic.items():
    if k - 1 not in dic:
        j = k
        while j + 1 in dic:
            j += 1
        merged_intervals.append((k, j))

merged_intervals.sort()

spaces = []
for i in range(len(merged_intervals) - 1):
    dist = merged_intervals[i+1][0] - merged_intervals[i][1] - 1
    spaces.append(dist)
# spaces.append(2 ** 32)

total_dist = 0
current_dist = 1
num = 0
ys = []
valid_indices = {i for i in range(len(spaces))}
invalid_indices = set()
while num < m:
    for i in valid_indices:
        if num >= m:
            break
        avail = min(2, spaces[i], m - num)
        num += avail
        total_dist += current_dist * avail

        if avail >= 1:
            ys.append(merged_intervals[i][1] + current_dist)
        if avail >= 2:
            ys.append(merged_intervals[i+1][0] - current_dist)
        spaces[i] -= avail
        if spaces[i] == 0:
            invalid_indices.add(i)
    if num < m:
        total_dist += current_dist
        ys.append(merged_intervals[0][0] - current_dist)
        num += 1
    if num < m:
        total_dist += current_dist
        ys.append(merged_intervals[-1][1] + current_dist)
        num += 1
    for invalid in invalid_indices:
        valid_indices.remove(invalid)
    if invalid_indices:
        invalid_indices.clear()
    current_dist += 1

print(total_dist)
print(' '.join(str(c) for c in ys))
