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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class D {

	public static void main(String[] args) {
		FastScanner fs=new FastScanner();
		int nTrees=fs.nextInt(), nPeople=fs.nextInt();
		HashSet<Long> used=new HashSet<>();
		PriorityQueue<Arrow> arrows=new PriorityQueue<>();
		for (int i=0; i<nTrees; i++) {
			long x=fs.nextInt();
			used.add(x);
			arrows.add(new Arrow(-1, x-1, 1));
			arrows.add(new Arrow(+1, x+1, 1));
		}
		ArrayList<Long> answers=new ArrayList<>();
		long sumOfDists=0;
		while (nPeople>0) {
			Arrow next=arrows.remove();
			if (used.contains(next.x)) continue;
			nPeople--;
			used.add(next.x);
			answers.add(next.x);
			sumOfDists+=next.distance;
			arrows.add(next.forward());
		}
		
		System.out.println(sumOfDists);
		Collections.sort(answers);
		for (long l:answers) {
			System.out.print(l+" ");
		}
		System.out.println();
	}

	static class Arrow implements Comparable<Arrow> {
		int dir;//+/-1
		long x;
		int distance;
		
		public Arrow(int dir, long x, int distance) {
			this.dir=dir;
			this.x=x;
			this.distance=distance;
		}
		
		public Arrow forward() {
			return new Arrow(dir, x+dir, distance+1);
		}
		
		public int compareTo(Arrow o) {
			return Integer.compare(distance, o.distance);
		}
	}
	
	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		
		public String next() {
			while (!st.hasMoreTokens())
				try {
					st=new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
			
		}
		
		public int nextInt() {
			return Integer.parseInt(next());
		}
		
		public long nextLong() {
			return Long.parseLong(next());
		}
		
		public int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++)
				a[i]=nextInt();
			return a;
		}
	}
	
}
