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

public class Main {

    public static void main(String[] args) throws IOException {
        Reader in = new Reader();
        int n = in.nextInt();
        int m = in.nextInt();
        PrintWriter out = new PrintWriter(System.out);

        LinkedList<Integer> ids = new LinkedList<>();
        LinkedList<Integer> dists = new LinkedList<>();
        HashSet<Integer> vis = new HashSet<>();

        for (int i = 0; i < n; i++) {
            int x = in.nextInt();
            ids.offer(x);
            dists.offer(0);
            vis.add(x);
        }

        int[] res = new int[m];
        long distSum = 0;

        // bfs each tree once
        for (int i = 0; i < n; i++) {
            int id = ids.poll();
            int dist = dists.poll();

            if (id != (-2e9) && !vis.contains(id-1)) {
                ids.offer(id-1);
                dists.offer(dist+1);
                vis.add(id-1);
            }
            if (id != (2e9) && !vis.contains(id+1)) {
                ids.offer(id+1);
                dists.offer(dist+1);
                vis.add(id+1);
            }
        }

        // bfs m iterations
        for (int i = 0; i < m; i++) {
            int id = ids.poll();
            int dist = dists.poll();

            if (id != (-2e9) && !vis.contains(id-1)) {
                ids.offer(id-1);
                dists.offer(dist+1);
                vis.add(id-1);
            }
            if (id != (2e9) && !vis.contains(id+1)) {
                ids.offer(id+1);
                dists.offer(dist+1);
                vis.add(id+1);
            }

            res[i] = id;
            distSum += dist;
        }

        out.println(distSum);
        for (int i = 0; i < m; i++) {
            if (i > 0) {
                out.print(' ');
            }
            out.print(res[i]);
        }
        out.println('\n');
        out.flush();
        out.close();
    }

    static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

    }
}
/*

 */