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

public class christmastrees {
    public static void main(String[] args) throws IOException {
        FastScanner scan = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        
        int n = scan.nextInt();
        int p = scan.nextInt();
        int[] trees = new int[n];
        HashSet<Integer> used = new HashSet<Integer>();
        for (int i = 0; i < n; i++) {
        	trees[i] = scan.nextInt();
        	used.add(trees[i]);
        }
        shuffle(trees);
        Arrays.sort(trees);
        
        PriorityQueue<int[]> queue = new PriorityQueue<int[]>((a,b) -> a[0]-b[0]);//dist, pos
        
        for (int i = 0; i<n; i++) {
        	if (!used.contains(trees[i]+1)) {
        		queue.add(new int[] {1,trees[i]+1});
        		used.add(trees[i]+1);
        	}
        	if (!used.contains(trees[i]-1)) {
        		queue.add(new int[] {1,trees[i]-1});
        		used.add(trees[i]-1);
        	}
        }
        int[] pos = new int[p];
        long ans = 0;
        while (!queue.isEmpty()) {
        	int[] arr = queue.remove();
        	p--;
        	pos[p] = arr[1];
        	ans+=arr[0];
        	if (p == 0)
        		break;
        	if (!used.contains(arr[1]+1)) {
        		queue.add(new int[] {arr[0]+1,arr[1]+1});
        		used.add(arr[1]+1);
        	}
        	if (!used.contains(arr[1]-1)) {
        		queue.add(new int[] {arr[0]+1,arr[1]-1});
        		used.add(arr[1]-1);
        	}
        }
        out.println(ans);
        for (int i : pos) {
        	out.print(i + " ");
        }
        out.close();
    }
    
    public static void shuffle(int[] arr) {
    	Random rgen = new Random();
    	
    	for (int i = 0; i < arr.length; i++) {
    		int rPos = rgen.nextInt(arr.length);
    		int temp = arr[i];
    		arr[i] = arr[rPos];
    		arr[rPos]=temp;
    	}
    }

    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

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

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return null;
        }

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

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

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