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.*;
import java.lang.*;
public class Main {

	public static void main(String[] args)throws IOException {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);
        
		int n = in.nextInt();
		int m = in.nextInt();
		long trees[] = new long[n];
		long ans = 0;
		PriorityQueue<ArrayList<Long>> q = new PriorityQueue<ArrayList<Long>>((x,y)->(int)(Math.abs(x.get(1))-Math.abs(y.get(1))));
		ArrayList<Long> anslist = new ArrayList<Long>();
		HashSet<Long> done = new HashSet<Long>();
		for(int i=0;i<n;i++)
		{
			trees[i]=in.nextLong();
			done.add(trees[i]);
		}
		for(int i=0;i<n;i++)
		{
			// ArrayList<Long> a=new ArrayList<Long>();
			if(!done.contains(trees[i]-1))
			{
				ArrayList<Long> a=new ArrayList<Long>();
				a.add((long)i);a.add(-1l);
				q.add(a);
			}
			if(!done.contains(trees[i]+1))
			{
				ArrayList<Long> a=new ArrayList<Long>();
				a.add((long)i);a.add(1l);
				q.add(a);
			}
		}
		ArrayList<Long>a;
		long tpos,delta;
		long tix;
		long i=0;
		while(i<m)
		{
			a=q.poll();
			tix = a.get(0);
			tpos = trees[(a.get(0)).intValue()];
			delta = a.get(1);
			if(!done.contains(tpos+delta))
			{
				anslist.add(tpos+delta);
				ans+=Math.abs(delta);
				done.add(tpos+delta);
				i++;
			}
			else
				continue;
			if(delta<0)
				delta--;
			else
				delta++;
			if(!done.contains(tpos+delta))
			{
				a.set(1,delta);
				q.add(a);
			}
		}
		out.println(ans);
		for(i=0;i<m;i++)
		{
			out.print(anslist.get((int)i)+" ");
		}
		out.println();
        out.close();
	}
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

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

    }

}