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.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

public class problem4 {
    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokenizer = new StringTokenizer(reader.readLine());
        int n = Integer.parseInt(tokenizer.nextToken());
        int m = Integer.parseInt(tokenizer.nextToken());
        ArrayList<Integer> x = new ArrayList<>();
        tokenizer = new StringTokenizer(reader.readLine());
        for (int i = 0; i < n; i++) {
            x.add(Integer.parseInt(tokenizer.nextToken()));
        }
        Collections.sort(x);
        int[] y = new int[m];
        int[] left = new int[n];
        int[] right = new int[n];
        TreeSet<Integer> left_set = new TreeSet<>();
        TreeSet<Integer> right_set = new TreeSet<>();
        for (int i = 0; i < n; i++) {
            if(i == 0){
                left[i] = 1;
                if(i + 1 < n){
                    if(x.get(i + 1) != x.get(i) + 1){
                        right[i] = 1;
                    }else{
                        right[i] = -1;
                    }
                }else{
                    right[i] = 1;
                }

            } else if(i == n - 1){
                if(x.get(i - 1) != x.get(i) - 1){
                    left[i] = 1;
                }else{
                    left[i] = -1;
                }
                right[i] = 1;
            }else{
                if(x.get(i - 1) != x.get(i) - 1){
                    left[i] = 1;
                }else{
                    left[i] = -1;
                }
                if(x.get(i+1) != x.get(i) + 1){
                    right[i] = 1;
                }else{
                    right[i] = -1;
                }
            }
            if(left[i] != -1){
                left_set.add(i);
            }
            if(right[i] != -1){
                right_set.add(i);
            }
        }
        int i = 0;
        long result = 0;
        int dist_left = 1;
        int dist_right = 1;
        Integer key_left = left_set.first();
        Integer key_right = right_set.first();
        while (i != m){
            if(key_left == null){
                dist_left++;
                key_left = left_set.first();
            }
            if(key_right == null){
                dist_right++;
                key_right = right_set.first();
            }
            if(dist_left < dist_right){
                int index = key_left;
                y[i] = x.get(index) - dist_left;
                result += dist_left;
                if(index != 0) {
                    if ((x.get(index - 1) + right[index - 1]) == (x.get(index) - left[index])) {
                        right[index - 1] = -1;
                        if(key_right == index - 1){
                            int tmp = key_right;
                            key_right = right_set.higher(key_right);
                            right_set.remove(tmp);
                        }else{
                            right_set.remove(index - 1);
                        }
                        left[index] = -1;
                        int tmp = key_left;
                        key_left = left_set.higher(key_left);
                        left_set.remove(tmp);
                    } else {
                        left[index]++;
                    }
                }else{
                    left[index]++;
                }
                if(left[index] != -1) {
                    key_left = left_set.higher(key_left);
                }
            }else{
                Integer index = key_right;
                y[i] = x.get(index) + dist_right;
                result += dist_right;
                if(index != n - 1) {
                    if ((x.get(index) + right[index]) == (x.get(index + 1) - left[index + 1])) {
                        right[index] = -1;
                        int tmp = key_right;
                        key_right = right_set.higher(key_right);
                        right_set.remove(tmp);


                        if(key_left == index + 1){
                            tmp = key_left;
                            key_left = left_set.higher(key_left);
                            left_set.remove(tmp);
                        }else{
                            left_set.remove(index + 1);
                        }
                        left[index + 1] = -1;
                    } else {
                        right[index]++;
                    }
                }else{
                    right[index]++;
                }
                if(right[index] != -1) {
                    key_right = right_set.higher(key_right);
                }
            }
            i++;
        }
        System.out.println(result);
        for (int j = 0; j < m; j++) {
            System.out.print(y[j]+" ");
        }

    }

}
