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.BigInteger;
import java.util.*;
 
public class A {
	public static void main (String[] args) { new A(); }
 
	A() {
		FastScanner fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		System.err.println("");

		int n = fs.nextInt(), m = fs.nextInt();
		HashSet<Integer> seen = new HashSet<>();
		int[] a = new int[n];
		for(int i = 0; i < n; i++) {
			a[i] = fs.nextInt();
			seen.add(a[i]);
		}
		TreeSet<Tree> set = new TreeSet<>();
		for(int i = 0; i < n; i++) {
			if(seen.contains(a[i]+1) && seen.contains(a[i]-1)) continue;
			int free1 = seen.contains(a[i]-1) ? 0 : 1;
			int free2 = seen.contains(a[i]+1) ? 0 : 1;
			set.add(new Tree(a[i], free1, free2));
		}
		
		int oo = (int)2e9;
		int[] res = new int[m];
		long sum = 0;
		for(int i = 0; i < m; i++) {
			boolean go = true;
			while(go) {
				go = false;
				Tree best = set.pollFirst();
				int v1 = best.free1 == oo ? 0 : best.free1;
				int v2 = best.free2 == oo ? 0 : best.free2;
				
				if(seen.contains(best.pos-v1) && seen.contains(best.pos+v2)) {
					go = true;
					continue;
				}
				if(seen.contains(best.pos-v1)) {
					best.free1 = oo; v1 = 0;
				}
				if(seen.contains(best.pos+v2)) {
					best.free2 = oo; v2 = 0;
				}
				
				if(v1 != 0 && (best.free1 <= best.free2) && !seen.contains(best.pos-v1)) {
					res[i] = best.pos-best.free1;
					best.free1++; 
					if(seen.contains(best.pos-best.free1)) best.free1 = oo;
				}
				else {
					res[i] = best.pos+best.free2;
					best.free2++; 
					if(seen.contains(best.pos+best.free2)) best.free2 = oo;
				}
				seen.add(res[i]);
				sum += Math.abs(res[i]-best.pos);
				set.add(best);
			}
		}
		out.println(sum);
		for(int i = 0; i < m; i++) out.print(res[i] + " ");
		
		
		out.close();
	}
	
	class Tree implements Comparable<Tree>{
		int pos, free1, free2;
		Tree(int p, int f, int ff) {
			pos = p; free1 = f; free2 = ff;
		}
		public int compareTo(Tree t) {
			int c = Integer.compare(Math.min(free1, free2), Math.min(t.free1, t.free2)); 
			if(c == 0) c = Integer.compare(pos, t.pos);
			return c;
		}
	}
	
	
	class FastScanner {
		BufferedReader br;
		StringTokenizer st;
		FastScanner(){
			br = new BufferedReader(new InputStreamReader(System.in));
			st = new StringTokenizer("");
		}
		String next() {
			if(st.hasMoreTokens()) return st.nextToken();
			try { st = new StringTokenizer(br.readLine()); } catch (Exception e) {}
			return next();
		}
		int nextInt() {
			return Integer.parseInt(next());
		}
	}
}