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 
import java.util.*;
import java.io.*;
import java.util.concurrent.TimeUnit;

public class ChristmasTrees_1800 {
    public static void main(String args[]) throws IOException {
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

        StringTokenizer st = new StringTokenizer(f.readLine());
        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());

        Set<Long> trees = new HashSet<>();
        Set<Long> people = new HashSet<>();
        Queue<long[]> queue = new LinkedList<long[]>();
        st = new StringTokenizer(f.readLine());
        for(int i = 0; i < N; i++) {
            long t = Long.parseLong(st.nextToken());
            trees.add(t);
            queue.add(new long[] {t+1, 1});
            queue.add(new long[] {t-1, -1});
        }

        long sum = 0;
        while(true) {
            if(people.size() >= M)
                break;
            long[] stor = queue.poll();
            if(!people.contains(stor[0]) && !trees.contains(stor[0])) {
                //System.out.println(stor[0] + " " + trees);
                people.add(stor[0]);
                sum += Math.abs(stor[1]);
                //System.out.println(stor[0] + " " + stor[1]);
                if(stor[1] > 0) {
                    queue.add(new long[] {stor[0] + 1, stor[1] + 1});
                } else {
                    queue.add(new long[] {stor[0] - 1, stor[1] - 1});
                }
            }
        }

        out.println(sum);
        Iterator<Long> it = people.iterator();
        long x = it.next();
        out.print(x);
        while(it.hasNext()) {
            out.print(" " + it.next());
        }
        out.println();

        out.close();
        f.close();

//        Scanner std = new Scanner(System.in);
//
//        int N = std.nextInt();
//        int M = std.nextInt();
//
//        Set<Long> trees = new HashSet<>();
//        Set<Long> people = new HashSet<>();
//        Queue<long[]> queue = new LinkedList<long[]>();
//        for(int i = 0; i < N; i++) {
//            long t = std.nextLong();
//            trees.add(t);
//            queue.add(new long[] {t+1, 1});
//            queue.add(new long[] {t-1, -1});
//        }
//
//        long sum = 0;
//        while(true) {
//            if(people.size() >= M)
//                break;
//            long[] stor = queue.poll();
//            if(!people.contains(stor[0]) && !trees.contains(stor[0])) {
//                //System.out.println(stor[0] + " " + trees);
//                people.add(stor[0]);
//                sum += Math.abs(stor[1]);
//                //System.out.println(stor[0] + " " + stor[1]);
//                if(stor[1] > 0) {
//                    queue.add(new long[] {stor[0] + 1, stor[1] + 1});
//                } else {
//                    queue.add(new long[] {stor[0] - 1, stor[1] - 1});
//                }
//            }
//        }
//
//        System.out.println(sum);
//        for(long t: people) {
//            System.out.print(t + " ");
//        }

//        int n = std.nextInt();
//        int ppl = std.nextInt();
//       // int[] data = new int[n];
//        HashSet<Integer> christ = new HashSet<>();
//        HashSet<Integer> spotsTaken = new HashSet<>();
//        for (int i = 0; i < n; i++) {
//            int an = std.nextInt();
//            christ.add(an);
//            spotsTaken.add(an);
//        }
//        ArrayList<Integer> pplLoc = new ArrayList<>();
//        int distSum = 0;
//
//        int maxDif = 1;
//
//        while (pplLoc.size() < ppl) {
//            for (Iterator<Integer> el = christ.iterator(); el.hasNext();) {
//
//                Integer i = el.next();
//
//                if (pplLoc.size() < ppl && christ.contains(i - maxDif) && christ.contains(i + maxDif)) { //we are trying to add a people to a tree that already exists, so
//                    //on the given tree, we are trying to add to a different tree on both sides (the current tree is useless)
//                    //so i tree is useless
//                    el.remove();
//                    continue;
//                }
//
//                if(pplLoc.size() < ppl && !spotsTaken.contains(i - maxDif)) { //so basically, can we put it x spot before?
//                    spotsTaken.add(i - maxDif);
//                    pplLoc.add(i - maxDif);
//                    distSum += maxDif;
//                }
//                if(pplLoc.size() < ppl && !spotsTaken.contains(i + maxDif)) {//so basically, can we put it x spot after?
//                    spotsTaken.add(i + maxDif);
//                    pplLoc.add(i + maxDif);
//                    distSum += maxDif;
//                }
//
//            }
//            maxDif++;
//
//        }
//        System.out.println(distSum);
//        for (int tmp : pplLoc) {
//            System.out.print(tmp + " ");
//        }
    }
}
