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.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.PriorityQueue;
public class D611 {

	public static void main(String[] args) {
		FastScanner in = new FastScanner(System.in);
		int T = in.nextInt();
		int P = in.nextInt();
		int[] arr = new int[T];
		for(int i = 0; i < T; i++)
			arr[i] = in.nextInt();
		
		HashSet<Integer> visited = new HashSet<>(P);
		PriorityQueue<Ptr> pq = new PriorityQueue<>();
		
		for(int i = 0; i < T; i++) {
			int val = arr[i];
			Ptr p = new Ptr(val - 1, 1, -1);
			Ptr q = new Ptr(val + 1, 1, 1);
			pq.add(p);
			pq.add(q);
			
			visited.add(val);
		}
		
		long sum = 0;
		ArrayList<Integer> listPos = new ArrayList<>();
		
		while(!pq.isEmpty() && listPos.size() < P) {
			Ptr p = pq.poll();
			if(visited.contains(p.pos)) {
				continue;
			}
			
			visited.add(p.pos);
			listPos.add(p.pos);
			
			sum += p.dist;
			
			p.pos += p.direction;
			p.dist += 1;
			
			pq.add(p);
		}
		
		StringBuilder sb = new StringBuilder();
		sb.append(sum);
		sb.append("\n");
		for(int i : listPos) {
			sb.append(i + " ");
		}
		
		System.out.println(sb.toString().trim());
		
	}
	
	static class Ptr implements Comparable<Ptr> {
		int pos;
		int dist;
		int direction;
		
		public Ptr(int pos, int dist, int direction) {
			this.pos = pos;
			this.dist = dist;
			this.direction = direction;
		}
		
		public int compareTo(Ptr p) {
			return dist - p.dist;
		}
		
		public boolean equals(Object o) {
			if(!(o instanceof Ptr)) {
				return true;
			}
			Ptr p = (Ptr) o;
			return pos == p.pos;
		}
		
		public void setMax() {
			dist = Integer.MAX_VALUE;
		}
	}
	
	/**
	 * Source: Matt Fontaine
	 */
	static class FastScanner {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int chars;

		public FastScanner(InputStream stream) {
			this.stream = stream;
		}

		int read() {
			if (chars == -1)
				throw new InputMismatchException();
			if (curChar >= chars) {
				curChar = 0;
				try {
					chars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (chars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		boolean isEndline(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}

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

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

		public double nextDouble() {
			return Double.parseDouble(next());
		}

		public String next() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public String nextLine() {
			int c = read();
			while (isEndline(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndline(c));
			return res.toString();
		}
	}

}
/*
2 6
1 5
outputCopy
8
-1 2 6 4 0 3 
inputCopy
3 5
0 3 1
outputCopy
7
5 -2 4 -1 2 
*/