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.util.*;
 
public class Main {
	static Scanner scanner = new Scanner(System.in);
	static PrintWriter out = new PrintWriter(System.out);
	static int n, m;
	static long sum;
 
	public static void main(String[] args) throws Exception {
		int n = scanner.nextInt();
		int m = scanner.nextInt();
 
		ArrayList<Integer> arr = new ArrayList<>();
		ArrayList<Integer> res = new ArrayList<>();
		for (int i = 0; i < n; i++) {
			arr.add(scanner.nextInt());
		}
 
		Collections.sort(arr);
 
		PriorityQueue<node> pq = new PriorityQueue<>();
 
		for (int i = 0; i < n - 1; i++) {
			node a = new node(arr.get(i), arr.get(i + 1));
			if (a.diff <= 0) continue;
			pq.add(a);
		}
 
		int cur = 1;
		while (true) {
			ArrayList<Integer> ans = new ArrayList<>();
			ArrayList<node> comp = new ArrayList<>();
			int fst = arr.get(0) - cur;
			int lst = arr.get(arr.size() - 1) + cur;
			ans.add(fst);
			ans.add(lst);
 
			while (!pq.isEmpty()) {
				node a = pq.poll();
				if (a.diff == 1) {
					ans.add(a.st + 1);
				} else {
					ans.add(a.st + 1);
					ans.add(a.end - 1);
					if (a.diff > 2) {
						node b = new node(a.st + 1, a.end - 1);
						comp.add(b);
					}
				}
			}
			pq.clear();
			for(node x : comp) {
				pq.add(x);
			}
			
			int idx = 0;
			while (m > 0 && idx < ans.size()) {
				m--;
				res.add(ans.get(idx++));
				sum += cur;
			}
			
			cur++;
			if (m <= 0)
				break;
		}
 
		out.println(sum);
		for (int x : res) {
			out.print(x + " ");
		}
		out.close();
	}
 
	static class node implements Comparable<node> {
		int st, end, diff;
 
		public node(int st, int end) {
			this.st = st;
			this.end = end;
			diff = end - st - 1;
		}
 
		public int compareTo(node o) {
			return o.diff - this.diff;
		}
 
	}
 
}
 
class Scanner {
	StringTokenizer st;
	BufferedReader br;
 
	public Scanner(InputStream system) {
		br = new BufferedReader(new InputStreamReader(system));
	}
 
	public Scanner(String file) throws Exception {
		br = new BufferedReader(new FileReader(file));
	}
 
	public String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
 
	public String nextLine() throws IOException {
		return br.readLine();
	}
 
	public int nextInt() throws IOException {
		return Integer.parseInt(next());
	}
 
	public double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
 
	public Long nextLong() throws IOException {
		return Long.parseLong(next());
	}
 
}
