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.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
//import java.math.*;
 
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
 
public class Main {
	
	static int MD= 998244353 ;
	static int N=300000;
    public static void main(String[] args) throws IOException {
    	OutputStream outputStream = System.out;
        InputReader in = new InputReader();
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
   

	static class TaskC {
    	 
	    public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
	    	 
	    	int t=1;
	    	while(t-->0) { 
	    		int n=in.nextInt();
	    		int m=in.nextInt();
	    		int[] a=new int[n];
	    		for(int i=0;i<n;i++) {
	    			a[i]=in.nextInt();
	    		}
	    		Queue<Integer> q=new LinkedList<>();
	    		HashMap<Integer,Integer> map=new HashMap<>();
	    		for(int i=0;i<n;i++) {
	    			map.put(a[i], 0);
	    			q.add(a[i]);
	    		}
	    		long ans=0;
	    		ArrayList<Integer> res=new ArrayList<>();
	    		while(!q.isEmpty()) {
	    			if(res.size()==m) {
	    				break;
	    			}
	    			int cur=q.peek();
	    			q.poll();
	    			if(map.get(cur)!=0) {
	    				ans+=map.get(cur);
	    				res.add(cur);
	    			}
	    			if(map.containsKey(cur-1)==false) {
	    				map.put(cur-1, map.get(cur)+1);
	    				q.add(cur-1);
	    			}
	    			if(map.containsKey(cur+1)==false) {
	    				map.put(cur+1, map.get(cur)+1);
	    				q.add(cur+1);
	    			}
	    			
	    		}
	    		out.println(ans);
	    		for(int i=0;i<m;i++) {
	    			out.print(res.get(i)+" ");
	    		}
	    		out.println();
	    	}
	    }
	    	
	}
	   
	
    
    static long modexp(long x, long n) 
    { 
        if (n == 0) { 
            return 1; 
        } 
        else if (n % 2 == 0) { 
            return modexp((x * x) % MD, n / 2); 
        } 
        else { 
            return (x * modexp((x * x) % MD, (n - 1) / 2) % MD); 
        } 
    } 
      
     static long getInv(long b) 
    { 
      
        long  d = modexp(b, MD - 2); 
      
        long ans =  (d % MD) ;
      
        return ans; 
    } 
    
    static class InputReader
    {
        BufferedReader br;
        StringTokenizer st;
 
        public InputReader()
        {
            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());
        }
 
        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    
    }
    static void sort(int[] a, int low, int high) 
    {
        int N = high - low;         
        if (N <= 1) 
            return; 
        int mid = low + N/2; 
        sort(a, low, mid); 
        sort(a, mid, high); 
        int[] temp = new int[N];
        int i = low, j = mid;
        for (int k = 0; k < N; k++) 
        {
            if (i == mid)  
                temp[k] = a[j++];
            else if (j == high) 
                temp[k] = a[i++];
            else if (a[j]<a[i]) 
                temp[k] = a[j++];
            else 
                temp[k] = a[i++];
        }    
        for (int k = 0; k < N; k++) 
            a[low + k] = temp[k];         
    }
    static void lsort(long[] a, int low, int high) 
    {
        int N = high - low;         
        if (N <= 1) 
            return; 
        int mid = low + N/2; 
        lsort(a, low, mid); 
        lsort(a, mid, high); 
        long[] temp = new long[N];
        int i = low, j = mid;
        for (int k = 0; k < N; k++) 
        {
            if (i == mid)  
                temp[k] = a[j++];
            else if (j == high) 
                temp[k] = a[i++];
            else if (a[j]<a[i]) 
                temp[k] = a[j++];
            else 
                temp[k] = a[i++];
        }    
        for (int k = 0; k < N; k++) 
            a[low + k] = temp[k];         
    }
    public static long fexp(long x, long y, long p) {
        long res = 1;      
        
       
        x = x % p;  
      
        while (y > 0) 
        { 
         
            if((y & 1)==1) 
                res = (res * x) % p; 
      
          
            y = y >> 1;  
            x = (x * x) % p;  
        } 
        return res; 
        
    }
    static int gcd(int a, int b) 
    { 
        if (b == 0) 
            return a; 
        return gcd(b, a % b);  
          
    }
    static long lgcd(long a, long b) 
    { 
        if (b == 0) 
            return a; 
        return lgcd(b, a % b);  
          
    }
   
	
	
}
 
