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.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
import java.util.Stack;
 
public class Main {
	
	public static class FastReader {
		BufferedReader br;
		StringTokenizer st;
	
 
		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}
 
		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception r) {
					r.printStackTrace();
				}
			}
			return st.nextToken();
		}
 
		int nextInt() {
			return Integer.parseInt(next());//converts string to integer
		}
 
		double nextDouble() {
			return Double.parseDouble(next());
		}
 
		long nextLong() {
			return Long.parseLong(next());
		}
 
		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (Exception r) {
				r.printStackTrace();
			}
			return str;
		}
	}
	
	public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
   
  // static Scanner sc = new Scanner(in);
  
    private final static int mod = (int) (1e9 + 7);
    private final static int N = (int) (1e6);
    public static List<Integer>[] edges ;
    
	public static void main(String[] args) {
	 FastReader sc = new FastReader();
	
	    int n = sc.nextInt();
		int m = sc.nextInt();
		
		TreeSet<Integer> s = new TreeSet<>();
		TreeMap<Integer,Integer> map = new TreeMap<>();
		Integer[] arr = new Integer[n];
		Queue<Pair> q = new LinkedList<>();
		for (int i = 0 ; i < n ; i++)
		{
			arr[i] = sc.nextInt();
			map.put(arr[i], 1);
		}
		long ans = 0;
		Arrays.sort(arr);
		int[] a = new int[n];
		for(int i=0;i<n;++i) a[i] =arr[i].intValue();
		
		for (int i = 0 ; i < n ; i++)
		{
			int x = a[i] - 1;
			int y = a[i] + 1;
			if (!map.containsKey(x))
			{
				
				q.add(new Pair(x,1));
				map.put(x, 1);
				s.add(x);
				ans++;
			}
			if (s.size() == m)
			{
				break;
			}
			if (!map.containsKey(y))
			{
				q.add(new Pair(y,1));
				map.put(y, 1);
				s.add(y);
				ans++;
			}
			if (s.size() == m)
			{
				break;
			}
		}
 
		while (s.size() < m)
		{
			int x = q.peek().f - 1;
			int y = q.peek().f + 1;
			int d = q.peek().s;
			q.poll();
			if (!map.containsKey(x))
			{
				ans += d + 1;
				q.add(new Pair(x,d+1));
				map.put(x, 1);
				s.add(x);
			}
			if (s.size() == m)
			{
				break;
			}
			if (!map.containsKey(y))
			{
				ans += d + 1;
				q.add(new Pair(y,d+1));
				map.put(y, 1);
				s.add(y);
			}
		}
		out.println(ans);
		for (int x : s)
		
			out.print(x+" ");
			
		
 
		out.close();
	}
static class Pair{
	int f;
	int s;
	Pair(int f,int s){
		this.f = f;
		this.s = s;
	}
}
 
	
 
}