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 
//package div3_round611;

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

public class QuestionD {

    public static void main(String[] args){
        out = new PrintWriter(new BufferedOutputStream(System.out));
        in = new MyScanner();

        int n = in.nextInt(), m = in.nextInt();
        long[] x = new long[n];
        for (int i=0; i<n; i++) x[i] = in.nextLong();
        solve(x, n, m);
        out.close();
    }

    public static void solve(long[] x, int n, int m) {
        long[] y = new long[m];
        Set<Long> treeSpots = new HashSet<>();
        for (long v : x) treeSpots.add(v);

        Deque<Long[]> queue = new LinkedList<>();
        Set<Long> visited = new HashSet<>();
        for (int i=0; i<n; i++) {
            if (!treeSpots.contains(x[i]-1) && !visited.contains(x[i]-1)) {
                queue.add(new Long[] {x[i]-1, 1L});
                visited.add(x[i]-1);
            }
            if (!treeSpots.contains(x[i]+1) && !visited.contains(x[i]+1)) {
                queue.add(new Long[] {x[i]+1, 1L});
                visited.add(x[i]+1);
            }
        }

        int solving = 0;
        long tot = 0;
        while (solving < m) {
            Long[] cur = queue.pollFirst();
            y[solving++] = cur[0];
            tot += cur[1];
            if (!treeSpots.contains(cur[0]-1) && !visited.contains(cur[0]-1)) {
                queue.add(new Long[] {cur[0]-1, cur[1]+1});
                visited.add(cur[0]-1);
            }
            if (!treeSpots.contains(cur[0]+1) && !visited.contains(cur[0]+1)) {
                queue.add(new Long[] {cur[0]+1, cur[1]+1});
                visited.add(cur[0]+1);
            }
        }

        out.println(tot);
        for (int i=0; i<m; i++) {
            out.print(y[i] + " ");
        }
    }

    public static PrintWriter out;
    public static MyScanner in;
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine(){
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        List<Integer[]> readListOfIntsHorizontal(int n, int m) {
            List<Integer[]> ret = new ArrayList<>();
            for (int j=0; j<n; j++){
                ret.add(new Integer[m]);
            }
            for (int i=0; i<n; i++) {
                for(int j=0; j<m; j++) {
                    ret.get(i)[j] = nextInt();
                }
            }
            return ret;
        }

        List<Integer[]> readListOfIntsVertical(int n, int m) {
            List<Integer[]> ret = new ArrayList<>();
            for (int j=0; j<m; j++){
                ret.add(new Integer[n]);
            }
            for (int i=0; i<n; i++) {
                for(int j=0; j<m; j++) {
                    ret.get(j)[i] = nextInt();
                }
            }
            return ret;
        }
    }
}