Problem: The New Vasjuki village is stretched along the motorway and that's why every house on it is characterized by its shift relative to some fixed point — the xi coordinate. The village consists of n houses, the i-th house is located in the point with coordinates of xi.

TELE3, a cellular communication provider planned to locate three base stations so as to provide every house in the village with cellular communication. The base station having power d located in the point t provides with communication all the houses on the segment [t - d, t + d] (including boundaries).

To simplify the integration (and simply not to mix anything up) all the three stations are planned to possess the equal power of d. Which minimal value of d is enough to provide all the houses in the village with cellular communication.

Input

The first line contains an integer n (1 ≤ n ≤ 2·105) which represents the number of houses in the village. The second line contains the coordinates of houses — the sequence x1, x2, ..., xn of integer numbers (1 ≤ xi ≤ 109). It is possible that two or more houses are located on one point. The coordinates are given in a arbitrary order.

Output

Print the required minimal power d. In the second line print three numbers — the possible coordinates of the base stations' location. Print the coordinates with 6 digits after the decimal point. The positions of the stations can be any from 0 to 2·109 inclusively. It is accepted for the base stations to have matching coordinates. If there are many solutions, print any of them.

Examples

Input

4
1 2 3 4


Output

0.500000
1.500000 2.500000 3.500000


Input

3
10 20 30


Output

0
10.000000 20.000000 30.000000


Input

5
10003 10004 10001 10002 1


Output

0.500000
1.000000 10001.500000 10003.500000

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.fill;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.sort;

public class Main {
	public static void main(String[] args) throws IOException {
		new Thread(null, new Runnable() {
			public void run() {
				try {
					try {
						if (new File("input.txt").exists())
							System.setIn(new FileInputStream("input.txt"));
					} catch (SecurityException e) {}
					new Main().run();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}, "1", 1L << 24).start(); 
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");
	
	int N;
	long[] x;
	
	long min;
	long max;
	
	long cx1;
	long cx2;
	long cx3;
	
	long ax1;
	long ax2;
	long ax3;
	
	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		
		N = nextInt();
		x = new long [N];
		min = Long.MAX_VALUE;
		max = Long.MIN_VALUE;
		for (int i = 0; i < N; i++) {
			x[i] = nextLong() * 2;
			min = min(min, x[i]);
			max = max(max, x[i]);
		}
		sort(x);
		
		long lt = 0L;
		long rt = max - min;
		long ans = 0L;
		ax1 = ax2 = ax3 = (max + min) / 2;
		
		while (lt <= rt) {
			long md = (lt + rt) >> 1;
			if (can(md)) {
				ans = md;
				ax1 = cx1;
				ax2 = cx2;
				ax3 = cx3;
				rt = md - 1L;
			} else {
				lt = md + 1L;
			}
		}
		
		out.printf(Locale.US, "%.6f%n%.6f %.6f %.6f%n", ans * 0.5, ax1 * 0.5, ax2 * 0.5, ax3 * 0.5);
		out.close();
	}
	
	boolean can(long d) {
		cx1 = min + d;
		cx2 = max - d;
		long cmin = max;
		long cmax = min;
		for (int i = 0; i < N; i++) {
			if (uncovered(x[i], d)) {
				cmin = min(cmin, x[i]);
				cmax = max(cmax, x[i]);
			}
		}
		if (cmin == max && cmax == min) {
			cx3 = cx2;
			return true;
		}
		if (cmax - cmin <= d + d) {
			cx3 = (cmax + cmin) / 2;
			return true;
		}
		return false;
	}

	boolean uncovered(long x, long d) {
		return cx1 + d < x && x < cx2 - d;
	}

	String nextToken() throws IOException {
		while (!st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		
		return st.nextToken();
	}
	
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			
			if (s == null) {
				return true;
			}
			
			st = new StringTokenizer(s);
		}
		
		return false;
	}
}