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 
    /*
    If you want to aim high, aim high
    Don't let that studying and grades consume you
    Just live life young
    ******************************
    If I'm the sun, you're the moon
    Because when I go up, you go down
    *******************************
    */
    import java.util.*;
    import java.io.*;
     
       public class D2
       {
          public static void main(String args[]) throws Exception
          {
             BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));  
             StringTokenizer st = new StringTokenizer(infile.readLine());
             int N = Integer.parseInt(st.nextToken());
             int M = Integer.parseInt(st.nextToken());
             Integer[] arr = readArr(N, infile, st);
             Arrays.sort(arr);
             ArrayList<Integer> ls = new ArrayList<Integer>();
             HashSet<Integer> set = new HashSet<Integer>();
             for(int x: arr)
                set.add(x);
             //solve
             Queue<Integer> q = new LinkedList<Integer>();
             for(int x: arr)
                q.add(x);
             while(q.size() > 0) //lol
             {
                int tree = q.poll();
                if(!set.contains(tree-1))
                {
                   set.add(tree-1);
                   ls.add(tree-1);
                   q.add(tree-1);
                }
                if(ls.size() == M)
                   break;
                if(!set.contains(tree+1))
                {
                   set.add(tree+1);
                   ls.add(tree+1);
                   q.add(tree+1);
                }
                if(ls.size() == M)
                   break;
             }
             //find res
             TreeSet<Integer> bst = new TreeSet<Integer>();
             for(int x: arr)
                bst.add(x);
             long res = 0L;
             for(int x: ls)
                res += find(bst, x);
             System.out.println(res);
             StringBuilder sb = new StringBuilder();
             for(int x: ls)
                sb.append(x+" ");
             System.out.println(sb);
          }
          public static int find(TreeSet<Integer> bst, int val)
          {
             if(bst.first() > val)
                return bst.first()-val;
             if(bst.last() < val)
                return val-bst.last();
             return Math.min(val-bst.floor(val), bst.ceiling(val)-val);
          }
          public static Integer[] readArr(int N, BufferedReader infile, StringTokenizer st) throws Exception
          {
             Integer[] arr = new Integer[N];
             st = new StringTokenizer(infile.readLine());
             for(int i=0; i < N; i++)
                arr[i] = Integer.parseInt(st.nextToken());
             return arr;
          }
       }