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

public class D_1283 {
	
	static int INF = (int)1e9;
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		
		int n = sc.nextInt(), m = sc.nextInt();
		int[] array = sc.shuffle(sc.nextIntArray(n));
		Arrays.sort(array);
		
		PriorityQueue<Tree> qu = new PriorityQueue<>();
		for(int i = 0; i < n; i++) {
			if(n == 1) {
				qu.add(new Tree(array[i], 0, 0, INF));
				qu.add(new Tree(array[i], 1, 0, INF));
			} else if(i == 0) {
				qu.add(new Tree(array[i], 0, 0, (array[1] - array[0] - 1) / 2));
				qu.add(new Tree(array[i], 1, 0, INF));
			} else if(i == n - 1) {
				qu.add(new Tree(array[i], 0, 0, INF));
				qu.add(new Tree(array[i], 1, 0, (array[n - 1] - array[n - 2]) / 2));
			} else {
				qu.add(new Tree(array[i], 0, 0, (array[i + 1] - array[i] - 1) / 2));
				qu.add(new Tree(array[i], 1, 0, (array[i] - array[i - 1]) / 2));
			}
		}
		
		long ans = 0;
		ArrayList<Integer> list = new ArrayList<>();
		while(m-->0) {
			while(true) {
				Tree t = qu.peek();
				if(t.c == t.l)
					qu.poll();
				else
					break;
			}
			Tree t = qu.poll();
			t.c++;
			if(t.d == 0)
				list.add(t.p + t.c);
			else
				list.add(t.p - t.c);
			ans += t.c;
			qu.add(t);
		}
		
		m = list.size();
		pw.println(ans);
		for(int i = 0; i < m; i++)
			pw.print(list.get(i) + (i == m - 1 ? "\n" : " "));
		
		pw.flush();
	}
	
	public static class Tree implements Comparable<Tree> {
		int p, d, c, l;
		
		public Tree(int p, int d, int c, int l) {
			this.p = p;
			this.d = d;
			this.c = c;
			this.l = l;
		}
		
		public int compareTo(Tree t) {
			return this.c - t.c;
		}
	}

	public static 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 char nextChar() throws IOException {
			return next().charAt(0);
		}

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

		public int[] nextIntArray(int n) throws IOException {
			int[] array = new int[n];
			for (int i = 0; i < n; i++)
				array[i] = nextInt();
			return array;
		}

		public Integer[] nextIntegerArray(int n) throws IOException {
			Integer[] array = new Integer[n];
			for (int i = 0; i < n; i++)
				array[i] = new Integer(nextInt());
			return array;
		}

		public long[] nextLongArray(int n) throws IOException {
			long[] array = new long[n];
			for (int i = 0; i < n; i++)
				array[i] = nextLong();
			return array;
		}

		public double[] nextDoubleArray(int n) throws IOException {
			double[] array = new double[n];
			for (int i = 0; i < n; i++)
				array[i] = nextDouble();
			return array;
		}

		public static int[] shuffle(int[] a) {
			int n = a.length;
			Random rand = new Random();
			for (int i = 0; i < n; i++) {
				int tmpIdx = rand.nextInt(n);
				int tmp = a[i];
				a[i] = a[tmpIdx];
				a[tmpIdx] = tmp;
			}
			return a;
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
}
