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.ArrayList;
import java.util.Collections;
import java.util.PriorityQueue;
import java.util.Scanner;

public class r611d {
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		int n=scan.nextInt(), m=scan.nextInt();
		PriorityQueue<gap> q=new PriorityQueue<>();
		
		ArrayList<Integer> temp=new ArrayList<>();
		for(int i=0;i<n;i++) temp.add(scan.nextInt());
		Collections.sort(temp);
		int[] a=new int[n];
		for(int i=0;i<n;i++) a[i]=temp.get(i);
		
		for(int i=1;i<n;i++) {
			if(a[i]-a[i-1]>1) q.offer(new gap(a[i-1],a[i],1));
		}
		
		q.offer(new gap(Integer.MIN_VALUE,a[0],1));
		q.offer(new gap(a[n-1],Integer.MIN_VALUE,1));
		
		long dist=0;
		ArrayList<Long> res=new ArrayList<>();
		while(!q.isEmpty()&&res.size()<m) {
			gap g=q.poll();
			
//			System.out.println(g.t1+" "+g.t2+" "+g.minleft);
			if(g.t1==Integer.MIN_VALUE) {
				res.add(g.t2-g.minleft);
				q.offer(new gap(g.t1,g.t2,g.minleft+1));
				dist+=g.minleft;
			}
			else if(g.t2==Integer.MIN_VALUE) {
				res.add(g.t1+g.minleft);
				q.offer(new gap(g.t1,g.t2,g.minleft+1));
				dist+=g.minleft;
			}
			else if(g.minleft==g.max) { 
				if(g.q==1) {
					res.add(g.t1+g.minleft);
					dist+=g.minleft;
				}
				else {
					res.add(g.t1+g.minleft);
					dist+=g.minleft;
					if(res.size()==m) break;
					res.add(g.t2-g.minleft);
					dist+=g.minleft;
				}
			}
			else {
				res.add(g.t1+g.minleft);
				dist+=g.minleft;
				if(res.size()==m) break;
				res.add(g.t2-g.minleft);
				dist+=g.minleft;
				q.offer(new gap(g.t1,g.t2,g.minleft+1));
			}
		}
		System.out.println(dist);
		for(int i=0;i<m;i++) {
			System.out.print(res.get(i)+" ");
		}
	}
	static class gap implements Comparable<gap> {
		int t1,t2;
		long minleft,max,q;
		
		gap(int t1, int t2, long minleft) {
			this.t1=t1;
			this.t2=t2;
			this.minleft=minleft;
			
			if(t1!=Integer.MIN_VALUE&&t2!=Integer.MIN_VALUE) {
				max=(t2-t1)/2;
				if((t2-t1)%2==0) q=1;
				else q=2;
			}
		}
		
		@Override
		public int compareTo(gap o) {
			return Long.compare(minleft,o.minleft);
		}
	}
}