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 
/*
Solution: Do a Dijkstra-like algorithm, branching out from each christmas tree. Greedily place people at the closest
points possible, and continue to branch out until enough people have been placed.

Since the coordinate space is way too big, use a HashSet to determine which locations have already been visited.

Runtime: O(N + M)
*/

import java.io.*;
import java.util.*;

public class xmastrees {
    int N, M;
    HashSet<Integer> visited = new HashSet<>();
    int[] trees;
    long distSum;
    ArrayList<Integer> peopleLocs;

    xmastrees() throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(in.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        trees = new int[N];
        st = new StringTokenizer(in.readLine());
        for (int i = 0; i < N; i++) {
            trees[i] = Integer.parseInt(st.nextToken());
            visited.add(trees[i]);
        }
        in.close();
        placePeople();
        PrintWriter out = new PrintWriter(System.out);
        out.println(distSum);
        for (int i = 0; i < M; i++) {
            out.print(peopleLocs.get(i));
            if (i != M - 1) out.print(' ');
            else out.println();
        }
        out.close();
    }

    void placePeople() {
        distSum = 0;
        peopleLocs = new ArrayList<>(M);
        int currCost = 1, currLeft = 0, nextLeft = 0;
        Queue<Integer> q = new LinkedList<>();
        for (int tree : trees) {
            if (!visited.contains(tree - 1)) {
                visited.add(tree - 1);
                q.add(tree - 1);
                currLeft++;
            }
            if (!visited.contains(tree + 1)) {
                visited.add(tree + 1);
                q.add(tree + 1);
                currLeft++;
            }
        }

        int numPlaced = 0;
        while (!q.isEmpty()) {
            if (currLeft == 0) {
                currLeft = nextLeft;
                nextLeft = 0;
                currCost++;
            }
            currLeft--;
            int c = q.poll();
            peopleLocs.add(c);
            distSum += currCost;
            if (++numPlaced == M) break;
            // Search neighbors
            if (!visited.contains(c-1)) {
                visited.add(c-1);
                q.add(c-1);
                nextLeft++;
            }
            if (!visited.contains(c+1)) {
                visited.add(c+1);
                q.add(c+1);
                nextLeft++;
            }
        }
    }

    public static void main(String[] args) throws IOException {
        new xmastrees();
    }
}
