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 File {
    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }

            return st.nextToken();
        }

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

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

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }
	
    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
		
		
		
		int n = sc.nextInt(); // Trees 
		int m = sc.nextInt(); // People
		
		// Where each tree is at.
		TreeSet<Integer> trees = new TreeSet<Integer>();
		// The result positions for each person.
		Set<Integer> people = new HashSet<Integer>();
		Set<Integer> visited = new HashSet<Integer>();
		
		int[] pos = new int[n];		
		
		for (int i = 0; i < n; i++) {
			pos[i] = sc.nextInt();
			trees.add(pos[i]);
			visited.add(pos[i]);
		}
		
		
		
		
		// Process available positions, priority by distance to closest tree.
		// {index, closest tree index}
		PriorityQueue<int[]> pq = new PriorityQueue<int[]>(new Comparator<int[]>() {
			@Override
			public int compare(int[] a, int[] b) {
				return Math.abs(a[0] - a[1]) - Math.abs(b[0] - b[1]);
			}
		});
		
		for (int p : trees) {
			if (!trees.contains(p-1) && !visited.contains(p-1)) {
				pq.offer(new int[] {p-1, p});
				visited.add(p-1);
			}
			if (!trees.contains(p+1) && !visited.contains(p+1)) {
				pq.offer(new int[] {p+1, p});
				visited.add(p+1);
			}
		}
		
		
		long total = 0;
		for (int i = 0; i < m; i++) {
			boolean found = false;
			
			while (!found) {
				int[] entry = pq.poll();
				int top = entry[0];
				int closest = entry[1];
				
				if (!people.contains(top)) {
					total += Math.abs(top - closest);
				    people.add(top);
					
					if (!visited.contains(top-1)) {
						Integer L = trees.floor(top - 1);						
						
					    visited.add(top-1);
						int closer = closest;
						
						if (L != null && Math.abs(L - (top-1)) < Math.abs(closer - (top - 1))) {
							closer = L;
						}
						
						pq.offer(new int[] {top-1, closer});
					}
					if (!visited.contains(top+1)) {
						Integer R = trees.ceiling(top + 1);
						
					    visited.add(top+1);
						int closer = closest;
						
						if (R != null && Math.abs(R - (top + 1)) < Math.abs(closer - (top + 1))) {
							closer = R;
						}
						
						pq.offer(new int[] {top+1, closer});
					}
					
					found = true;
				}
			}				
		}
		
		
		out.println(total);
		for (int p : people) {
			out.print(p + " ");
		}
		
		
		
		
		out.close();
	}
}








