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 
def cal_len(seg):
    result = 0
    for s in seg:
        result = result + (s[1] - s[0] + 1 - s[2])
    return result


def solve(max_dis):
    d = max_dis - 1
    seg = [[g_x[0] - d, g_x[0] + d, 0]]
    tot = 0
    for x in g_x:
        if seg[-1][1] >= x - d:
            seg[-1][1] = x + d
            seg[-1][2] = seg[-1][2] + 1
        else:
            tot = tot + (seg[-1][1] - seg[-1][0] + 1 - seg[-1][2])
            if tot >= m:
                return seg
            seg.append([x - d, x + d, 1])
    tot = tot + (seg[-1][1] - seg[-1][0] + 1 - seg[-1][2])
    if tot >= m:
        return seg
    last_idx = len(seg) - 1
    for i, s in enumerate(seg):
        if i == 0 or s[0] - 1 != seg[i - 1][1]:
            s[0] = s[0] - 1
            tot = tot + 1
            if tot >= m:
                return seg
        if i == last_idx or s[1] + 1 != seg[i + 1][0]:
            s[1] = s[1] + 1
            tot = tot + 1
            if tot >= m:
                return seg
    return None


def find_max_dis():
    low = 1
    high = 100000
    while low != high:
        mid = (low + high) / 2
        if solve(mid) is not None:
            high = mid
        else:
            low = mid + 1
    return high


def get_res(seg):
    x_set = set(g_x)
    y_list = []
    for s in seg:
        for y in xrange(s[0], s[1] + 1):
            if y not in x_set:
                y_list.append(y)
    score = 0
    i = 0
    last_i = len(g_x) - 1
    for y in y_list:
        dis = abs(y - g_x[i])
        while i != last_i and dis > abs(y - g_x[i + 1]):
            dis = abs(y - g_x[i + 1])
            i = i + 1
        score = score + dis
    return score, y_list

n, m = map(int, raw_input().split())
g_x = map(int, raw_input().split())
g_x.sort()
max_dis = find_max_dis()
seg = solve(max_dis)
score, y_list = get_res(seg)
print score
for y in y_list:
    print y,
