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 inp(dtype=str, strip=True):
    s = input()
    res = [dtype(p) for p in s.split()]
    res = res[0] if len(res) == 1 and strip else res
    return res


def problem1():
    t = inp(int)
    for _ in range(t):
        h, m = inp(int)
        print((23 - h) * 60 + (60 - m))


def problem2():
    t = inp(int)
    for _ in range(t):
        n, k = inp(int)
        res = (n // k) * k + min(n % k, k // 2)
        print(res)


def problem3():
    n = inp(int)
    f = inp(int, strip=False)
    f = [ch - 1 for ch in f]
    g = [-1 for _ in range(n)]
    for i, ch in enumerate(f):
        if ch >= 0:
            g[ch] = i

    gave = set([i for i in range(n) if f[i] >= 0 and g[i] == -1])
    received = set([i for i in range(n) if f[i] == -1 and g[i] >= 0])
    neither = set([i for i in range(n) if f[i] == -1 and g[i] == -1])

    # give a gift to anyone who has not yet given one
    # and has not yet received one

    while len(neither):
        # i is giving to j
        if len(received):
            i = received.pop()
        else:
            i = neither.pop()
            gave.add(i)
        j = neither.pop()
        received.add(j)
        f[i] = j

    while len(received):
        i = received.pop()
        j = gave.pop()
        f[i] = j

    f = [ch + 1 for ch in f]
    print(' '.join([str(ch) for ch in f]))


def problem4():
    max_m = 10 ** 6
    n, m = inp(int)
    x = inp(int, strip=False)

    x = sorted(x)

    empty = [(0, 0) for _ in range(n + 1)]
    for i in range(1, n):
        empty[i] = (x[i] - x[i - 1] - 1, i)
    empty[0] = (max_m, 0)
    empty[-1] = (max_m, n)

    empty = sorted(empty, key=lambda tup: tup[0])

    cur_dist = 1
    start = 0
    while empty[start][0] == 0:
        start += 1
    j = 0
    y = [0 for _ in range(m)]
    p = start
    res = 0

    while j < m:
        # print(x, empty, y)

        num, i = empty[p]
        res += cur_dist
        if i == 0:
            # to the left of tree #0
            num -= 1
            y[j] = x[i] - cur_dist
            j += 1
        elif i == n:
            # to the right of tree #n-1
            num -= 1
            y[j] = x[i - 1] + cur_dist
            j += 1
        else:
            # between trees i - 1 and i
            num -= 1
            y[j] = x[i - 1] + cur_dist
            j += 1
            if j < m and num > 0:
                num -= 1
                y[j] = x[i] - cur_dist
                j += 1
                res += cur_dist

        if num == 0:
            start += 1
        empty[p] = (num, i)

        p += 1
        if p == n + 1:
            cur_dist += 1
            p = start

    print(res)
    print(' '.join([str(k) for k in y]))


def problem5():
    pass


if __name__ == '__main__':
    # problem1()
    # problem2()
    # problem3()
    problem4()
    # problem5()
