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 
// Working program using Reader Class 
import java.io.*; 
import java.io.FileInputStream; 
import java.io.IOException; 
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*; 

public class Main 
{ 
	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 Reader(String file_name) throws IOException 
		{ 
			din = new DataInputStream(new FileInputStream(file_name)); 
			buffer = new byte[BUFFER_SIZE]; 
			bufferPointer = bytesRead = 0; 
		} 

		public String readLine() throws IOException 
		{ 
			byte[] buf = new byte[64]; // line length 
			int cnt = 0, c; 
			while ((c = read()) != -1) 
			{ 
				if (c == '\n') 
					break; 
				buf[cnt++] = (byte) c; 
			} 
			return new String(buf, 0, cnt); 
		} 

		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; 
		} 

		public long nextLong() throws IOException 
		{ 
			long 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; 
		} 

		public double nextDouble() throws IOException 
		{ 
			double ret = 0, div = 1; 
			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 (c == '.') 
			{ 
				while ((c = read()) >= '0' && c <= '9') 
				{ 
					ret += (c - '0') / (div *= 10); 
				} 
			} 

			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++]; 
		} 

		public void close() throws IOException 
		{ 
			if (din == null) 
				return; 
			din.close(); 
		} 
	} 
	 
	public static int gcd(int a, int b) 
    { 
        // Everything divides 0  
        if (a == 0 || b == 0) 
           return 0; 
       
        // base case 
        if (a == b) 
            return a; 
       
        // a is greater 
        if (a > b) 
            return gcd(a-b, b); 
        return gcd(a, b-a); 
    }
	
	public static class Node implements Comparable<Node>{
		long center;
		long min;
		long max;
		Node(long c){
			center=c;
			min=c;
			max=c;
		}
		@Override
		public int compareTo(Node n2) {
			if(this.center>n2.center) {
				return 1;
			}
			else {
				return -1;
			}
		}
	}
	
	public static class Node1{
		long diff;
		int index;
		boolean min;
		Node1(long d,int i,boolean m){
			diff=d;
			index=i;
			min=m;
		}
	}
	
	public static long maxValue=2*(long)Math.pow(10, 9);
	
	public static void main(String[] args) throws IOException 
	{ 
		//Reader scan=new Reader(); 
		Reader scan=new Reader();
		PrintWriter out=new PrintWriter(System.out);
		int n=scan.nextInt();
		int m=scan.nextInt();
		ArrayList<Node> al=new ArrayList<Node>();
		for(int i=0;i<n;i++) {
			al.add(new Node(scan.nextLong()));
		}
		Collections.sort(al);
		Comparator<Node1> cmp=new Comparator<Node1>() {

			@Override
			public int compare(Node1 arg0, Node1 arg1) {
				// TODO Auto-generated method stub
				if(arg0.diff>arg1.diff) {
					return 1;
				}
				else if(arg0.diff<arg1.diff) {
					return -1;
				}
				else {
					return arg0.index-arg1.index;
				}
			}
			
		};
		PriorityQueue<Node1> pq=new PriorityQueue<Node1>(cmp);
		for(int i=0;i<n;i++) {
			if(i==0) {
				al.get(i).min--;
				if(al.get(i).min>=-maxValue) {
					pq.add(new Node1(Math.abs(al.get(i).center-al.get(i).min),i,true));
				}
			}
			else {
				if(al.get(i).center-1L!=al.get(i-1).max) {
					al.get(i).min--;
					if(al.get(i).min>=-maxValue) {
						pq.add(new Node1(Math.abs(al.get(i).center-al.get(i).min),i,true));
					}
				}
			}
			if(i==n-1) {
				al.get(i).max++;
				if(al.get(i).max<=maxValue) {
					pq.add(new Node1(Math.abs(al.get(i).center-al.get(i).max),i,false));
				}
			}
			else {
				if(al.get(i).center+1L!=al.get(i+1).center) {
					al.get(i).max++;
					if(al.get(i).max<=maxValue) {
						pq.add(new Node1(Math.abs(al.get(i).center-al.get(i).max),i,false));
					}
				}
			}
		}
		ArrayList<Long> output=new ArrayList<Long>();
		long ans=0L;
		for(int i=0;i<m;i++) {
			Node1 nd1=pq.poll();
			ans+=nd1.diff;
			if(nd1.min==true) {
				output.add(al.get(nd1.index).min);
				if(nd1.index==0) {
					al.get(nd1.index).min--;
					if(al.get(nd1.index).min>=-maxValue) {
						pq.add(new Node1(Math.abs(al.get(nd1.index).center-al.get(nd1.index).min),nd1.index,true));
					}
				}
				else {
					if(al.get(nd1.index).min-1L!=al.get(nd1.index-1).max) {
						al.get(nd1.index).min--;
						if(al.get(nd1.index).min>=-maxValue) {
							pq.add(new Node1(Math.abs(al.get(nd1.index).center-al.get(nd1.index).min),nd1.index,true));
						}
					}
				}
			}
			else {
				output.add(al.get(nd1.index).max);
				if(nd1.index==n-1) {
					al.get(nd1.index).max++;
					if(al.get(nd1.index).max<=maxValue) {
						pq.add(new Node1(Math.abs(al.get(nd1.index).center-al.get(nd1.index).max),nd1.index,false));
					}
				}
				else {
					if(al.get(nd1.index).max+1L!=al.get(nd1.index+1).min) {
						al.get(nd1.index).max++;
						if(al.get(nd1.index).max<=maxValue) {
							pq.add(new Node1(Math.abs(al.get(nd1.index).center-al.get(nd1.index).max),nd1.index,false));
						}
					}
				}
			}
		}
		out.println(ans);
		for(long i : output) {
			out.print(i+" ");
		}
		out.close();
	} 
}