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

public class D
{
	static class Pos implements Comparable<Pos>
	{
		int y;
		int del;

		Pos(int yy, int dd)
		{
			y = yy;
			del = dd;
		}

		public int compareTo(Pos p)
		{
			int cmp = Integer.compare(del, p.del);
			return cmp != 0 ? cmp : Integer.compare(y, p.y);
		}
	}
	static void solve(FastIO io)
	{
		int n = io.nextInt();
		int m = io.nextInt();
		int[] x = new int[n];

		HashSet<Integer> taken = new HashSet<>();
		PriorityQueue<Pos> q = new PriorityQueue<>();
		ArrayList<Integer> ans = new ArrayList<>();
		int seen = 0;
		long sum = 0;

		for (int i = 0; i < n; i++)
		{
			x[i] = io.nextInt();
			q.add(new Pos(x[i]+1, 1));
			q.add(new Pos(x[i]-1, 1));
			taken.add(x[i]);
		}

		while (seen < m)
		{
			Pos p = q.remove();

			if (taken.contains(p.y))
				continue;

			taken.add(p.y);
			sum += p.del;
			ans.add(p.y);
			seen++;
		
			if (!taken.contains(p.y + 1))
				q.add(new Pos(p.y + 1, p.del + 1));

			if (!taken.contains(p.y - 1))
				q.add(new Pos(p.y - 1, p.del + 1));
		}

		io.println(sum);
		for (int i : ans)
			io.print(i + " ");
		io.println();
	}

	public static void main(String[] args) {
		FastIO io = new FastIO();

		solve(io);

		io.close();
	}
}

class FastIO extends PrintWriter
{
	BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
	StringTokenizer st = new StringTokenizer("");

	FastIO()
	{
		super(System.out);
	}

	public String next()
	{
		while (!st.hasMoreTokens())
		{
			try {
				st = new StringTokenizer(r.readLine());
			} catch (Exception e) {
				//TODO: handle exception
			}
		}
		return st.nextToken();
	}

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

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

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