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

public class ProblemD {

    public static InputStream inputStream = System.in;

    public static OutputStream outputStream = System.out;

    public static void main(String[] args) {
        MyScanner scanner = new MyScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);

        int n = scanner.nextInt();
        int m = scanner.nextInt();

        Set<Integer> trees = new HashSet<>();
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int x = scanner.nextInt();
            trees.add(x);
            list1.add(x);
            list2.add(x);
        }

        Set<Integer> ans = new HashSet<>();
        boolean finished = false;
        while (true) {
            List<Integer> tmpList1 = new ArrayList<>();
            List<Integer> tmpList2 = new ArrayList<>();
            for (int x : list1) {
                if (!ans.contains(x - 1) && !trees.contains(x - 1)) {
                    ans.add(x - 1);
                    tmpList1.add(x - 1);
                }
                if (ans.size() == m) {
                    finished = true;
                    break;
                }
            }
            if (finished) {
                break;
            }
            for (int x : list2) {
                if (!ans.contains(x + 1) && !trees.contains(x + 1)) {
                    ans.add(x + 1);
                    tmpList2.add(x + 1);
                }
                if (ans.size() == m) {
                    finished = true;
                    break;
                }
            }
            list1 = tmpList1;
            list2 = tmpList2;
            if (finished) {
                break;
            }
        }

        long s = 0;
        TreeSet<Integer> treeSet = new TreeSet<>(trees);
        for (int x : ans) {
            s += getDistance(treeSet, x);
        }

        out.println(s);
        for (int x : ans) {
            out.print(x + " ");
        }


        out.flush();
    }

    private static int getDistance(TreeSet<Integer> trees, int x) {
        Integer a = trees.lower(x);
        Integer b = trees.higher(x);
        if (a == null) {
            return Math.abs(b - x);
        } else if (b == null ){
            return Math.abs(a - x);
        } else {
            return Math.min(Math.abs(a - x), Math.abs(b - x));
        }
    }

    private static class MyScanner {
        private BufferedReader bufferedReader;
        private StringTokenizer stringTokenizer;

        private MyScanner(InputStream inputStream) {
            bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        }

        private String next() {
            while (stringTokenizer == null || !stringTokenizer.hasMoreElements()) {
                try {
                    stringTokenizer = new StringTokenizer(bufferedReader.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return stringTokenizer.nextToken();
        }

        private int nextInt() {
            return Integer.parseInt(next());
        }

        private long nextLong() {
            return Long.parseLong(next());
        }

        private double nextDouble() {
            return Double.parseDouble(next());
        }

        private String nextLine() {
            String str = "";
            try {
                str = bufferedReader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    private static class Pair<F, S> {

        private F first;

        private S second;

        public Pair() {
        }

        public Pair(F first, S second) {
            this.first = first;
            this.second = second;
        }
    }
}
