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 Problem_D {
	static final int INF = Integer.MAX_VALUE / 2;

	static class Pair {
		int x, y;

		Pair(int x, int y) {
			this.x = x;
			this.y = y;
		}
	}

	public static void shuffle(int[] A) {
		for (int i = 0; i < A.length; i++) {
			int j = (int)(i * Math.random());
			int tmp = A[i];
			A[i] = A[j];
			A[j] = tmp;
		}
	}

	public static void main(String[] args) {
		InputReader in = new InputReader();
		StringBuilder out = new StringBuilder();

		int N = in.nextInt();
		int M = in.nextInt();
		int[] x = new int[N];
		for (int i = 0; i < N; i++) {
			x[i] = in.nextInt();
		}
		shuffle(x);
		Arrays.sort(x);
		List<Pair> list = new LinkedList<>();
		list.add(new Pair(x[0], -INF));
		list.add(new Pair(x[N - 1], INF));
		for (int i = 1; i < N; i++) {
			int d = x[i] - x[i - 1];
			if (d == 1) {
				continue;
			}
			list.add(new Pair(x[i - 1], d / 2));
			if (d == 2) {
				continue;
			}
			list.add(new Pair(x[i], -((d - 1) / 2)));
		}
		long res = 0;
		List<Integer> y_list = new ArrayList<>();
		Iterator<Pair> it = list.iterator();
		int now = 1;
		while (M-- > 0) {
			while (true) {
				if (!it.hasNext()) {
					it = list.iterator();
					now++;
				}
				Pair p = it.next();
				if (Math.abs(p.y) < now) {
					it.remove();
					continue;
				}
				res += now;
				y_list.add(p.x + Integer.signum(p.y) * now);
				break;
			}
		}
		out.append(res).append('\n');
		for (int y : y_list) {
			out.append(y).append(' ');
		}
		out.setCharAt(out.length() - 1, '\n');

		System.out.print(out);
	}

	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer st;

		public InputReader() {
			reader = new BufferedReader(new InputStreamReader(System.in));
		}

		public String next() {
			while (st == null || !st.hasMoreTokens()) {
				st = new StringTokenizer(nextLine());
			}
			return st.nextToken();
		}

		public String nextLine() {
			try {
				return reader.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return null;
		}

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