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.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;

public class C {

    static StreamTokenizer st;
    public static void main(String[] args) throws IOException{
        st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int n = nextInt();
        int[]x = new int[n+1];
        for (int i = 1; i <= n; i++) {
            x[i] = nextInt();
        }
        Arrays.sort(x, 1, n+1);
        if (n==1) {
            System.out.printf("%.6f\n", 0.0);
            System.out.printf("%.6f %.6f %.6f", 1.0*x[1], 1.0*x[1], 1.0*x[1]);
            return;
        }
        if (n==2) {
            System.out.printf("%.6f\n", 0.0);
            System.out.printf("%.6f %.6f %.6f", 1.0*x[1], 1.0*x[2], 1.0*x[2]);
            return;
        }
        int k1 = 0, k2 = 0;
        double left_d = 0, right_d = (x[n]-x[1])/2.0;
        for (int step = 1; step <= 100; step++) {
            double midle_d = (left_d+right_d)/2;
            int left = 1, right = n;
            while (left <= right) {
                int midle = (left+right) >> 1;
                if (x[midle]-x[1] > midle_d)
                    right = midle-1;
                else
                    left = midle+1;
            }
            left--;
            k1 = left;
            left = 1; right = n;
            while (left <= right) {
                int midle = (left+right) >> 1;
                if (x[n]-x[midle] > midle_d)
                    left = midle+1;
                else
                    right = midle-1;
            }
            if (x[n]-x[left] > midle_d)
                left++;
            k2 = left;
            if (k2 <= k1)
                right_d = midle_d;
            else {
                double s = x[k2-1]-x[k1+1];
                s = Math.max(s, Math.max(x[k1]-x[1], x[n]-x[k2]));
                if (s <= midle_d)
                    right_d = midle_d;
                else
                    left_d = midle_d;
            }
        }
        System.out.printf("%.6f\n", left_d/2);
        if (k1 > k2) {
            int t = k1;
            k1 = k2;
            k2 = t;
        }
        System.out.printf("%.6f %.6f %.6f", (x[1]+x[k1])/2.0, (x[k1+1]+x[k2-1])/2.0, (x[k2]+x[n])/2.0);
        pw.close();
    }
    
    private static int nextInt() throws IOException{
        st.nextToken();
        return (int) st.nval;
    }

}