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.HashMap;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class d {
	
	public static void main(String[] args)
	{
		Scanner s=new Scanner(System.in);
		StringBuilder sb=new StringBuilder();
    int n=s.nextInt();
    int k=s.nextInt();
    int[] arr=new int[n];
    
    for(int i=0;i<n;i++) {
    	arr[i]=s.nextInt();
    	
    }
    
    Queue<pair> q=new LinkedList<>();
    HashMap<Integer,Integer> map=new HashMap<>();
    for(int i=0;i<n;i++) {
    pair ob=new pair(arr[i],arr[i]);
    	q.add(ob);
    	map.put(arr[i], 1);
    }
    long sum=0;
    int count=0;
    while(!q.isEmpty()){
    	
    	pair h=q.poll();
         if(count<k) {
    	if(!map.containsKey(h.a+1)) {
    		
    	sb.append(h.a+1+" ");
    		sum=sum+(Math.abs(h.b-h.a-1));
    		map.put(h.a+1, 1);
    		pair kl=new pair(h.a+1,h.b);
    		q.add(kl);
    		 
    		count++;
    	}
         }else {
        	 break;
         }
         if(count<k) {
    	if(!map.containsKey(h.a-1)) {
    		sb.append(h.a-1+" ");
    		map.put(h.a-1, 1);
    		sum=sum+(Math.abs(h.b-h.a+1));
    		pair kl=new pair(h.a-1,h.b);
    		q.add(kl);
    		count++;
    		  
    	}
    	
    	
         }else {
        	 break;
         }
    
    }
    
  
		System.out.println(sum);
		System.out.println(sb);
	}
}
class pair{
	int a;
	int b;
	public pair(int a,int b) {
		this.a=a;
		this.b=b;
	}
}