#include <bits/stdc++.h>

using namespace std;

long long n, A[200009];

bool ok(double x){
	int i = 0 ,num=0;
	while(i<n){
		i = upper_bound(A,A+n,A[i]+2*x)-A;
		num++;
	}
	return num<=3;
}

double binarySearch(){
	double lo=0.0 , mid, hi = 2e+9;
	int i = 100000;
	while(i--){
		mid = (lo+hi)/2;
		if(ok(mid)){
			hi = mid;
		}
		else{
			lo = mid;
		}
	}
	return mid;
}

int main(){
	//freopen("i.in","r", stdin);
	//freopen("o.out","w",stdout);
	cin >> n;
	for(int i = 0 ; i < n ; i++){
		cin >>A[i];
	}
	sort(A,A+n);
	double val = binarySearch();
	cout << fixed << setprecision(6) << val<<"\n";
	int j = 0;
	for(int i = 0 ; i< 3 ; i++){
		j = j>n-1 ? n-1 : j;
		cout << fixed << setprecision(6) << A[j]+val<<" ";
		j = upper_bound(A,A+n,A[j]+(2*val+0.0000001))-A;
	}
	cout << endl;
	return 0;
}


#include <bits/stdc++.h>

using namespace std;
typedef long long ll;

const int N = 2e5+5, OO = 0x3f3f3f3f;
const double EPS = 1e-6;

int n, A[N];

bool ok(double t){
  int currentStart = 0;
  for(int i = 0 ; i < 3 ; ++i){
    currentStart = upper_bound(A, A+n, A[currentStart]+2*t)-A;
    if(currentStart == n) return 1;
  }
  return 0;
}

double binarySearch(){
  double lo = 0, med, hi = 3e9;
  int cnt = 100;
  while(cnt--){
    med = (lo+hi)/2;
    if(ok(med)) hi = med;
    else  lo = med;
  }
  return lo;
}

int main(){
  scanf("%d", &n);
  for(int i = 0 ; i < n ; ++i)  scanf("%d", A+i);
  sort(A, A+n);
  double t;
  printf("%.8lf\n", t = binarySearch());
  int currentStart = 0;
  for(int i = 0 ; i < 3 ; ++i){
    printf("%.8lf ", A[currentStart]+t);
    currentStart = upper_bound(A, A+n, A[currentStart]+2*t+EPS)-A;
  }
  printf("\n");
  return 0;
}

/*
*/


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define X first
#define Y second
#define pb push_back

ll n, x[200005];

bool check(ll m) {
	ll l, r;
	l = x[1];
	ll cnt = 1;
	r = x[1] + m;
	for (ll i = 1; i <= n; ++i) {
		if (x[i] <= r) continue;
		cnt++;
		l = x[i];
		r = x[i] + m;
	}
	if (cnt > 3) return false;
	return true;
}

int main() {
	ios_base::sync_with_stdio(0), cin.tie(0);
	cin >> n;
	for (ll i = 1; i <= n; ++i) {
		cin >> x[i];
	}
	sort(x + 1, x + n + 1);
	if (n == 2) {
		cout << 0 << '\n';
		cout << x[1] << ' ' << x[2] << ' ' << x[2] << '\n';
		return 0;
	}
	if (n == 1) {
		cout << 0 << '\n';
		cout << x[1] << ' ' << x[1] << ' ' << x[1] << '\n';
		return 0;
	}
	ll l = -1, r = 1e10;
	while(r - l > 1) {
		ll m = (l + r) / 2;
		if (check(m))
			r = m;
		else
			l = m;
	}
	ld ans = (ld)r / 2.0;
	cout << fixed << setprecision(7) << ans;
	ld lf = x[1];
	ld rf = x[1] + r;
	cout << '\n';
	cout << lf + (ld)(rf - lf) / (ld)2 << ' ';
	ll cnt = 1;
	for (ll j = 1; j <= n; ++j) {
		if (x[j] <= rf) continue;
		lf = x[j];
		rf = x[j] + r;
		cout << lf + (ld)(rf - lf) / (ld)2 << ' ';
		++cnt;
	}
	for (ll i = cnt; i < 3; ++i) cout << 0 << ' ';
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define X first
#define Y second
#define pb push_back

ll n, x[200005];

bool check(ll m) {
	ll l, r;
	l = x[1];
	ll cnt = 1;
	r = x[1] + m;
	for (ll i = 1; i <= n; ++i) {
		if (x[i] <= r) continue;
		cnt++;
		l = x[i];
		r = x[i] + m;
	}
	if (cnt > 3) return false;
	return true;
}

int main() {
	ios_base::sync_with_stdio(0), cin.tie(0);
	cin >> n;
	for (ll i = 1; i <= n; ++i) {
		cin >> x[i];
	}
	sort(x + 1, x + n + 1);
	if (n == 2) {
		cout << 0 << '\n';
		cout << x[1] << ' ' << x[2] << ' ' << x[2] << '\n';
		return 0;
	}
	if (n == 1) {
		cout << 0 << '\n';
		cout << x[1] << ' ' << x[1] << ' ' << x[1] << '\n';
	}
	ll l = -1, r = 1e10;
	while(r - l > 1) {
		ll m = (l + r) / 2;
		if (check(m))
			r = m;
		else
			l = m;
	}
	ld ans = (ld)r / 2.0;
	cout << fixed << setprecision(7) << ans;
	ld lf = x[1];
	ld rf = x[1] + r;
	cout << '\n';
	cout << lf + (ld)(rf - lf) / (ld)2 << ' ';
	ll cnt = 1;
	for (ll j = 1; j <= n; ++j) {
		if (x[j] <= rf) continue;
		lf = x[j];
		rf = x[j] + r;
		cout << lf + (ld)(rf - lf) / (ld)2 << ' ';
		++cnt;
	}
	for (ll i = cnt; i < 3; ++i) cout << 0 << ' ';
	return 0;
}


/* */

#include <cstdio>
#include <cstring>
#include <cassert>
#include <cmath>
#include <string>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <bitset>
#include <map>
#include <set>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using pll = pair<ll, ll>;

#ifdef XVENOM
	#define errp(...) fprintf(stderr, __VA_ARGS__)
#else
	#define errp(...)
#endif
#define dbg(x) errp(" %s = %s\n", #x, to_string(x).data())
#define dbg_al(s, x) for(auto e:x)s+=to_string(e)+" "
#define dbg_rt(x) string s="[ ";dbg_al(s,x);s+="]";return s;
#define dbg_fd1 template<typename T>string to_string
#define dbg_fd2 template<typename U, typename V>string to_string
#define dbg_d1(c) dbg_fd1(c<T>);
#define dbg_d2(c) dbg_fd2(c<U, V>);
#define dbg_f1(c) dbg_fd1(c<T> v){dbg_rt(v);}
#define dbg_f2(c) dbg_fd2(c<U, V> v){dbg_rt(v);}
string to_string (char s) { return "\'"+string(1, s)+"\'"; }
string to_string (string s) { return "\"" + s + "\""; }
dbg_d1(vector) dbg_d1(set) dbg_d2(map)
dbg_fd2(pair<U, V> p) { return "("+to_string(p.first)+", "+to_string(p.second)+")"; }
dbg_f1(vector) dbg_f1(set) dbg_f2(map)
/* ==================== */
const int N = 200010;
const double EPS = 1e-9;
int x[N], n;
double c1, c2, c3;

bool can (double d) {
	d *= 2;
	int i = 0, j;
	for (j = 0; j < n && x[j] - x[i] < d + EPS; j++);
	c1 = (x[0] + x[j - 1]) / 2.0;
	i = j;
	for (j = i; j < n && x[j] - x[i] < d + EPS; j++);
	c2 = (i == n) ? 0.0 : (x[i] + x[j - 1]) / 2.0;
	i = j;
	for (j = i; j < n && x[j] - x[i] < d + EPS; j++);
	c3 = (i == n) ? 0.0 : (x[i] + x[j - 1]) / 2.0;
	return j == n && (i == n || x[j - 1] - x[i] < d + EPS);
}

double solve() {
	double lo = 0.0, hi = x[n - 1] - x[0], mid;
	while (abs(hi - lo) > 1e-6) {
		dbg(hi); dbg(lo);
		mid = (hi + lo) / 2.0;
		if (can(mid)) hi = mid;
		else lo = mid;
	}
	return hi;
}

int main() {
	scanf("%d", &n);
	for (int i = 0; i < n; i++) scanf("%d", &x[i]);
	sort(x, x + n);
	double ans = solve();
	assert(can(ans));
	printf("%f\n", ans);
	printf("%f %f %f\n", c1, c2, c3);
}


/* */

#include <cstdio>
#include <cstring>
#include <cassert>
#include <cmath>
#include <string>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <bitset>
#include <map>
#include <set>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using pll = pair<ll, ll>;

#ifdef XVENOM
	#define errp(...) fprintf(stderr, __VA_ARGS__)
#else
	#define errp(...)
#endif
#define dbg(x) errp(" %s = %s\n", #x, to_string(x).data())
#define dbg_al(s, x) for(auto e:x)s+=to_string(e)+" "
#define dbg_rt(x) string s="[ ";dbg_al(s,x);s+="]";return s;
#define dbg_fd1 template<typename T>string to_string
#define dbg_fd2 template<typename U, typename V>string to_string
#define dbg_d1(c) dbg_fd1(c<T>);
#define dbg_d2(c) dbg_fd2(c<U, V>);
#define dbg_f1(c) dbg_fd1(c<T> v){dbg_rt(v);}
#define dbg_f2(c) dbg_fd2(c<U, V> v){dbg_rt(v);}
string to_string (char s) { return "\'"+string(1, s)+"\'"; }
string to_string (string s) { return "\"" + s + "\""; }
dbg_d1(vector) dbg_d1(set) dbg_d2(map)
dbg_fd2(pair<U, V> p) { return "("+to_string(p.first)+", "+to_string(p.second)+")"; }
dbg_f1(vector) dbg_f1(set) dbg_f2(map)
/* ==================== */
/* binary search solution */
//const int N = 200010;
//const double EPS = 1e-9;
//int x[N], n;
//double c1, c2, c3;
//
//bool can (double d) {
//	d *= 2;
//	int i = 0, j;
//	for (j = 0; j < n && x[j] - x[i] < d + EPS; j++);
//	c1 = (x[0] + x[j - 1]) / 2.0;
//	i = j;
//	for (j = i; j < n && x[j] - x[i] < d + EPS; j++);
//	c2 = (i == n) ? 0.0 : (x[i] + x[j - 1]) / 2.0;
//	i = j;
//	for (j = i; j < n && x[j] - x[i] < d + EPS; j++);
//	c3 = (i == n) ? 0.0 : (x[i] + x[j - 1]) / 2.0;
//	return j == n && (i == n || x[j - 1] - x[i] < d + EPS);
//}
//
//double solve() {
//	double lo = 0.0, hi = x[n - 1] - x[0], mid;
//	while (abs(hi - lo) > 1e-6) {
//		dbg(hi); dbg(lo);
//		mid = (hi + lo) / 2.0;
//		if (can(mid)) hi = mid;
//		else lo = mid;
//	}
//	return hi;
//}
//
//int main() {
//	scanf("%d", &n);
//	for (int i = 0; i < n; i++) scanf("%d", &x[i]);
//	sort(x, x + n);
//	double ans = solve();
//	assert(can(ans));
//	printf("%f\n", ans);
//	printf("%f %f %f\n", c1, c2, c3);
//}
/* ======================================== */
const int N = 200010;
int x[N], n, f[N], g[N];

int main() {
	scanf("%d", &n);
	for (int i = 0; i < n; i++) scanf("%d", &x[i]);
	sort(x, x + n);

	int mid = 0;
	f[0] = g[0] = 0;
	for (int i = 1; i < n; i++) {
		while (x[mid] - x[0] < x[i] - x[mid + 1]) mid++;
		f[i] = max(x[mid] - x[0], x[i] - x[mid + 1]);
		int t = max(x[mid - 1] - x[0], x[i] - x[mid]);
		if (t < f[i]) {
			f[i] = t;
			mid--;
		}
		g[i] = mid;
	}
	int ans = x[n - 1] - x[0] + 1, k;
	for (int i = 0; i < n - 1; i++) {
		int t = max(f[i], x[n - 1] - x[i + 1]);
		if (t < ans) {
			ans = t;
			k = i;
		}
	}
	printf("%f\n", ans / 2.0);
	printf("%f %f %f\n", (
		x[g[k]] + x[0]) / 2.0,
		(x[k] + x[g[k] + 1]) / 2.0,
		(x[n - 1] + x[k + 1]) / 2.0
	);

}


/* */

#include <cstdio>
#include <cstring>
#include <cassert>
#include <cmath>
#include <string>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <bitset>
#include <map>
#include <set>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using pll = pair<ll, ll>;

#ifdef XVENOM
	#define errp(...) fprintf(stderr, __VA_ARGS__)
#else
	#define errp(...)
#endif
#define dbg(x) errp(" %s = %s\n", #x, to_string(x).data())
#define dbg_al(s, x) for(auto e:x)s+=to_string(e)+" "
#define dbg_rt(x) string s="[ ";dbg_al(s,x);s+="]";return s;
#define dbg_fd1 template<typename T>string to_string
#define dbg_fd2 template<typename U, typename V>string to_string
#define dbg_d1(c) dbg_fd1(c<T>);
#define dbg_d2(c) dbg_fd2(c<U, V>);
#define dbg_f1(c) dbg_fd1(c<T> v){dbg_rt(v);}
#define dbg_f2(c) dbg_fd2(c<U, V> v){dbg_rt(v);}
string to_string (char s) { return "\'"+string(1, s)+"\'"; }
string to_string (string s) { return "\"" + s + "\""; }
dbg_d1(vector) dbg_d1(set) dbg_d2(map)
dbg_fd2(pair<U, V> p) { return "("+to_string(p.first)+", "+to_string(p.second)+")"; }
dbg_f1(vector) dbg_f1(set) dbg_f2(map)
/* ==================== */
/* binary search solution */
//const int N = 200010;
//const double EPS = 1e-9;
//int x[N], n;
//double c1, c2, c3;
//
//bool can (double d) {
//	d *= 2;
//	int i = 0, j;
//	for (j = 0; j < n && x[j] - x[i] < d + EPS; j++);
//	c1 = (x[0] + x[j - 1]) / 2.0;
//	i = j;
//	for (j = i; j < n && x[j] - x[i] < d + EPS; j++);
//	c2 = (i == n) ? 0.0 : (x[i] + x[j - 1]) / 2.0;
//	i = j;
//	for (j = i; j < n && x[j] - x[i] < d + EPS; j++);
//	c3 = (i == n) ? 0.0 : (x[i] + x[j - 1]) / 2.0;
//	return j == n && (i == n || x[j - 1] - x[i] < d + EPS);
//}
//
//double solve() {
//	double lo = 0.0, hi = x[n - 1] - x[0], mid;
//	while (abs(hi - lo) > 1e-6) {
//		dbg(hi); dbg(lo);
//		mid = (hi + lo) / 2.0;
//		if (can(mid)) hi = mid;
//		else lo = mid;
//	}
//	return hi;
//}
//
//int main() {
//	scanf("%d", &n);
//	for (int i = 0; i < n; i++) scanf("%d", &x[i]);
//	sort(x, x + n);
//	double ans = solve();
//	assert(can(ans));
//	printf("%f\n", ans);
//	printf("%f %f %f\n", c1, c2, c3);
//}
/* ======================================== */
const int N = 200010;
int x[N], n, f[N], g[N];
double r1, r2, r3;

double solve() {
	if (n == 1) {
		r1 = r2 = r3 = x[0];
		return 0.0;
	}
	int ans = x[n - 1] - x[0] + 1, k;
	for (int i = 0; i < n - 1; i++) {
		int t = max(f[i], x[n - 1] - x[i + 1]);
		if (t < ans) {
			ans = t;
			k = i;
		}
	}
	r1 = (x[g[k]] + x[0]) / 2.0;
	r2 = (x[k] + x[g[k] + 1]) / 2.0;
	r3 = (x[n - 1] + x[k + 1]) / 2.0;
	return ans / 2.0;
}

int main() {
	int z;
	set<int> s;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &z);
		s.insert(z);
	}
	n = 0;
	for (int w : s) x[n++] = w;
	assert(is_sorted(x, x + n));

	f[0] = g[0] = 0;
	for (int i = 1; i < n; i++) {
		g[i] = g[i - 1];
		while (x[g[i]] - x[0] < x[i] - x[g[i] + 1]) g[i]++;
		f[i] = max(x[g[i]] - x[0], x[i] - x[g[i] + 1]);
		int t = max(x[g[i] - 1] - x[0], x[i] - x[g[i]]);
		if (t < f[i]) {
			f[i] = t;
			g[i]--;
		}
	}
	double ans = solve();
	printf("%f\n", ans);
	printf("%f %f %f\n", r1, r2, r3);

}


/* */

#include <cstdio>
#include <cstring>
#include <cassert>
#include <cmath>
#include <string>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <bitset>
#include <map>
#include <set>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using pll = pair<ll, ll>;

#ifdef XVENOM
	#define errp(...) fprintf(stderr, __VA_ARGS__)
#else
	#define errp(...)
#endif
#define dbg(x) errp(" %s = %s\n", #x, to_string(x).data())
#define dbg_al(s, x) for(auto e:x)s+=to_string(e)+" "
#define dbg_rt(x) string s="[ ";dbg_al(s,x);s+="]";return s;
#define dbg_fd1 template<typename T>string to_string
#define dbg_fd2 template<typename U, typename V>string to_string
#define dbg_d1(c) dbg_fd1(c<T>);
#define dbg_d2(c) dbg_fd2(c<U, V>);
#define dbg_f1(c) dbg_fd1(c<T> v){dbg_rt(v);}
#define dbg_f2(c) dbg_fd2(c<U, V> v){dbg_rt(v);}
string to_string (char s) { return "\'"+string(1, s)+"\'"; }
string to_string (string s) { return "\"" + s + "\""; }
dbg_d1(vector) dbg_d1(set) dbg_d2(map)
dbg_fd2(pair<U, V> p) { return "("+to_string(p.first)+", "+to_string(p.second)+")"; }
dbg_f1(vector) dbg_f1(set) dbg_f2(map)
/* ==================== */
/* binary search solution */
//const int N = 200010;
//const double EPS = 1e-9;
//int x[N], n;
//double c1, c2, c3;
//
//bool can (double d) {
//	d *= 2;
//	int i = 0, j;
//	for (j = 0; j < n && x[j] - x[i] < d + EPS; j++);
//	c1 = (x[0] + x[j - 1]) / 2.0;
//	i = j;
//	for (j = i; j < n && x[j] - x[i] < d + EPS; j++);
//	c2 = (i == n) ? 0.0 : (x[i] + x[j - 1]) / 2.0;
//	i = j;
//	for (j = i; j < n && x[j] - x[i] < d + EPS; j++);
//	c3 = (i == n) ? 0.0 : (x[i] + x[j - 1]) / 2.0;
//	return j == n && (i == n || x[j - 1] - x[i] < d + EPS);
//}
//
//double solve() {
//	double lo = 0.0, hi = x[n - 1] - x[0], mid;
//	while (abs(hi - lo) > 1e-6) {
//		dbg(hi); dbg(lo);
//		mid = (hi + lo) / 2.0;
//		if (can(mid)) hi = mid;
//		else lo = mid;
//	}
//	return hi;
//}
//
//int main() {
//	scanf("%d", &n);
//	for (int i = 0; i < n; i++) scanf("%d", &x[i]);
//	sort(x, x + n);
//	double ans = solve();
//	assert(can(ans));
//	printf("%f\n", ans);
//	printf("%f %f %f\n", c1, c2, c3);
//}
/* ======================================== */
const int N = 200010;
int x[N], n, f[N], g[N];

int main() {
	int z;
	set<int> s;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &z);
		s.insert(z);
	}
	n = 0;
	for (int w : s) x[n++] = w;

	f[0] = g[0] = 0;
	for (int i = 1; i < n; i++) {
		g[i] = g[i - 1];
		while (x[g[i]] - x[0] < x[i] - x[g[i] + 1]) g[i]++;
		f[i] = max(x[g[i]] - x[0], x[i] - x[g[i] + 1]);
		int t = max(x[g[i] - 1] - x[0], x[i] - x[g[i]]);
		if (t < f[i]) {
			f[i] = t;
			g[i]--;
		}
	}

	int ans = x[n - 1] - x[0] + 1, k;
	for (int i = 0; i < n - 1; i++) {
		int t = max(f[i], x[n - 1] - x[i + 1]);
		if (t < ans) {
			ans = t;
			k = i;
		}
	}
	printf("%f\n", ans / 2.0);
	printf("%f %f %f\n", (
		x[g[k]] + x[0]) / 2.0,
		(x[k] + x[g[k] + 1]) / 2.0,
		(x[n - 1] + x[k + 1]) / 2.0
	);

}


/* */

#include <cstdio>
#include <cstring>
#include <cassert>
#include <cmath>
#include <string>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <bitset>
#include <map>
#include <set>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using pll = pair<ll, ll>;

#ifdef XVENOM
	#define errp(...) fprintf(stderr, __VA_ARGS__)
#else
	#define errp(...)
#endif
#define dbg(x) errp(" %s = %s\n", #x, to_string(x).data())
#define dbg_al(s, x) for(auto e:x)s+=to_string(e)+" "
#define dbg_rt(x) string s="[ ";dbg_al(s,x);s+="]";return s;
#define dbg_fd1 template<typename T>string to_string
#define dbg_fd2 template<typename U, typename V>string to_string
#define dbg_d1(c) dbg_fd1(c<T>);
#define dbg_d2(c) dbg_fd2(c<U, V>);
#define dbg_f1(c) dbg_fd1(c<T> v){dbg_rt(v);}
#define dbg_f2(c) dbg_fd2(c<U, V> v){dbg_rt(v);}
string to_string (char s) { return "\'"+string(1, s)+"\'"; }
string to_string (string s) { return "\"" + s + "\""; }
dbg_d1(vector) dbg_d1(set) dbg_d2(map)
dbg_fd2(pair<U, V> p) { return "("+to_string(p.first)+", "+to_string(p.second)+")"; }
dbg_f1(vector) dbg_f1(set) dbg_f2(map)
/* ==================== */
const int N = 200010;
const double EPS = 1e-9;
int x[N], n;
double c1, c2, c3;

bool can (double d) {
	d *= 2;
	int i = 0, j;
	for (j = 0; j < n && x[j] - x[i] < d + EPS; j++);
	c1 = (x[0] + x[j - 1]) / 2.0;
	i = j;
	for (j = i; j < n && x[j] - x[i] < d + EPS; j++);
	c2 = (i == n) ? 0.0 : (x[i] + x[j - 1]) / 2.0;
	i = j;
	for (j = i; j < n && x[j] - x[i] < d + EPS; j++);
	c3 = (i == n) ? 0.0 : (x[i] + x[j - 1]) / 2.0;
	return j == n && (i == n || x[j - 1] - x[i] < d + EPS);
}

double solve() {
	double lo = 0.0, hi = x[n - 1] - x[0], mid;
	while (abs(hi - lo) > 1e-9) {
		dbg(hi); dbg(lo);
		mid = (hi + lo) / 2.0;
		if (can(mid)) hi = mid;
		else lo = mid;
	}
	return hi;
}

int main() {
	scanf("%d", &n);
	for (int i = 0; i < n; i++) scanf("%d", &x[i]);
	sort(x, x + n);
	double ans = solve();
	assert(can(ans));
	printf("%f\n", ans);
	printf("%f %f %f\n", c1, c2, c3);
}


/* */

#include <cstdio>
#include <cstring>
#include <cassert>
#include <cmath>
#include <string>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <bitset>
#include <map>
#include <set>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using pll = pair<ll, ll>;

#ifdef XVENOM
	#define errp(...) fprintf(stderr, __VA_ARGS__)
#else
	#define errp(...)
#endif
#define dbg(x) errp(" %s = %s\n", #x, to_string(x).data())
#define dbg_al(s, x) for(auto e:x)s+=to_string(e)+" "
#define dbg_rt(x) string s="[ ";dbg_al(s,x);s+="]";return s;
#define dbg_fd1 template<typename T>string to_string
#define dbg_fd2 template<typename U, typename V>string to_string
#define dbg_d1(c) dbg_fd1(c<T>);
#define dbg_d2(c) dbg_fd2(c<U, V>);
#define dbg_f1(c) dbg_fd1(c<T> v){dbg_rt(v);}
#define dbg_f2(c) dbg_fd2(c<U, V> v){dbg_rt(v);}
string to_string (char s) { return "\'"+string(1, s)+"\'"; }
string to_string (string s) { return "\"" + s + "\""; }
dbg_d1(vector) dbg_d1(set) dbg_d2(map)
dbg_fd2(pair<U, V> p) { return "("+to_string(p.first)+", "+to_string(p.second)+")"; }
dbg_f1(vector) dbg_f1(set) dbg_f2(map)
/* ==================== */
const int N = 200010;
int x[N], n;
double c1, c2, c3;

bool can (double d) {
	dbg(d);
	d *= 2;
	int i = 0, j;
	for (j = 0; j < n && x[j] - x[i] <= d; j++);
	c1 = (x[0] + x[j - 1]) / 2.0;
	i = j;
	for (j = i; j < n && x[j] - x[i] <= d; j++);
	c2 = (x[i] + x[j - 1]) / 2.0;
	i = j;
	for (j = i; j < n && x[j] - x[i] <= d; j++);
	c3 = (x[i] + x[j - 1]) / 2.0;
	dbg(j == n);
	return j == n;
}

double solve() {
	double lo = 0.0, hi = x[n - 1] - x[0], mid;
	while (hi - lo > 1e-9) {
		mid = (hi + lo) / 2.0;
		if (can((hi + lo) / 2.0)) hi = mid;
		else lo = mid;
	}
	return hi;
}

int main() {
	scanf("%d", &n);
	for (int i = 0; i < n; i++) scanf("%d", &x[i]);
	sort(x, x + n);
	printf("%f\n", solve());
	printf("%f %f %f\n", c1, c2, c3);
}


#include<bits/stdc++.h>
using namespace std;

const int N = 2e5 + 55;
const double eps = 1e-12;
int n, a[N];
bool valid(double mid){
  double s1 = mid + a[0], s2, s3;
  int i = 0;
  while(i < n && a[i] < s1 + mid + eps) ++i;
  s2 = a[i] + mid;
  while(i < n && a[i] < s2 + mid + eps) ++i;
  i = min(i, n - 1);
  s3 = a[i] + mid;
  // if(fabs(mid - 11.0000000) < eps && s3 + mid + eps > a[n - 1]) cout << s3 << '\n';
  return s3 + mid + eps > a[n - 1];
}
void printdd(double mid){
  double s1 = mid + a[0], s2, s3;
  int i = 0;
  while(i < n && a[i] < s1 + mid + eps) ++i;
  s2 = a[i] + mid;
  while(i < n && a[i] < s2 + mid + eps) ++i;
  i = min(i, n - 1);
  s3 = a[i] + mid;
  cout << fixed << setprecision(10) <<
   min(2e9 - 3, s1) << ' ' << min(2e9 - 2, s2) << ' ' << min(2e9 - 1, s3) << '\n';
}
int main(){
  ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
   freopen("in.txt", "r", stdin);
#endif // ONLINE_JUDGE
  cin >> n;
  for(int i = 0; i < n; ++i) cin >> a[i];
  sort(a, a + n);
  double l = 0, r = 1e9 + 55;
  int k = 500;
  while(k--){
    double mid = l + (r - l) / 2;
    if(valid(mid)) r = mid;
    else l = mid;
  }
  cout << fixed << setprecision(10) << l << '\n';
  printdd(r);
  return 0;
}


#include<bits/stdc++.h>
using namespace std;

const int N = 2e5 + 55;
const double eps = 1e-12;
int n, a[N];
bool valid(double mid){
  double s1 = mid + a[0];
  double s2, s3;
  int i = 0;
  while(i < n && a[i] < s1 + mid + eps) ++i;
  s2 = a[i] + mid;
  while(i < n && a[i] < s2 + mid + eps) ++i;
  i = min(i, n - 1);
  s3 = a[i] + mid;
  return s3 + mid > a[n - 1];
}
void printdd(double mid){
  double s1 = mid + a[0];
  double s2, s3;
  int i = 0;
  while(i < n && a[i] < s1 + mid + eps) ++i;
  s2 = a[i] + mid;
  while(i < n && a[i] < s2 + mid + eps) ++i;
  i = min(i, n - 1);
  s3 = a[i] + mid;
  cout << fixed << setprecision(10) <<
   min(2e9 - 3, s1) << ' ' << min(2e9 - 2, s2) << ' ' << min(2e9 - 1, s3) << '\n';
}
int main(){
  ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
  // freopen("in.txt", "r", stdin);
#endif // ONLINE_JUDGE
  cin >> n;
  for(int i = 0; i < n; ++i) cin >> a[i];
  sort(a, a + n);
  double l = 0, r = 1e9 + 55;
  int k = 300;
  while(k--){
    double mid = l + (r - l) / 2;
    if(valid(mid)) r = mid;
    else l = mid;
  }
  cout << fixed << setprecision(10) << l << '\n';
  printdd(l);
  return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <iomanip>
using namespace std;
int n,x[100000],i;
double l,r,m,a,b,c;
bool Less(double k){
    a = b = c = x[0] + k;
    for(i = 0; i < n; i++){
        if(x[i] < a - k || a + k < x[i])
            break;
    }
    if(i == n) return false;
    b = x[i] + k;
    for(; i < n; i++){
        if(x[i] < b - k || b + k < x[i])
            break;
    }
    if(i == n) return false;
    c = x[i] + k;
    for(; i < n; i++){
        if(x[i] < c - k || c + k < x[i])
            break;
    }
    if(i == n) return false;
    return true;
}
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    //freopen("input.txt","r",stdin);
    cin >> n;
    for(i = 0; i < n; i++)
        cin >> x[i];
    sort(x, x + n);
    l = 0; r = 1000000000;
    while(r - l > 0.000000001){
        m = (l + r)/2;
        if(Less(m)) l = m;
        else r = m;
    }
    Less(l);
    cout << fixed << setprecision(6) << l << endl;
    cout << fixed << setprecision(6) << a << " " << b << " " << c;
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <iomanip>
#include <ctime>
using namespace std;
int n,i;
double l,r,m,a,b,c,x[300000];
bool Less(double k){
    a = b = c = x[0] + k;
    for(i = 0; i < n; i++){
        if(a + k < x[i])
            break;
    }
    b = x[i] + k;
    for(; i < n; i++){
        if(b + k < x[i])
            break;
    }
    c = x[i] + k;
    for(; i < n; i++){
        if(c + k < x[i])
            break;
    }
    if(i == n) return false;
    return true;
}
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    //freopen("input.txt","r",stdin);
    double t = clock();
    cin >> n;
    for(i = 0; i < n; i++)
        cin >> x[i];
    sort(x, x + n);
    l = 0; r = 1000000000;
    while(clock() - t < 930.0){
        m = (l + r)/2.0;
        if(Less(m)) l = m;
        else r = m;
    }
    Less(r);
    cout << fixed << setprecision(6) << l << endl;
    cout << fixed << setprecision(6) << a << " " << b << " " << c;
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <iomanip>
#include <ctime>
using namespace std;
int n,i;
double l,r,m,a,b,c,x[300000];
bool Less(double k){
    a = b = c = x[0] + k;
    for(i = 0; i < n; i++){
        if(a + k < x[i])
            break;
    }
    if(i == n) return false;
    b = x[i] + k;
    for(; i < n; i++){
        if(b + k < x[i])
            break;
    }
    if(i == n) return false;
    c = x[i] + k;
    for(; i < n; i++){
        if(c + k < x[i])
            break;
    }
    if(i == n) return false;
    return true;
}
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    double t = clock();
    cin >> n;
    for(i = 0; i < n; i++)
        cin >> x[i];
    sort(x, x + n);
    l = 0; r = 1000000000;
    while(clock() - t < 930.0){
        m = (l + r)/2.0;
        if(Less(m)) l = m;
        else r = m;
    }
    Less(r);
    cout << fixed << setprecision(6) << l << endl;
    cout << fixed << setprecision(6) << a << " " << b << " " << c;
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <iomanip>
using namespace std;
int n,i;
double l,r,m,a,b,c,x[100000];
bool Less(double k){
    a = b = c = x[0] + k;
    for(i = 0; i < n; i++){
        if(a + k < x[i])
            break;
    }
    if(i == n) return false;
    b = x[i] + k;
    for(; i < n; i++){
        if(b + k < x[i])
            break;
    }
    if(i == n) return false;
    c = x[i] + k;
    for(; i < n; i++){
        if(c + k < x[i])
            break;
    }
    if(i == n) return false;
    return true;
}
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    //freopen("input.txt","r",stdin);
    cin >> n;
    for(i = 0; i < n; i++)
        cin >> x[i];
    sort(x, x + n);
    l = 0; r = 1000000000;
    while(r - l > 0.00000001){
        m = (l + r)/2.0;
        if(Less(m)) l = m;
        else r = m;
    }
    Less(r);
    cout << fixed << setprecision(6) << l << endl;
    cout << fixed << setprecision(6) << a << " " << b << " " << c;
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <iomanip>
#include <ctime>
using namespace std;
int n,i;
double l,r,m,a,b,c,x[100000];
bool Less(double k){
    a = b = c = x[0] + k;
    for(i = 0; i < n; i++){
        if(a + k < x[i])
            break;
    }
    if(i == n) return false;
    b = x[i] + k;
    for(; i < n; i++){
        if(b + k < x[i])
            break;
    }
    if(i == n) return false;
    c = x[i] + k;
    for(; i < n; i++){
        if(c + k < x[i])
            break;
    }
    if(i == n) return false;
    return true;
}
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    //freopen("input.txt","r",stdin);
    double t = clock();
    cin >> n;
    for(i = 0; i < n; i++)
        cin >> x[i];
    sort(x, x + n);
    l = 0; r = 1000000000;
    while(clock() - t < 930.0){
        m = (l + r)/2.0;
        if(Less(m)) l = m;
        else r = m;
    }
    Less(r);
    cout << fixed << setprecision(6) << l << endl;
    cout << fixed << setprecision(6) << a << " " << b << " " << c;
    return 0;
}


#include "bits/stdc++.h"
#define MOD 1000000007
#define inf 0x3f3f3f3f3f3f3f3f
#define pi acos(-1.0)
#define ri register int
#define int long long
#ifdef ONLINE_JUDGE
const int maxn = 3e5 + 10;
#else
const int maxn = 1e3 + 10;
#endif
using namespace std;
int N, arr[maxn];
vector<double> v;
bool ok(double mid)
{
    double r = mid * 2 + arr[1];
    int i;
    v.clear();
    v.push_back(mid + arr[1]);
    for (i = 1; i <= N; ++i) {
        if (r < arr[i]) {
            break;
        }
    }
    r = arr[i] + mid * 2;
    if (i > N) {
        v.push_back(v[0]);
        v.push_back(v[0]);
        return true;
    }
    v.push_back(arr[i] + mid);
    for (; i <= N; ++i) {
        if (r < arr[i]) {
            break;
        }
    }
    if (i > N) {
        v.push_back(v.back());
        return true;
    }
    r = arr[i] + mid * 2;
    v.push_back(arr[i] + mid);
    for (; i <= N; ++i) {
        if (r < arr[i]) {
            return false;
        }
    }
    return true;
}
signed main()
{
    ios::sync_with_stdio(false);
    cin >> N;
    for (ri i = 1; i <= N; ++i) {
        cin >> arr[i];
    }
    sort(arr + 1, arr + 1 + N);
    N = unique(arr + 1, arr + 1 + N) - arr - 1;
    double l = 0, r = 1e9;
    while (r - l >= 1e-7) {
        double mid = (l + r) / 2;
        if (ok(mid)) {
            r = mid;
        } else {
            l = mid;
        }
    }
    cout << setprecision(6) << fixed << r << endl;
    ok(r);
    for (auto ele : v) {
        cout << setprecision(6) << fixed << ele << " ";
    }
    return 0;
}


#include "bits/stdc++.h"
#define MOD 1000000007
#define inf 0x3f3f3f3f3f3f3f3f
#define pi acos(-1.0)
#define ri register int
#define int long long
#ifdef ONLINE_JUDGE
const int maxn = 3e5 + 10;
#else
const int maxn = 1e3 + 10;
#endif
using namespace std;
int N, arr[maxn];
vector<double> v;
bool ok(double mid)
{
    double r = mid * 2 + arr[1];
    int i;
    v.clear();
    v.push_back(mid + arr[1]);
    for (i = 1; i <= N; ++i) {
        if (r < arr[i]) {
            break;
        }
    }
    r = arr[i] + mid * 2;
    if (i > N) {
        v.push_back(v[0]);
        v.push_back(v[0]);
        return true;
    }
    v.push_back(arr[i] + mid);
    for (; i <= N; ++i) {
        if (r < arr[i]) {
            break;
        }
    }
    if (i > N) {
        v.push_back(v.back());
        return true;
    }
    r = arr[i] + mid * 2;
    v.push_back(arr[i] + mid);
    for (; i <= N; ++i) {
        if (r < arr[i]) {
            return false;
        }
    }
    return true;
}
signed main()
{
    ios::sync_with_stdio(false);
    cin >> N;
    for (ri i = 1; i <= N; ++i) {
        cin >> arr[i];
    }
    sort(arr + 1, arr + 1 + N);
    N = unique(arr + 1, arr + 1 + N) - arr - 1;
    double l = 0, r = 1e9;
    while (r - l >= 1e-8) {
        double mid = (l + r) / 2;
        if (ok(mid)) {
            r = mid;
        } else {
            l = mid;
        }
    }
    cout << setprecision(6) << fixed << r << endl;
    ok(r);
    for (auto ele : v) {
        cout << setprecision(6) << fixed << ele << " ";
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
const int r=2e5+5;
const double eps=1e-6;
int n,arr[r];
bool ok(double t)
{
  int secondstart=upper_bound(arr,arr+n,arr[0]+2*t)-arr;
  if(secondstart==n) return 1;
    int thirdstart=upper_bound(arr,arr+n,arr[secondstart]+2*t)-arr;
  if(thirdstart==n) return 1;
    int fourstart=upper_bound(arr,arr+n,arr[thirdstart]+2*t)-arr;
  if(fourstart==n) return 1;
  return 0;
};
double binary()
{
  double lo=0,med,hi=1e9+5;
  int count =100;
  while(count)
  {
      med=(lo+hi)/2;
      if(ok(med)) hi=med;
      else
      lo=med;
  }
  return med;
};
int main()
{
    scanf("%d" ,&n);
    for(int i=0;i<n;i++) scanf("%d", arr+i);
    sort(arr,arr+n);
    double t=binary();
    printf("%lf\n%lf " ,t, arr[0]+t);
  int secondstart=upper_bound(arr,arr+n,arr[0]+2*(t+eps))-arr;
  printf("%lf ",arr[secondstart]+t);
      int thirdstart=upper_bound(arr,arr+n,arr[secondstart]+2*(t+eps))-arr;
    printf("%lf\n",arr[thirdstart]+t);
  return 0;
}


// Example program
#include <bits/stdc++.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int s=2e5+5;
const double eps=1e-6;
int n,arr[s];
bool ok(double t)
{
  int secondstart=upper_bound(arr,arr+n,arr[0]+2*t)-arr;
  if(secondstart==n) return 1;
    int thirdstart=upper_bound(arr,arr+n,arr[secondstart]+2*t)-arr;
  if(thirdstart==n) return 1;
    int fourstart=upper_bound(arr,arr+n,arr[thirdstart]+2*t)-arr;
  if(fourstart==n) return 1;
  return 0;
};
double binary()
{
  double lo=0,med,hi=1e9+5;
  int count =100;
  while(count)
  {
      med=(lo+hi)/2;
      if(ok(med)) hi=med;
      else
      lo=med;
  }
  return med;
};
int main()
{
    scanf("%d" ,&n);
    for(int i=0;i<n;i++) cin>>arr[i];
    sort(arr,arr+n);
    double t=binary();
    printf("%lf\n%lf " ,t, arr[0]+t);
  int secondstart=upper_bound(arr,arr+n,arr[0]+2*(t+eps))-arr;
  printf("%lf ",arr[secondstart]+t);
      int thirdstart=upper_bound(arr,arr+n,arr[secondstart]+2*(t+eps))-arr;
    printf("%lf\n",arr[thirdstart]+t);
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
const int r=2e5+5;
const double eps=1e-6;
int n,arr[r];
bool ok(double t)
{
  int secondstart=upper_bound(arr,arr+n,arr[0]+2*t)-arr;
  if(secondstart==n) return 1;
    int thirdstart=upper_bound(arr,arr+n,arr[secondstart]+2*t)-arr;
  if(thirdstart==n) return 1;
    int fourstart=upper_bound(arr,arr+n,arr[thirdstart]+2*t)-arr;
  if(fourstart==n) return 1;
  return 0;
};
double binary()
{
  double lo=0,med,hi=1e9+5;
  int count =100;
  while(count--)
  {
      med=(lo+hi)/2;
      if(ok(med)) hi=med;
      else
      lo=med;
  }
  return med;
};
int main()
{
    scanf("%d" ,&n);
    for(int i=0;i<n;i++) scanf("%d", arr+i);
    sort(arr,arr+n);
    double t=binary();
    printf("%lf\n%lf " ,t, arr[0]+t);
  int secondstart=upper_bound(arr,arr+n,arr[0]+2*(t+eps))-arr;
  printf("%lf ",arr[secondstart]+t);
      int thirdstart=upper_bound(arr,arr+n,arr[secondstart]+2*(t+eps))-arr;
    printf("%lf\n",arr[thirdstart]+t);
  return 0;
}


#include <bits/stdc++.h>
#include<iostream>
using namespace std;
const int s=2e5+5;
const double eps=1e-6;
int n,arr[s];
bool ok(double t)
{
  int secondstart=upper_bound(arr,arr+n,arr[0]+2*t)-arr;
  if(secondstart==n) return 1;
    int thirdstart=upper_bound(arr,arr+n,arr[secondstart]+2*t)-arr;
  if(thirdstart==n) return 1;
    int fourstart=upper_bound(arr,arr+n,arr[thirdstart]+2*t)-arr;
  if(fourstart==n) return 1;
  return 0;
};
double binary()
{
  double lo=0,med,hi=1e9+5;
  int count =100;
  while(count)
  {
      med=(lo+hi)/2;
      if(ok(med)) hi=med;
      else
      lo=med;
  }
  return med;
};
int main()
{
    scanf("%d" ,&n);
    for(int i=0;i<n;i++) cin>>arr[i];
    sort(arr,arr+n);
    double t=binary();
    printf("%lf\n%lf " ,t, arr[0]+t);
  int secondstart=upper_bound(arr,arr+n,arr[0]+2*(t+eps))-arr;
  printf("%lf ",arr[secondstart]+t);
      int thirdstart=upper_bound(arr,arr+n,arr[secondstart]+2*(t+eps))-arr;
    printf("%lf\n",arr[thirdstart]+t);
  return 0;
}


#include <bits/stdc++.h>
using namespace std;

const int MAX = 2e5 + 5;

int n, arr[MAX];

bool Can(double x) {
    long double lastPos = arr[0] + x;
    int cnt = 1;
    for(int i=1;i<n;i++) {
        if( abs(arr[i] - lastPos) > x) {
            ++cnt;
            lastPos = arr[i] + x;
        }
    }
    if(cnt <= 3)
        return true;
    return false;
}

int main() {

    cin>>n;
    for(int i=0;i<n;i++)
        cin>>arr[i];
    sort(arr,arr + n);
    Can(0.5);
    int iter = 1000;
    long double st = 0, en = arr[n-1];
    while(--iter) {
        double mid = (st + en) * 0.5;
        if(Can(mid))
            en = mid;
        else
            st = mid;
    }
    printf("%.6llf\n", st);

    int cnt = 1;
    long double lastPos = arr[0] + st;

    printf("%.6llf ", lastPos);
    for(int i=1;i<n;i++) {
        if( abs(arr[i] - lastPos) > st) {
            ++cnt;
            lastPos = arr[i] + st;
            printf("%.6llf ", lastPos);
            if(cnt == 3)
                break;
        }
    }
    while(cnt++ < 3)
        printf("%.6llf ", lastPos);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

const int MAX = 2e5 + 5;

int n, arr[MAX];

bool Can(double x) {
    long double lastPos = arr[0] + x;
    int cnt = 1;
    for(int i=1;i<n;i++) {
        if( abs(arr[i] - lastPos) > x) {
            ++cnt;
            lastPos = arr[i] + x;
        }
    }
    if(cnt <= 3)
        return true;
    return false;
}

int main() {

    cin>>n;
    for(int i=0;i<n;i++)
        cin>>arr[i];
    sort(arr,arr + n);
    Can(0.5);
    int iter = 1000;
    double st = 0, en = arr[n-1];
    while(--iter) {
        double mid = (st + en) * 0.5;
        if(Can(mid))
            en = mid;
        else
            st = mid;
    }
    printf("%.6lf\n", st);

    int cnt = 1;
    double lastPos = arr[0] + st;

    printf("%.6lf ", lastPos);
    for(int i=1;i<n;i++) {
        if( abs(arr[i] - lastPos) > st) {
            ++cnt;
            lastPos = arr[i] + st;
            printf("%.6lf ", lastPos);
            if(cnt == 3)
                break;
        }
    }
    if(cnt < 3)
        printf("%.6lf ", lastPos);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define EPS 1e-15

const int MAX = 2e5 + 5;

int n, arr[MAX];

bool Can(double x) {
    double lastPos = arr[0] + x;
    int cnt = 1;
    for(int i=1;i<n;i++) {
        if( abs(arr[i] - lastPos) > x) {
            ++cnt;
            lastPos = arr[i] + x;
        }
    }
    if(cnt <= 3)
        return true;
    return false;
}

int main() {

    cin>>n;
    for(int i=0;i<n;i++)
        cin>>arr[i];
    sort(arr,arr + n);
    Can(0.5);
    int iter = 1000;
    double st = 0, en = arr[n-1];
    while(--iter) {
        double mid = (st + en) * 0.5;
        if(Can(mid))
            en = mid;
        else
            st = mid + EPS;
    }

    st = round(st);
    cout<<fixed<<setprecision(6)<<st<<endl;

    int cnt = 1;
    double lastPos = arr[0] + st;

    cout<<lastPos<<" ";
    for(int i=1;i<n;i++) {
        if( abs(arr[i] - lastPos) > st) {
            ++cnt;
            lastPos = arr[i] + st;
            cout<<lastPos<<" ";
            if(cnt == 3)
                break;
        }
    }
    while(cnt++ < 3)
        cout<<lastPos<<" ";
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

const int MAX = 2e5 + 5;

int n, arr[MAX];

bool Can(double x) {
    long double lastPos = arr[0] + x;
    int cnt = 1;
    for(int i=1;i<n;i++) {
        if( abs(arr[i] - lastPos) > x) {
            ++cnt;
            lastPos = arr[i] + x;
        }
    }
    if(cnt <= 3)
        return true;
    return false;
}

int main() {

    cin>>n;
    for(int i=0;i<n;i++)
        cin>>arr[i];
    sort(arr,arr + n);
    Can(0.5);
    int iter = 1000;
    double st = 0, en = arr[n-1];
    while(--iter) {
        double mid = (st + en) * 0.5;
        if(Can(mid))
            en = mid;
        else
            st = mid;
    }
    printf("%.6lf\n", st);

    int cnt = 1;
    double lastPos = arr[0] + st;

    printf("%.6lf ", lastPos);
    for(int i=1;i<n;i++) {
        if( abs(arr[i] - lastPos) > st) {
            ++cnt;
            lastPos = arr[i] + st;
            printf("%.6lf ", lastPos);
            if(cnt == 3)
                break;
        }
    }
    while(cnt++ < 3)
        printf("%.6lf ", lastPos);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define EPS 1e-6

const int MAX = 2e5 + 5;

int n, arr[MAX];

bool Can(double x) {
    double lastPos = arr[0] + x;
    int cnt = 1;
    for(int i=1;i<n;i++) {
        if( abs(arr[i] - lastPos) > x) {
            ++cnt;
            lastPos = arr[i] + x;
        }
    }
    if(cnt <= 3)
        return true;
    return false;
}

int main() {

    cin>>n;
    for(int i=0;i<n;i++)
        cin>>arr[i];
    sort(arr,arr + n);
    Can(0.5);
    int iter = 1000;
    double st = 0, en = arr[n-1];
    while(--iter) {
        double mid = (st + en) * 0.5;
        if(Can(mid))
            en = mid;
        else
            st = mid;
    }

    cout<<fixed<<setprecision(6)<<st<<endl;

    int cnt = 1;
    double firstPos = arr[0] + st;
    cout<<firstPos<<" ";

    auto it  = upper_bound(arr,arr + n,arr[0]+2*st + 1e-6);      ///second station
    if(it == arr + n)
        cout<<arr[n-1] - st<<" ";
    else cout<< *it + st<<" ";

    cout<<arr[n-1] - st; ///third station
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define EPS 1e-15

const int MAX = 2e5 + 5;

int n, arr[MAX];

bool Can(double x) {
    double lastPos = arr[0] + x;
    int cnt = 1;
    for(int i=1;i<n;i++) {
        if( abs(arr[i] - lastPos) > x) {
            ++cnt;
            lastPos = arr[i] + x;
        }
    }
    if(cnt <= 3)
        return true;
    return false;
}

int main() {

    cin>>n;
    for(int i=0;i<n;i++)
        cin>>arr[i];
    sort(arr,arr + n);
    Can(0.5);
    int iter = 1000;
    double st = 0, en = arr[n-1];
    while(--iter) {
        double mid = (st + en) * 0.5;
        if(Can(mid))
            en = mid;
        else
            st = mid + EPS;
    }
    cout<<fixed<<setprecision(6)<<st<<endl;

    int cnt = 1;
    double lastPos = arr[0] + st;

    cout<<lastPos<<" ";
    for(int i=1;i<n;i++) {
        if( abs(arr[i] - lastPos) > st) {
            ++cnt;
            lastPos = arr[i] + st;
            cout<<lastPos<<" ";
            if(cnt == 3)
                break;
        }
    }
    while(cnt++ < 3)
        cout<<lastPos<<" ";
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define EPS 1e-15

const int MAX = 2e5 + 5;

int n, arr[MAX];

bool Can(double x) {
    double lastPos = arr[0] + x;
    int cnt = 1;
    for(int i=1;i<n;i++) {
        if( abs(arr[i] - lastPos) > x) {
            ++cnt;
            lastPos = arr[i] + x;
        }
    }
    if(cnt <= 3)
        return true;
    return false;
}

int main() {

    cin>>n;
    for(int i=0;i<n;i++)
        cin>>arr[i];
    sort(arr,arr + n);
    Can(0.5);
    int iter = 1000;
    double st = -1, en = arr[n-1];
    while(--iter) {
        double mid = (st + en) * 0.5;
        if(mid > 0 && Can(mid))
            en = mid;
        else
            st = mid;
    }
    cout<<fixed<<setprecision(6)<<st<<endl;

    int cnt = 1;
    double lastPos = arr[0] + st;

    cout<<lastPos<<" ";
    for(int i=1;i<n;i++) {
        if( abs(arr[i] - lastPos) > st) {
            ++cnt;
            lastPos = arr[i] + st;
            cout<<lastPos<<" ";
            if(cnt == 3)
                break;
        }
    }
    while(cnt++ < 3)
        cout<<lastPos<<" ";
    return 0;
}


#include <bits/stdc++.h>
#define sz(x) (int)((x).size())
#define all(x) (x).begin(),(x).end()
#define rep(i,a,b) for (int i=(a); i<(b); i++)
#define per(i,a,b) for (int i=(b)-1; i>=(a); i--)
using namespace std;

#define fi first
#define se second
#define mp make_pair
typedef pair<int, int> pii;

#define pb push_back
typedef vector<int> vi;

const int N = 2e5 + 7;
const int INF = 1e9 + 7;
int x[N], n;
///---------------------------------------
vector<double> ans;
bool gao(int lim, bool sav = false) {
    int ned = 0;
    for (int l = 0, r; l < n; l = r) {
        for (r = l; r < n && x[r] - x[l] <= lim; r++);
        if (sav) ans.pb(x[l] + (x[r - 1] - x[l]) / 2.0);
        ned++;
    }
    return ned <= 3;
}
int main() {

    ///read
    cin >> n;
    rep(i, 0, n) scanf("%d", &x[i]);

    ///work
    int ret = -1;
    for (int l = 0, r = INF, mid = (l + r) >> 1; l <= mid; mid = (l + r) >> 1) {
        if (gao(mid)) r = (ret = mid) - 1 ;
            else l = mid + 1;
    }

    ///print
    gao(ret, true);
    while (sz(ans) < 3) ans.pb(ans.back());
    printf("%.10f\n", ret / 2.0);
    rep(i, 0, sz(ans)) printf("%.10f ", ans[i]);

    return 0;
}


#include <bits/stdc++.h>
#define sz(x) (int)((x).size())
#define all(x) (x).begin(),(x).end()
#define rep(i,a,b) for (int i=(a); i<(b); i++)
#define per(i,a,b) for (int i=(b)-1; i>=(a); i--)
using namespace std;

#define fi first
#define se second
#define mp make_pair
typedef pair<int, int> pii;

#define pb push_back
typedef vector<int> vi;

const int N = 2e5 + 7;
const int INF = 1e9 + 7;
int x[N], n;
///---------------------------------------
vector<double> ans;
bool gao(int lim, bool sav = false) {
    int ned = 0;
    for (int l = 0, r; l < n; l = r) {
        for (r = l; r < n && x[r] - x[l] <= lim; r++);
        if (sav) ans.pb(x[l] + (x[r - 1] - x[l]) / 2.0);
        ned++;
    }
    return ned <= 3;
}
int main() {

    ///read
    cin >> n;
    rep(i, 0, n) scanf("%d", &x[i]);

    ///prework
    sort(x, x + n);

    ///work
    int ret = -1;
    for (int l = 0, r = INF, mid = (l + r) >> 1; l <= mid; mid = (l + r) >> 1) {
        if (gao(mid)) r = (ret = mid) - 1 ;
            else l = mid + 1;
    }

    ///print
    gao(ret, true);
    while (sz(ans) < 3) ans.pb(ans.back());
    printf("%.10f\n", ret / 2.0);
    rep(i, 0, sz(ans)) printf("%.10f ", ans[i]);

    return 0;
}


#include<bits/stdc++.h>
using namespace std;
int a[ 100000 ];
int n;
vector< double  > v;
int f( double d , int z ){
	bool ok = 0;
	double t1 = (double)a[ 0 ] + 2*d;
	if ( z == 1 ){
		v.push_back(  d+ a[ 0 ] );
	}

	int pos;
	for ( int i = 0 ; i <= n ; i++ ){
		if ( i == n ){
			pos = n;
		}
		if ( a[ i ] > t1 ){
			pos = i;
			break;
		}
	}
	if ( pos == n ) ok =1;

	if ( z == 1 ){
		v.push_back(  d+ a[ pos ] );
	}
	t1 = a[ pos ] + 2*d;
	for ( int i = pos + 1 ; i <= n ; i++ ){
		if ( i == n ){
			pos = n;
		}
		if ( a[ i ] > t1 ){
			pos = i;
			break;
		}
	}
	if ( pos == n ) ok = 1;

	t1 = a[ pos ] + 2*d;

	if ( z == 1 ){
		v.push_back(  d+ a[ pos ] );
	}
	for ( int i = pos + 1 ; i <= n ; i++ ){
		if ( i == n ){
			pos = n;
		}
		if ( a[ i ] > t1 ){
			pos = i;
			break;
		}
	}

	if( pos == n ) ok =1;
	return ok;
}
int main(){
	cin>>n;
	for ( int i = 0 ; i <n ; i++ ){
		cin>>a[ i ];
	}
	a[ n ] = a[ n - 1 ] + 12;
	sort( a , a + n );
	double lo =0, hi=100000 , mi;
	for ( int i = 0 ; i < 60 ; i++ ){
		mi=( lo + hi )/2.0;
		if ( f( mi, 0 )  ){
			hi = mi;
		}else lo = mi;
	}
	f( hi , 1 );
	printf("%.6f\n",hi);
	for ( int i = 0 ; i < (int)v.size(); i++ ){
		if ( i ){
			cout<<" ";
		}
		printf("%.6f",v[i]);
	}
	cout<<endl;

}


#include<bits/stdc++.h>
using namespace std;
int a[ 100000 ];
int n;
vector< double  > v;
int f( double d , int z ){
	bool ok = 0;
	double t1 = (double)a[ 0 ] + 2*d;
	if ( z == 1 ){
		v.push_back(  d+ a[ 0 ] );
	}

	int pos;
	for ( int i = 0 ; i <= n ; i++ ){
		if ( i == n ){
			pos = n;
		}
		if ( a[ i ] > t1 ){
			pos = i;
			break;
		}
	}
	if ( pos == n ) ok =1;

	if ( z == 1 ){
		v.push_back(  d+ a[ pos ] );
	}
	t1 = a[ pos ] + 2*d;
	for ( int i = pos + 1 ; i <= n ; i++ ){
		if ( i == n ){
			pos = n;
		}
		if ( a[ i ] > t1 ){
			pos = i;
			break;
		}
	}
	if ( pos == n ) ok = 1;

	t1 = a[ pos ] + 2*d;

	if ( z == 1 ){
		v.push_back(  d+ a[ pos ] );
	}
	for ( int i = pos + 1 ; i <= n ; i++ ){
		if ( i == n ){
			pos = n;
		}
		if ( a[ i ] > t1 ){
			pos = i;
			break;
		}
	}

	if( pos == n ) ok =1;
	return ok;
}
int main(){
	cin>>n;
	for ( int i = 0 ; i <n ; i++ ){
		cin>>a[ i ];
	}
	a[ n ] = a[ n - 1 ] + 12;
	sort( a , a + n );
	double lo =0, hi=1000000000 , mi;
	for ( int i = 0 ; i < 60 ; i++ ){
		mi=( lo + hi )/2.0;
		if ( f( mi, 0 )  ){
			hi = mi;
		}else lo = mi;
	}
	f( hi , 1 );
	printf("%.6f\n",hi);
	for ( int i = 0 ; i < (int)v.size(); i++ ){
		if ( i ){
			cout<<" ";
		}
		printf("%.6f",v[i]);
	}
	cout<<endl;

}


#include<bits/stdc++.h>
using namespace std;
int a[ 200004 ];
int n;
vector< double  > v;
int f( double d , int z ){
	bool ok = 0;
	double t1 = (double)a[ 0 ] + 2*d;
	if ( z == 1 ){
		v.push_back(  d+ a[ 0 ] );
	}

	int pos;
	for ( int i = 0 ; i <= n ; i++ ){
		if ( i == n ){
			pos = n;
		}
		if ( a[ i ] > t1 ){
			pos = i;
			break;
		}
	}
	if ( pos == n ) ok =1;

	if ( z == 1 ){
		v.push_back(  d+ a[ pos ] );
	}
	t1 = a[ pos ] + 2*d;
	for ( int i = pos + 1 ; i <= n ; i++ ){
		if ( i == n ){
			pos = n;
		}
		if ( a[ i ] > t1 ){
			pos = i;
			break;
		}
	}
	if ( pos == n ) ok = 1;

	t1 = a[ pos ] + 2*d;

	if ( z == 1 ){
		v.push_back(  d+ a[ pos ] );
	}
	for ( int i = pos + 1 ; i <= n ; i++ ){
		if ( i == n ){
			pos = n;
		}
		if ( a[ i ] > t1 ){
			pos = i;
			break;
		}
	}

	if( pos == n ) ok =1;
	return ok;
}
int main(){
	cin>>n;
	for ( int i = 0 ; i <n ; i++ ){
		cin>>a[ i ];
	}
	a[ n ] = a[ n - 1 ] + 12;
	sort( a , a + n );
	double lo =0, hi=1000000000 , mi;
	for ( int i = 0 ; i < 60 ; i++ ){
		mi=( lo + hi )/2.0;
		if ( f( mi, 0 )  ){
			hi = mi;
		}else lo = mi;
	}
	f( hi , 1 );
	printf("%.6f\n",hi);
	for ( int i = 0 ; i < (int)v.size(); i++ ){
		if ( i ){
			cout<<" ";
		}
		printf("%.6f",v[i]);
	}
	cout<<endl;

}


#include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
typedef long long ll;
const int N=2e5+5, OO = 0x3f3f3f3f;
//priority_queue<int,vector<int>, greater<int>>pg;
int n,a[N];
double dis;
bool ok(ll d){
    ll used=0, last=-OO;
    for (int i=0;i<n;i++){
        if (a[i]>last){
            used++;
            last=a[i]+d*2.0;
        }
    }
    return used<=3;
}
ll bs(){
    ll mid,lo=0,hi=5e9;
    while(hi-lo>0){
        mid=(hi+lo)/2;
        if (ok(mid))    hi=mid;
        else    lo=mid+1;
        //cout<<mid<<endl;
    }
    return lo;
}

int main()
{
#ifndef ONLINE_JUDGE
    //freopen("out.txt","w",stdout);
#endif
    scanf("%d",&n);
    for(int i=0;i<n;i++){    scanf("%d",a+i);a[i]*=2;}
    sort(a,a+n);
    //cout<<bs()<<endl;
    ll x =bs();
    cout<<fixed<<setprecision(6)<<x/2.0<<endl;
    ll last=-OO , cnt=0;
    for (int i=0;i<n;i++){
        if (a[i]>last){
            cout<<fixed<<setprecision(6)<<(a[i]+x)/2.0<<" ";
            last=a[i]+x*2;
            cnt++;
        }
    }
    while(cnt<3)    {cout<<0<<" ";cnt++;}
    puts("");

    return 0;
}


#include <bits/stdc++.h>
using namespace std;

const int N = 2e5+5, M = 2e6+5, OO = 0x3f3f3f3f;
typedef long long ll;
ll a[N];
int n;

bool OK(ll k)
{
	ll last=-OO;
	ll cnt=0;
	for(int i=0;i<n;i++){
		if(a[i]>last)
		{
			last=k*2+a[i];
			cnt++;
		}
}
	return cnt<=3;
}
int BS()
{
	ll lo=0,mid,hi=4e9;
	while(hi-lo>0)
	{
		mid=(hi+lo)/2;
		if(OK(mid))
			hi=mid;
		else
			lo=mid+1;
	}
	return lo;
}

int main() {
	scanf("%d",&n);

	for(int i=0;i<n;i++)
		{cin>>a[i];
		a[i] <<=1;
		}

	sort(a,a+n);
	ll x=BS();
	printf("%lf\n",x/2.0);

	ll last=-OO , cnt=0;
	for (int i=0;i<n;i++){
        if (a[i]>last){
            printf("%lf\n",(a[i]+x)/2.0);
            last=a[i]+2*x;
            cnt++;
        }
	}
	while(cnt<3){
        puts("0");
        cnt++;
	}

    return 0;
}


#include <bits/stdc++.h>

using namespace std;
const int N=2e5+10;
double EPS=1e-8;
int n,arr[N];
bool ok (double d){
double last=0.0;
int used=0;
for (int i=0;i<n;i++){
    if (arr[i]>last){
        used++;
        last=arr[i]+2*d;
    }
}
return used<=3;
}
double binarysearch(){
double lo=0,hi=2e9+10,mid;
while (hi - lo > EPS){
    mid =(hi+lo)/2;
    if (ok(mid))
        hi=mid;
    else
        lo=mid;
}
return lo;
}
int main()
{
   scanf("%d",&n);
   for (int i=0;i<n;i++){
    scanf("%d",arr+i);
   }
   sort(arr,arr+n);
   double d=binarysearch();
   printf("%.7f\n",d);
   double last=0.0;
   int used=0;
   for (int i=0;i<n;i++){
    if (arr[i]-last>EPS){
        used++;
    printf("%.7f ",arr[i]+d);
        last=arr[i]+2*d;
    }
   }
   while (used<3){
    printf("%.7f ",0.0);
    used++;
   }
   puts("");
    return 0;
}


#include <bits/stdc++.h>

using namespace std;
const int N=2e5+10;
double EPS=1e-8;
int n,arr[N];
bool ok (double d){
double last=0.0;
int used=0;
for (int i=0;i<n;i++){
    if (arr[i]>last){
        used++;
        last=arr[i]+2*d;
    }
}
return used<=3;
}
double binarysearch(){
double lo=0,hi=2e9+10,mid;
while (hi - lo > EPS){
    mid =(hi+lo)/2;
    if (ok(mid))
        hi=mid;
    else
        lo=mid;
}
return hi;
}
int main()
{
   scanf("%d",&n);
   for (int i=0;i<n;i++){
    scanf("%d",arr+i);
   }
   sort(arr,arr+n);
   double d=binarysearch();
   printf("%.7f\n",d);
   double last=0.0;
   int used=0;
   for (int i=0;i<n;i++){
    if (arr[i]-last>EPS){
        used++;
    printf("%.7f ",arr[i]+d);
        last=arr[i]+2*d;
    }
   }
   while (used<3){
    printf("%.7f ",0.0);
    used++;
   }
   puts("");
    return 0;
}


#include<bits/stdc++.h>
#define fastio ios_base::sync_with_stdio(false),cin.tie(NULL)
#define endl "\n"
#define ll long long
#define N ((int)2e5 + 5)
#define MAX ((int)1e9 + 5)
#define MAXL ((ll)1e18 + 5)
#define MOD ((int)7901 + 0)
#define thr (1e-10)

using namespace std;

/*fast io
ios_base::sync_with_stdio(false);
cin.tie(NULL);
*/

int arr[N];

int main()
{
    fastio;
    int n;
    cin>>n;

    for(int i = 1 ; i<=n ; i++){
        cin>>arr[i];
    }

    sort(arr+1,arr+n+1);

    int l = 0 , r = 1e9;
    while(l<r){
        int mid = (l+r)/2;
        int cur = 0 , cnt = 0;
        for(int i = 1 ; i<=n ; i++){
            if(arr[i] > cur){
                cur = arr[i] + mid;
                cnt++;
            }
        }

        if(cnt > 3) l = mid+1;
        else r = mid;

    }

    cout<<(double)l/2.0<<endl;
    int cur = 0 , cnt = 0;
    for(int i = 1 ; i<=n ; i++){
        if(arr[i] > cur){
            cout<<(double)arr[i] + l/2.0<<" ";
            cur = arr[i] + l;
            cnt++;
        }
    }

    while(cnt < 3){
        cnt++;
        cout<<"0 ";
    }

    return 0;
}


#include<bits/stdc++.h>
#define fastio ios_base::sync_with_stdio(false),cin.tie(NULL)
#define endl "\n"
#define ll long long
#define N ((int)2e5 + 5)
#define MAX ((int)1e9 + 5)
#define MAXL ((ll)1e18 + 5)
#define MOD ((int)7901 + 0)
#define thr (1e-10)

using namespace std;

/*fast io
ios_base::sync_with_stdio(false);
cin.tie(NULL);
*/

int arr[N];

int main()
{
    fastio;
    int n;
    cin>>n;

    for(int i = 1 ; i<=n ; i++){
        cin>>arr[i];
    }

    sort(arr+1,arr+n+1);

    int l = 0 , r = 1e9;
    while(l<r){
        int mid = (l+r)/2;
        int cur = 0 , cnt = 0;
        for(int i = 1 ; i<=n ; i++){
            if(arr[i] > cur){
                cur = arr[i] + mid;
                cnt++;
            }
        }

        if(cnt > 3) l = mid+1;
        else r = mid;

    }

    cout<<(float)l/2.0<<endl;
    int cur = 0 , cnt = 0;
    for(int i = 1 ; i<=n ; i++){
        if(arr[i] > cur){
            cout<<(float)arr[i] + l/2.0<<" ";
            cur = arr[i] + l;
            cnt++;
        }
    }

    while(cnt < 3){
        cnt++;
        cout<<"0 ";
    }

    return 0;
}


#include<bits/stdc++.h>
#define fastio ios_base::sync_with_stdio(false),cin.tie(NULL)
#define endl "\n"
#define ll long long
#define N ((int)2e5 + 5)
#define MAX ((int)1e9 + 5)
#define MAXL ((ll)1e18 + 5)
#define MOD ((int)7901 + 0)
#define thr (1e-10)

using namespace std;

/*fast io
ios_base::sync_with_stdio(false);
cin.tie(NULL);
*/

int arr[N];

int main()
{
    fastio;
    int n;
    cin>>n;

    for(int i = 1 ; i<=n ; i++){
        cin>>arr[i];
    }

    sort(arr+1,arr+n+1);

    int l = 0 , r = 1e9;
    while(l<r){
        int mid = (l+r)/2;
        int cur = 0 , cnt = 0;
        for(int i = 1 ; i<=n ; i++){
            if(arr[i] > cur){
                cur = arr[i] + mid;
                cnt++;
            }
        }

        if(cnt > 3) l = mid+1;
        else r = mid;

    }

    cout<<setprecision(6)<<fixed;

    cout<<(double)l/2.0<<endl;
    int cur = 0 , cnt = 0;
    for(int i = 1 ; i<=n ; i++){
        if(arr[i] > cur){
            cout<<(double)arr[i] + l/2.0<<" ";
            cur = arr[i] + l;
            cnt++;
        }
    }

    while(cnt < 3){
        cnt++;
        cout<<"0 ";
    }

    return 0;
}


#include<bits/stdc++.h>
#define fastio ios_base::sync_with_stdio(false),cin.tie(NULL)
#define endl "\n"
#define ll long long
#define N ((int)2e5 + 5)
#define MAX ((int)1e9 + 5)
#define MAXL ((ll)1e18 + 5)
#define MOD ((int)7901 + 0)
#define thr (1e-10)

using namespace std;

/*fast io
ios_base::sync_with_stdio(false);
cin.tie(NULL);
*/

int arr[N];

int main()
{
    fastio;
    int n;
    cin>>n;

    for(int i = 1 ; i<=n ; i++){
        cin>>arr[i];
    }

    sort(arr+1,arr+n+1);

    int l = 0 , r = 1e9;
    while(l<r){
        int mid = (l+r)/2;
        int cur = 0 , cnt = 0;
        for(int i = 1 ; i<=n ; i++){
            if(arr[i] > cur){
                cur = arr[i] + mid;
                cnt++;
            }
        }

        if(cnt > 3) l = mid+1;
        else r = mid;

    }

    cout<<l/2.0<<endl;
    int cur = 0 , cnt = 0;
    for(int i = 1 ; i<=n ; i++){
        if(arr[i] > cur){
            cout<<arr[i] + l/2.0<<" ";
            cur = arr[i] + l;
            cnt++;
        }
    }

    while(cnt < 3){
        cnt++;
        cout<<"0 ";
    }

    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define ld long double

bool check(vector<ld> &a, ld mid)
{
    ll n = a.size();
    ll i = 0;
    ll count = 0;
    while (i < n)
    {
        count++;
        ll x = upper_bound(a.begin(), a.end(), a[i] + 2 * mid) - a.begin();
        i = x;
    }

    return count <= 3;
}

int main()
{
    ll i, j, n;
    cin >> n;
    vector<ld> a(n);
    for (i = 0; i < n; i++)
        cin >> a[i];

    sort(a.begin(), a.end());

    ld high = 1e17;
    ld low = 0;
    ld mid;

    for (i = 0; i < 90; i++)
    {
        mid = (low + high) / 2.0;

        if (check(a, mid))
        {
            high = mid;
        }
        else
        {
            low = mid;
        }
    }
    cout << fixed << setprecision(6) << high << "\n";
    cout << a[0] + high << " ";
    ll index = upper_bound(a.begin(), a.end(), a[0] + 2 * high) - a.begin();
    cout << min(a[n-1],a[index] + high) << " ";
    index = upper_bound(a.begin(), a.end(), a[index] + 2 * high) - a.begin();

    cout << min(a[n-1],a[index] + high) << " ";

    return (0);
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define ld long double

bool check(vector<ld> &a, ld mid)
{
    ll n = a.size();
    ll i = 0;
    ll count = 0;
    while (i < n)
    {
        count++;
        ll x = upper_bound(a.begin(), a.end(), a[i] + 2 * mid) - a.begin();
        i = x;
    }

    return count <= 3;
}

int main()
{
    ll i, j, n;
    cin >> n;
    vector<ld> a(n);
    for (i = 0; i < n; i++)
        cin >> a[i];

    sort(a.begin(), a.end());

    ld high = 1e17;
    ld low = 0;
    ld mid;

    for (i = 0; i < 90; i++)
    {
        mid = (low + high) / 2.0;

        if (check(a, mid))
        {
            high = mid;
        }
        else
        {
            low = mid;
        }
    }
    cout << fixed << setprecision(6) << high << "\n";
    cout << a[0] + high << " ";
    ll index = upper_bound(a.begin(), a.end(), a[0] + 2 * high) - a.begin();
    cout << a[index] + high << " ";
    index = upper_bound(a.begin(), a.end(), a[index] + 2 * high) - a.begin();

    cout << min(a[n-1],a[index] + high) << " ";

    return (0);
}


#include<bits/stdc++.h>
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define ll long long
using namespace std;
const int MAX =1e5+9;
ll dp[500][500];
int has[MAX];
int n;
vector<double>v;
int a[MAX];
int stations(double x){
	double end=-1;
	int cnt=0;
	for(int i=0;i<n;i++){
		if(a[i]>end){
			v.push_back(a[i]+x);
			end=a[i]+2*x;
			cnt++;
		}
	}
	return cnt;
}
int main(){
	cin>>n;
	for(int i=0;i<n;i++)
		cin>>a[i];
	double l=0, h=1000000000, mid;
	sort(a, a+n);
	for(int i=0;i<1000;i++){
		mid=l+(h-l)/2;
		v.clear();
		if(stations(mid)>3)
			l=mid;
		else
			h=mid;
	}
	cout<<fixed<<setprecision(6)<<l<<"\n";
	for(int i=0;i<3;i++)
		cout<<fixed<<setprecision(6)<<v[i]<<" ";
}


#include<bits/stdc++.h>
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define ll long long
using namespace std;
const int MAX =1e5+9;
ll dp[500][500];
int has[MAX];
int n;
vector<double>v;
int a[MAX];
int stations(double x){
	double end=-1;
	int cnt=0;
	for(int i=0;i<n;i++){
		if(a[i]>end){
			v.push_back(a[i]+x);
			end=a[i]+2*x;
			cnt++;
		}
	}
	return cnt;
}
int main(){
	cin>>n;
	for(int i=0;i<n;i++)
		cin>>a[i];
	double l=0, h=10000000000 , mid;
	sort(a, a+n);
	for(int i=0;i<1000;i++){
		mid=l+(h-l)/2;
		v.clear();
		if(stations(mid)>3)
			l=mid;
		else
			h=mid;
	}
	cout<<fixed<<setprecision(6)<<l<<"\n";
	for(int i=0;i<3;i++)
		cout<<fixed<<setprecision(6)<<v[i]<<" ";
}


#include<bits/stdc++.h>
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define ll long long
using namespace std;
const int MAX =1e5+9;
ll dp[500][500];
int has[MAX];
int n;
vector<double>v;
int a[MAX];
int stations(double x){
	double end=-1;
	int cnt=0;
	for(int i=0;i<n;i++){
		if(a[i]>end){
			v.push_back(a[i]+x);
			end=a[i]+2*x;
			cnt++;
		}
	}
	return cnt;
}
int main(){
	cin>>n;
	for(int i=0;i<n;i++)
		cin>>a[i];
	double l=0, h=10000000 , mid;
	sort(a, a+n);
	for(int i=0;i<1000;i++){
		mid=l+(h-l)/2;
		v.clear();
		if(stations(mid)>3)
			l=mid;
		else
			h=mid;
	}
	cout<<fixed<<setprecision(6)<<l<<"\n";
	for(int i=0;i<3;i++)
		cout<<fixed<<setprecision(6)<<v[i]<<" ";
}


#include<bits/stdc++.h>
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define ll long long
using namespace std;
const int MAX =1e6+9;
ll dp[500][500];
int has[MAX];
int n;
vector<double>v;
int a[MAX];
int stations(double x){
	double end=-1;
	int cnt=0;
	for(int i=0;i<n;i++){
		if(a[i]>end){
			v.push_back(a[i]+x);
			end=a[i]+2*x;
			cnt++;
		}
	}
	return cnt;
}
int main(){
	cin>>n;
	for(int i=0;i<n;i++)
		cin>>a[i];
	double l=0, h=10000000000 , mid;
	sort(a, a+n);
	for(int i=0;i<1000;i++){
		mid=l+(h-l)/2;
		v.clear();
		if(stations(mid)>3)
			l=mid;
		else
			h=mid;
	}
	cout<<fixed<<setprecision(6)<<l<<"\n";
	for(int i=0;i<3;i++)
		cout<<fixed<<setprecision(6)<<v[i]<<" ";
}


#include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define mod 1000000007
#define MAX 300005

lli max(lli a,lli b)
{
   if(a>b)
   {
       return a;
   }
   return b;
}
lli gcd(lli a,lli b)
{
    if(a==0)
    {
        return b;
    }
    return gcd(b%a,a);
}
lli min(lli a,lli b)
{
   if(a<b)
   {
       return a;
   }
   return b;
}
lli power(lli x,lli n)
{
    lli res=1;
    while(n>0)
    {
        if(n%2==1)
        {
            res=(res*x)%mod;
        }
        x=(x*x)%mod;
        n=n/2;
    }
    return  res%mod;
}

lli factorialNumInverse[1000001];
lli naturalNumInverse[1000001];
lli fact[1000001];

void InverseofNumber(lli n,lli p)
{
    naturalNumInverse[0] = naturalNumInverse[1] = 1;
    for (lli i = 2; i <= n; i++)
        naturalNumInverse[i] = naturalNumInverse[p % i] * (p - p / i) % p;
}
void InverseofFactorial(lli n,lli p)
{
    factorialNumInverse[0] = factorialNumInverse[1] = 1;

    for (lli i = 2; i <= n; i++)
        factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
}
void factorial(lli n,lli p)
{
    fact[0] = 1;
    for (lli i = 1; i <= n; i++) {
        fact[i] = (fact[i - 1] * i) % p;
    }
}
lli nCrModp(lli n, lli r, lli p)
{
    lli ans = ((fact[n] * factorialNumInverse[r]) % p * factorialNumInverse[n - r]) % p;
    return ans;
}

vector<long double> solve(long double arr[], long double range, lli n)
{
    lli i=0;
    vector<long double> v;
    while(i<n)
    {
        long double limit=arr[i]+(long double)range;
        v.push_back(limit);
        if(v.size()>3)
        {
            vector<long double> v1;
            return v1;
        }
        while(arr[i]<=limit+range && i<n)
        {
            i++;
        }

    }
    if(v.size()<3)
    {
        v.push_back(v.back());
    }
    return v;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    //lli tc;
    //cin>>tc;
    factorial(200005,mod);
    InverseofNumber(200005,mod);
    InverseofFactorial(200005,mod);
    //while(tc--)
    //{
        lli n;
        cin>>n;
        long double arr[n];
        for(int i=0;i<n;i++)
        {
            cin>>arr[i];
        }
        sort(arr,arr+n);
        long double l=0;
        long double res=LONG_MAX;
        long double r=1e9;
        lli cnt=100;
        while(l<r && cnt--)
        {

            long double mid=(l+r)/2;
            vector<long double> ans=solve(arr,mid,n);

            if(ans.size()>0)
            {
                r=mid;
            }
            else
            {
                l=mid;
            }

        }
        //cout<<"\n";
        cout<<r<<"\n";
        vector<long double> ans=solve(arr,r,n);
        for(int i=0;i<ans.size();i++)
        {
            cout<<fixed<<setprecision(12)<<ans[i]<<" ";
        }
        cout<<"\n";
        //cout<<res<<"\n";

    //}
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define mod 1000000007
#define MAX 300005

lli max(lli a,lli b)
{
   if(a>b)
   {
       return a;
   }
   return b;
}
lli gcd(lli a,lli b)
{
    if(a==0)
    {
        return b;
    }
    return gcd(b%a,a);
}
lli min(lli a,lli b)
{
   if(a<b)
   {
       return a;
   }
   return b;
}
lli power(lli x,lli n)
{
    lli res=1;
    while(n>0)
    {
        if(n%2==1)
        {
            res=(res*x)%mod;
        }
        x=(x*x)%mod;
        n=n/2;
    }
    return  res%mod;
}

lli factorialNumInverse[1000001];
lli naturalNumInverse[1000001];
lli fact[1000001];

void InverseofNumber(lli n,lli p)
{
    naturalNumInverse[0] = naturalNumInverse[1] = 1;
    for (lli i = 2; i <= n; i++)
        naturalNumInverse[i] = naturalNumInverse[p % i] * (p - p / i) % p;
}
void InverseofFactorial(lli n,lli p)
{
    factorialNumInverse[0] = factorialNumInverse[1] = 1;

    for (lli i = 2; i <= n; i++)
        factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
}
void factorial(lli n,lli p)
{
    fact[0] = 1;
    for (lli i = 1; i <= n; i++) {
        fact[i] = (fact[i - 1] * i) % p;
    }
}
lli nCrModp(lli n, lli r, lli p)
{
    lli ans = ((fact[n] * factorialNumInverse[r]) % p * factorialNumInverse[n - r]) % p;
    return ans;
}

vector<long double> solve(long double arr[], long double range, lli n)
{
    lli i=0;
    vector<long double> v;
    while(i<n)
    {
        long double limit=arr[i]+(long double)range;
        v.push_back(limit);
        if(v.size()>3)
        {
            vector<long double> v1;
            return v1;
        }
        while(arr[i]<=limit+range && i<n)
        {
            i++;
        }

    }
    while(v.size()<3)
    {
        v.push_back(v.back());
    }
    return v;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    //lli tc;
    //cin>>tc;
    factorial(200005,mod);
    InverseofNumber(200005,mod);
    InverseofFactorial(200005,mod);
    //while(tc--)
    //{
        lli n;
        cin>>n;
        long double arr[n];
        for(int i=0;i<n;i++)
        {
            cin>>arr[i];
        }
        sort(arr,arr+n);
        long double l=0;
        long double r=1e10;
        lli cnt=100;
        while( cnt--)
        {

            long double mid=(l+r)/2;
            //cout<<l<<" "<<r<<" "<<mid<<"\n";
            vector<long double> ans=solve(arr,mid,n);

            if(ans.size()>0)
            {
                r=mid;
            }
            else
            {
                l=mid;
            }

        }
        cout<<fixed<<setprecision(6)<<r<<"\n";
        vector<long double> ans=solve(arr,r,n);
        for(int i=0;i<ans.size();i++)
        {
            cout<<fixed<<setprecision(6)<<ans[i]<<" ";
        }
        cout<<"\n";
        //cout<<res<<"\n";

    //}
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
vector<double>v;
bool ok(double mid,bool f){
    double pos=mid+v[0];
    int indx=upper_bound(v.begin(),v.end(),pos+mid)-v.begin();
    if(f){
        if(pos>v[v.size()-1])cout<<fixed<<setprecision(6)<<v[v.size()-1];
        else cout<<fixed<<setprecision(6)<<pos<<" ";}
    if(indx<v.size()){
        pos=v[indx]+mid;
        indx=upper_bound(v.begin(),v.end(),pos+mid)-v.begin();
    }
    if(f){
        if(pos>v[v.size()-1])cout<<fixed<<setprecision(6)<<v[v.size()-1];
        else cout<<fixed<<setprecision(6)<<pos<<" ";}
    if(indx<v.size()){
        pos=v[indx]+mid;
        indx=upper_bound(v.begin(),v.end(),pos+mid)-v.begin();
    }
    if(f){
        if(pos>v[v.size()-1])cout<<fixed<<setprecision(6)<<v[v.size()-1];
        else cout<<fixed<<setprecision(6)<<pos<<" ";}
    if (pos+mid>=v[v.size()-1]){return true;}
    else return false;
}
double bs (){
    double lo=0,hi=1000000000,mid;
    for(int i=0;i<1000;i++){
        mid=(lo+hi)/2;
        if(ok(mid,false)){hi=mid;}
        else lo=mid;
    }
    return hi;
}
int main(){
    int n;
    double num,mid;
    cin>>n;
    while(n--){
        cin>>num;
        v.push_back(num);}
    sort(v.begin(),v.end());
    mid=bs();
    cout<<fixed<<setprecision(6)<<mid<<"\n";
    ok(mid,true);
return 0;}


#include <bits/stdc++.h>
using namespace std;
vector<double>v;
bool ok(double mid,bool f){
    double pos=mid+v[0];
    int indx=upper_bound(v.begin(),v.end(),pos+mid)-v.begin();
    if(f){
        if(pos>v[v.size()-1])cout<<fixed<<setprecision(6)<<v[v.size()-1];
        else cout<<fixed<<setprecision(6)<<pos<<" ";}
    if(indx<v.size()){
        pos=v[indx]+mid;
        indx=upper_bound(v.begin(),v.end(),pos+mid)-v.begin();
    }
    if(f){
        if(pos>v[v.size()-1])cout<<fixed<<setprecision(6)<<v[v.size()-1];
        else cout<<fixed<<setprecision(6)<<pos<<" ";}
    if(indx<v.size()){
        pos=v[indx]+mid;
        indx=upper_bound(v.begin(),v.end(),pos+mid)-v.begin();
    }
    if(f){
        if(pos>v[v.size()-1])cout<<fixed<<setprecision(6)<<v[v.size()-1];
        else cout<<fixed<<setprecision(6)<<pos<<" ";}
    if (pos+mid>=v[v.size()-1]){return true;}
    else return false;
}
double bs (){
    double lo=0,hi=1000000000,mid;
    for(int i=0;i<500;i++){
        mid=(lo+hi)/2;
        if(ok(mid,false)){hi=mid;}
        else lo=mid;
    }
    return hi;
}
int main(){
    int n;
    double num,mid;
    cin>>n;
    while(n--){
        cin>>num;
        v.push_back(num);}
    sort(v.begin(),v.end());
    mid=bs();
    cout<<fixed<<setprecision(6)<<mid<<"\n";
    ok(mid,true);
return 0;}


#include <bits/stdc++.h>
using namespace std;
vector<double>v;
bool ok(double mid,bool f){
    double pos=mid+v[0];
    int indx=upper_bound(v.begin(),v.end(),pos+mid)-v.begin();
    if(f){
        if(pos>v[v.size()-1])printf("%.6lf ",v[v.size()-1]);
        else printf("%.6lf ",pos);}
    if(indx<v.size()){
        pos=v[indx]+mid;
        indx=upper_bound(v.begin(),v.end(),pos+mid)-v.begin();
    }
    if(f){
        if(pos>v[v.size()-1])printf("%.6lf",v[v.size()-1]);
        else printf("%.6lf ",pos);}
    if(indx<v.size()){
        pos=v[indx]+mid;
        indx=upper_bound(v.begin(),v.end(),pos+mid)-v.begin();
    }
    if(f){
        if(pos>v[v.size()-1])printf("%.6lf",v[v.size()-1]);
        else printf("%.6lf ",pos);}
    if (pos+mid>=v[v.size()-1]){return true;}
    else return false;
}
double bs (){
    double lo=0,hi=1000000000,mid;
    for(int i=0;i<100;i++){
        mid=(lo+hi)/2;
        if(ok(mid,false)){hi=mid;}
        else lo=mid;
    }
    return hi;}
int main(){
    int n;
    double num,mid;
    scanf("%d",&n);
    while(n--){
        scanf("%lf",&num);
        v.push_back(num);}
    sort(v.begin(),v.end());
    mid=bs();
    printf("%.6lf\n",mid);
    ok(mid,true);
return 0;}


#include<bits/stdc++.h>
#define ll long long int
#define mod 1000000007
#define se second
#define fi first
#define endl "\n"
#define pi 3.1415926535897932384626433832795028841971
#define MAX 9223372036854775807
using namespace std;
bool find(vector<double> arr,double mid,ll n)
{
	double x,z;
	ll y;
	x=arr[0]+2.0*mid;
	vector<double>::iterator it;
	it=upper_bound(arr.begin(),arr.end(),x);
	if(it==arr.end())
	x=arr[n-1];
	else
	{
		x=*it+2.0*mid;
	}
	it=upper_bound(arr.begin(),arr.end(),x);
	if(it==arr.end())
	x=arr[n-1];
	else
	{
		x=*it+2.0*mid;
	}
	if(x>=arr[n-1])
	return 1;
	else
	return 0;
}
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	cout<<fixed<<setprecision(15);
	ll n;
	cin>>n;
	vector<double> arr(n);
	for(int a=0;a<n;a++)
	cin>>arr[a];
	double x,z;
	ll y;
	sort(arr.begin(),arr.end());
	double low,high,mid,ans=-1;
	low=0;
	high=10000000000.0;
	while(low<=high)
	{
		mid=low+(high-low)/2;
		if(find(arr,mid,n)==1)
		{
			ans=mid;
			high=mid;
		}
		else
		low=mid;
		if(1000000*abs(low-high)<=1)
		break;
	}
	cout<<ans<<endl;
	cout<<arr[0]+ans<<" ";
	x=arr[0]+2.0*ans;
	vector<double>::iterator it;
	it=upper_bound(arr.begin(),arr.end(),x);
	if(it==arr.end())
	cout<<arr[n-1]<<" ";
	else
	{
		cout<<*it+ans<<" ";
		x=*it+2.0*ans;
	}
	it=upper_bound(arr.begin(),arr.end(),x);
	if(it==arr.end())
	cout<<arr[n-1]<<" ";
	else
	{
		cout<<*it+ans<<" ";
		x=*it+2.0*ans;
	}
	return 0;
}


#include<bits/stdc++.h>
#define ll long long int
#define mod 1000000007
#define se second
#define fi first
#define endl "\n"
#define pi 3.1415926535897932384626433832795028841971
#define MAX 9223372036854775807
using namespace std;
bool find(vector<double> arr,double mid,ll n)
{
	double x,z;
	ll y;
	x=arr[0]+2.0*mid;
	vector<double>::iterator it;
	it=upper_bound(arr.begin(),arr.end(),x);
	if(it==arr.end())
	x=arr[n-1];
	else
	{
		x=*it+2.0*mid;
	}
	it=upper_bound(arr.begin(),arr.end(),x);
	if(it==arr.end())
	x=arr[n-1];
	else
	{
		x=*it+2.0*mid;
	}
	if(x>=arr[n-1])
	return 1;
	else
	return 0;
}
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	cout<<fixed<<setprecision(15);
	ll n;
	cin>>n;
	vector<double> arr(n);
	for(int a=0;a<n;a++)
	cin>>arr[a];
	double x,z;
	ll y;
	sort(arr.begin(),arr.end());
	double low,high,mid,ans=-1;
	low=0;
	high=10000000000.0;
	while(low<=high)
	{
		mid=low+(high-low)/2;
		if(find(arr,mid,n)==1)
		{
			ans=mid;
			high=mid;
		}
		else
		low=mid;
		if(100000000*abs(low-high)<=1)
		break;
	}
	cout<<ans<<endl;
	cout<<arr[0]+ans<<" ";
	x=arr[0]+2.0*ans;
	vector<double>::iterator it;
	it=upper_bound(arr.begin(),arr.end(),x);
	if(it==arr.end())
	cout<<arr[n-1]<<" ";
	else
	{
		cout<<*it+ans<<" ";
		x=*it+2.0*ans;
	}
	it=upper_bound(arr.begin(),arr.end(),x);
	if(it==arr.end())
	cout<<arr[n-1]<<" ";
	else
	{
		cout<<*it+ans<<" ";
		x=*it+2.0*ans;
	}
	return 0;
}


#include<bits/stdc++.h>
#define ll long long int
#define mod 1000000007
#define se second
#define fi first
#define endl "\n"
#define pi 3.1415926535897932384626433832795028841971
#define MAX 9223372036854775807
using namespace std;
bool find(double arr[],double mid,ll n)
{
	double x,y,z;
	x=arr[0]+2.0*mid;
	for(int a=1;a<n;a++)
	{
		if(arr[a]>x)
		{
			x=arr[a]+2.0*mid;
			y=a;
			break;
		}
	}
	for(int a=y+1;a<n;a++)
	{
		if(arr[a]>x)
		{
			x=arr[a]+2.0*mid;
			y=a;
			break;
		}
	}
	if(x>=arr[n-1])
	return 1;
	else
	return 0;
}
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	cout<<fixed<<setprecision(15);
	ll n;
	cin>>n;
	double arr[n];
	for(int a=0;a<n;a++)
	cin>>arr[a];
	double x,y,z;
	sort(arr,arr+n);
	double low,high,mid,ans=-1;
	low=0;
	high=10000000000.0;
	while(low<=high)
	{
		mid=low+(high-low)/2;
		if(find(arr,mid,n)==1)
		{
			ans=mid;
			high=mid;
		}
		else
		low=mid;
		if(100000000*abs(low-high)<=1)
		break;
	}
	cout<<ans<<endl;
	cout<<arr[0]+ans<<" ";
	x=arr[0]+2.0*ans;
	for(int a=1;a<n;a++)
	{
		if(arr[a]>x)
		{
			cout<<arr[a]+ans<<" ";
			x=arr[a]+2.0*ans;
			y=a;
			break;
		}
	}
	ll c=0;
	for(int a=y+1;a<n;a++)
	{
		if(arr[a]>x)
		{
			c=1;
			cout<<arr[a]+ans<<" ";
			break;
		}
	}
	if(c==0)
	cout<<arr[n-1]<<" ";
	return 0;
}


#include<bits/stdc++.h>
#define ll long long int
#define mod 1000000007
#define se second
#define fi first
#define endl "\n"
#define pi 3.1415926535897932384626433832795028841971
#define MAX 9223372036854775807
using namespace std;
bool find(double arr[],double mid,ll n)
{
	double x,z;
	ll y;
	x=arr[0]+2.0*mid;
	for(int a=1;a<n;a++)
	{
		if(arr[a]>x)
		{
			x=arr[a]+2.0*mid;
			y=a;
			break;
		}
	}
	for(int a=y+1;a<n;a++)
	{
		if(arr[a]>x)
		{
			x=arr[a]+2.0*mid;
			y=a;
			break;
		}
	}
	if(x>=arr[n-1])
	return 1;
	else
	return 0;
}
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	cout<<fixed<<setprecision(15);
	ll n;
	cin>>n;
	double arr[n];
	for(int a=0;a<n;a++)
	cin>>arr[a];
	double x,z;
	ll y;
	sort(arr,arr+n);
	double low,high,mid,ans=-1;
	low=0;
	high=10000000000.0;
	while(low<=high)
	{
		mid=low+(high-low)/2;
		if(find(arr,mid,n)==1)
		{
			ans=mid;
			high=mid;
		}
		else
		low=mid;
		if(100000000*abs(low-high)<=1)
		break;
	}
	cout<<ans<<endl;
	cout<<arr[0]+ans<<" ";
	x=arr[0]+2.0*ans;
	ll c=0;
	for(int a=1;a<n;a++)
	{
		if(arr[a]>x)
		{
			c=1;
			cout<<arr[a]+ans<<" ";
			x=arr[a]+2.0*ans;
			y=a;
			break;
		}
	}
	if(c==0)
	cout<<arr[n-1]<<" ";
	c=0;
	for(int a=y+1;a<n;a++)
	{
		if(arr[a]>x)
		{
			c=1;
			cout<<arr[a]+ans<<" ";
			break;
		}
	}
	if(c==0)
	cout<<arr[n-1]<<" ";
	return 0;
}


#include<bits/stdc++.h>
#define pb push_back
#define all(x) (x).begin(),(x).end()
using namespace  std ;
typedef long l ;
typedef long long ll ;
typedef vector<int>vi ;
typedef vector<l>vl ;
typedef vector<ll>vll ;
typedef vector<vector<ll> >vvl ;
typedef pair<int,int> pii ;
typedef pair<ll,ll> pll ;
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    std::cout.unsetf ( std::ios::floatfield );//this and next line for floating precision upto 6
    std::cout.precision(10);
    ll a,b,c,d,x,i,j,n,t,m,k,y;
    double p,s,q,r,w,u ;
    string str = "",str1 = "" ;
    ll a1,a2,b1,b2 ;
    cin>>n ;
    vll v;
    for(i=0 ; i<n ; i=i+1)
    {
        cin>>a ;
        v.pb(a) ;
    }
    sort(all(v)) ;
    if(n==3)
    {
    	cout<<"0\n" ;
    	for(i=0 ; i<n ; i=i+1)
    	{
    		cout<<v[i]<<" " ;
		}
		exit(0) ;
	}
    p = 0 ;
    q = v[n-1] ;
    double t1,t2,t3,ans=DBL_MAX ;
    j = 0 ;
    while(j<1000)
    {
        r = p + (q-p)/2.0 ;
        a = v[0] ;
        s = v[0] + r ;
        vll::iterator itr = upper_bound(all(v),s+r);
        bool hua = false ;
        if(itr!=v.end())
        {
            c = 1 ;
            for( ; itr<v.end() ;)
            {
                b = *itr ;
                vll::iterator it = upper_bound(all(v),b+2*r) ;
                c++ ;
                itr = it ;
            }
        }
        else
        {
            hua = true ;
        }
        if(c<=3 || hua)
        {
            q = r ;
            ans = min(ans,r) ;
        }
        else
        {
            p = r ;
        }
		j++ ;
    }
    cout<<ans<<"\n";
    s = v[0] + r ;
    vector<double> cor ;
    cor.pb(s) ;
    c = 1 ;
    vll::iterator itr = upper_bound(all(v),s+r);
    for( ; itr<v.end() ;)
    {
        b = *itr ;
        vll::iterator it = upper_bound(all(v),b+2*r) ;
        if(b+r>v[n-1])
        {
        	cor.pb(v[n-1]) ;
        	a = v[n-1] ;
        	c++ ;
		}
		else
		{
			cor.pb(b+r) ;
			a = b + r ;
			c++ ;
		}
        itr = it ;
    }
    if(cor.size()==2)
    {
    	cor.pb((cor[0]+cor[1])/2.0) ;
    	sort(all(cor)) ;
	}
	cout<<cor[0]<<" "<<cor[1]<<" "<<cor[2] ;
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long
const long double eps = 1e-9;
const int N = 3e5+100;
long double x[N];
long double ans[10];
bool can(long double d){
    long double rng = -1e20;
    int it = 0;
    for(int i=0;i<n;++i){
       if(fabs(x[i]-rng)<eps)continue;
       if(x[i]<=rng)continue;
       ans[it++] = x[i] + d;
       rng = max(x[i]+d+d,rng);
       if(it>3)break;
    }
    return it<=3;
}
int main(){
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;++i)cin>>x[i];
    sort(x,x+n);
    long double l = 0,r = 1e9+7;
    for(int i=0;it<200;++it)
        long double m = (l + r)/2.;
        if(can(m)){
            r = m;
        }else{
            l = m;
        }
    }
    can(r);
    cout.precision(6);
    cout<<fixed;
    printf("%.6lf",(double)(l+r)/2.);
    for(int i=0;i<3;++i){
        cout << min(max(0.0L, ans[i]), 1E9L+100) << " ";
    }
    cout<<endl;
    return 0;
}


/**
▂▃▅▇█▓▒░۩۞۩ ۩۞۩░▒▓█▇▅▃▂
Make it happen now, not tomorrow.
Tomorrow is a  loser's excuse.
▂▃▅▇█▓▒░۩۞۩ ۩۞۩░▒▓█▇▅▃▂
**/
#ifndef _GLIbCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>

#if __cplu >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#include <cstring>
#endif

// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include<random>
#include <chrono>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>

#if __cplu >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <time.h>
#endif
#define __ ios_base::sync_with_stdio(false);cin.tie(NULL);
using namespace std;
// #define INF 0x7f7f7f7f
#define ull unsigned long long int
#define pii pair<int,int>
#define ll long long int
#define ld long double
#define MSET(x,y) memset(x,y,sizeof(x))
// #define l long
#define se second
#define AlphaSize 26
#define fi first
#define NIL 0
#define UNVISITED -1
#define EXPOLORED 0
#define mk make_pair
#define pb push_back
#define sc(n) scanf("%d",&n)
#define NIL 0
#define db double
#define pii pair<int,int>
#define eps 1e-8
#define inrange(x,y,n,m) ((x>=1 && y>=1 && x<=n && y<=m))
#define all(x) x.begin(),x.end()
#define me(u,v,w) make_pair(w,make_pair(u,v))
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define foreach(e, x) for(__typeof(x.begin()) e = x.begin(); e != x.end(); ++ e)
// #define add(a,b) (a + b >= MOD ? a+b-MOD:a+b)
#define hs(c1,c2) (256*min(c1,c2) + max(c1,c2))
#define REP(i,n) for((i)=0;(i)<(int)(n);(i)++)
typedef struct{ int sum,suf,pre,max;} Node;
int toint(const string &s) { stringstream ss; ss << s; int x; ss >> x; return x; }
const int MAXN = 2e5+100;
const int UP = 31;
// const ll inf = 1e18;
// const int mod = 1e9+7;
const ll highest = 1e18;
// const int inf = 1e9+10;
// const dou    ble pi = 3.141592653589793238462643383;
const double pi = acos(-1);
const double Phi =  1.618033988749894;
const int logn = 20;
const double root5 = 2.236067977;
const ll inf = 1e18;
const int mod = 998244353;
const int ini = -1e9;
/**
▂▃▅▇█▓▒░۩۞۩ ۩۞۩░▒▓█▇▅▃▂
Make it happen now, not tomorrow.
Tomorrow is a loser's excuse.
▂▃▅▇█▓▒░۩۞۩ ۩۞۩░▒▓█▇▅▃▂
**/
//E.cpp
const int N = 2e5+10;
double x[N];
int n;
double l,r;
long double ans[3];
bool solve(double d){
    double range = -1e10;
    int it = 0;
    for(int i=0;i<n;++i){
        if(fabs(x[i]-range)<eps)continue;
        if(x[i]<=range)continue;
        ans[it++] = x[i] + d;
        range = max(range,x[i]+d+d);
        if(it>3)break;
    }
    return (it<=3);
}
int main(){
    scanf("%d",&n);
    for(int i=0;i<n;++i){
        cin>>x[i];
        // r = max(r,x[i]);
    }
    sort(x,x+n);
    n = unique(x,x+n) - x;
    l = 0;
    r = 1e9;
    for(int it=0;it<200;++it){
        double m = (l + r)/2.;
        if(solve(m)){
            r = m;
        }else{
            l = m;
        }
    }
    printf("%.6lf\n", l);
    for(int i=0;i<3;++i){
        double an = min(max(0.0L,ans[i]),1E9L+100);
        printf("%.6lf ",an);
    }
    cout<<endl;
    return 0;
}
// struct bigint {
//     vector<int> z;
//     int sign;

//     bigint() :
//         sign(1) {
//     }

//     bigint(long v) {
//         *this = v;
//     }

//     bigint(const string &s) {
//         read(s);
//     }

//     void operator=(const bigint &v) {
//         sign = v.sign;
//         z = v.z;tor=(long long v) {
//         sign = 1;
//         if (v < return 0;0)
//             sign = -1, v = -v;
//         z.clear();
//         for (; v > 0; v = v / base)
//             z.push_back(v % base);
//     }

//     bigint operator+(const bigint &v) const {
//         if (sign == v.sign) {
//             bigint res = v;

//             for (int i = 0, carry = 0; i < (int) max(z.size(), v.z.size()) || carry; ++i) {
//                 if (i == (int) res.z.size())
//                     res.z.push_back(0);
//                 res.z[i] += carry + (i < (int) z.size() ? z[i] : 0);
//                 carry = res.z[i] >= base;
//                 if (carry)
//                     res.z[i] -= base;
//             }
//             return res;
//         }
//         return *this - (-v);
//     }

//     bigint operator-(const bigint &v) const {
//         if (sign == v.sign) {
//             if (abs() >= v.abs()) {
//                 bigint res = *this;
//                 for (int i = 0, carry = 0; i < (int) v.z.size() || carry; ++i) {
//                     res.z[i] -= carry + (i < (int) v.z.size() ? v.z[i] : 0);
//                     carry = res.z[i] < 0;
//                     if (carry)
//                         res.z[i] += base;
//                 }
//                 res.trim();
//                 return res;
//             }
//             return -(v - *this);
//         }
//         return *this + (-v);
//     }

//     void operator*=(int v) {
//         if (v < 0)
//             sign = -sign, v = -v;
//         for (int i = 0, carry = 0; i < (int) z.size() || carry; ++i) {
//             if (i == (int) z.size())
//                 z.push_back(0);
//             long long cur = z[i] * (long long) v + carry;
//             carry = (int) (cur / base);
//             z[i] = (int) (cur % base);
//             //asm("divl %%ecx" : "=a"(carry), "=d"(a[i]) : "A"(cur), "c"(base));
//         }
//         trim();
//     }

//     bigint operator*(int v) const {
//         bigint res = *this;
//         res *= v;
//         return res;
//     }

//     friend pair<bigint, bigint> divmod(const bigint &a1, const bigint &b1) {
//         int norm = base / (b1.z.back() + 1);
//         bigint a = a1.abs() * norm;
//         bigint b = b1.abs() * norm;
//         bigint q, r;
//         q.z.resize(a.z.size());

//         for (int i = a.z.size() - 1; i >= 0; i--) {
//             r *= base;
//             r += a.z[i];
//             int s1 = b.z.size() < r.z.size() ? r.z[b.z.size()] : 0;
//             int s2 = b.z.size() - 1 < r.z.size() ? r.z[b.z.size() - 1] : 0;
//             int d = ((long long) s1 * base + s2) / b.z.back();
//             r -= b * d;
//             while (r < 0)
//                 r += b, --d;
//             q.z[i] = d;
//         }

//         q.sign = a1.sign * b1.sign;
//         r.sign = a1.sign;
//         q.trim();
//         r.trim();
//         return make_pair(q, r / norm);
//     }

//     friend bigint sqrt(const bigint &a1) {
//         bigint a = a1;
//         while (a.z.empty() || a.z.size() % 2 == 1)
//             a.z.push_back(0);

//         int n = a.z.size();

//         int firstDigit = (int) sqrt((double) a.z[n - 1] * base + a.z[n - 2]);
//         int norm = base / (firstDigit + 1);
//         a *= norm;
//         a *= norm;
//         while (a.z.empty() || a.z.size() % 2 == 1)
//             a.z.push_back(0);

//         bigint r = (long long) a.z[n - 1] * base + a.z[n - 2];
//         firstDigit = (int) sqrt((double) a.z[n - 1] * base + a.z[n - 2]);
//         int q = firstDigit;
//         bigint res;

//         for(int j = n / 2 - 1; j >= 0; j--) {
//             for(; ; --q) {
//                 bigint r1 = (r - (res * 2 * base + q) * q) * base * base + (j > 0 ? (long long) a.z[2 * j - 1] * base + a.z[2 * j - 2] : 0);
//                 if (r1 >= 0) {
//                     r = r1;
//                     break;
//                 }
//             }
//             res *= base;
//             res += q;

//             if (j > 0) {
//                 int d1 = res.z.size() + 2 < r.z.size() ? r.z[res.z.size() + 2] : 0;
//                 int d2 = res.z.size() + 1 < r.z.size() ? r.z[res.z.size() + 1] : 0;
//                 int d3 = res.z.size() < r.z.size() ? r.z[res.z.size()] : 0;
//                 q = ((long long) d1 * base * base + (long long) d2 * base + d3) / (firstDigit * 2);
//             }
//         }

//         res.trim();
//         return res / norm;
//     }

//     bigint operator/(const bigint &v) const {
//         return divmod(*this, v).first;
//     }

//     bigint operator%(const bigint &v) const {
//         return divmod(*this, v).second;
//     }

//     void operator/=(int v) {
//         if (v < 0)
//             sign = -sign, v = -v;
//         for (int i = (int) z.size() - 1, rem = 0; i >= 0; --i) {
//             long long cur = z[i] + rem * (long long) base;
//             z[i] = (int) (cur / v);
//             rem = (int) (cur % v);
//         }
//         trim();
//     }

//     bigint operator/(int v) const {
//         bigint res = *this;
//         res /= v;
//         return res;
//     }

//     int operator%(int v) const {
//         if (v < 0)
//             v = -v;
//         int m = 0;
//         for (int i = z.size() - 1; i >= 0; --i)
//             m = (z[i] + m * (long long) base) % v;
//         return m * sign;
//     }

//     void operator+=(const bigint &v) {
//         *this = *this + v;
//     }
//     void operator-=(const bigint &v) {
//         *this = *this - v;
//     }
//     void operator*=(const bigint &v) {
//         *this = *this * v;
//     }
//     void operator/=(const bigint &v) {
//         *this = *this / v;
//     }

//     bool operator<(const bigint &v) const {
//         if (sign != v.sign)
//             return sign < v.sign;
//         if (z.size() != v.z.size())
//             return z.size() * sign < v.z.size() * v.sign;
//         for (int i = z.size() - 1; i >= 0; i--)
//             if (z[i] != v.z[i])
//                 return z[i] * sign < v.z[i] * sign;
//         return false;
//     }

//     bool operator>(const bigint &v) const {
//         return v < *this;
//     }
//     bool operator<=(const bigint &v) const {
//         return !(v < *this);
//     }
//     bool operator>=(const bigint &v) const {
//         return !(*this < v);
//     }
//     bool operator==(const bigint &v) const {
//         return !(*this < v) && !(v < *this);
//     }
//     bool operator!=(const bigint &v) const {
//         return *this < v || v < *this;
//     }

//     void trim() {
//         while (!z.empty() && z.back() == 0)
//             z.pop_back();
//         if (z.empty())
//             sign = 1;
//     }

//     bool isZero() const {
//         return z.empty() || (z.size() == 1 && !z[0]);
//     }

//     bigint operator-() const {
//         bigint res = *this;
//         res.sign = -sign;
//         return res;
//     }

//     bigint abs() const {
//         bigint res = *this;
//         res.sign *= res.sign;
//         return res;
//     }

//     long long longValue() const {
//         long long res = 0;
//         for (int i = z.size() - 1; i >= 0; i--)
//             res = res * base + z[i];
//         return res * sign;
//     }

//     friend bigint gcd(const bigint &a, const bigint &b) {
//         return b.isZero() ? a : gcd(b, a % b);
//     }
//     friend bigint lcm(const bigint &a, const bigint &b) {
//         return a / gcd(a, b) * b;
//     }

//     void read(const string &s) {
//         sign = 1;
//         z.clear();
//         int pos = 0;
//         while (pos < (int) s.size() && (s[pos] == '-' || s[pos] == '+')) {
//             if (s[pos] == '-')
//                 sign = -sign;
//             ++pos;
//         }
//         for (int i = s.size() - 1; i >= pos; i -= base_digits) {
//             int x = 0;
//             for (int j = max(pos, i - base_digits + 1); j <= i; j++)
//                 x = x * 10 + s[j] - '0';
//             z.push_back(x);
//         }
//         trim();
//     }

//     friend istream& operator>>(istream &stream, bigint &v) {
//         string s;
//         stream >> s;
//         v.read(s);
//         return stream;
//     }

//     friend ostream& operator<<(ostream &stream, const bigint &v) {
//         if (v.sign == -1)
//             stream << '-';
//         stream << (v.z.empty() ? 0 : v.z.back());
//         for (int i = (int) v.z.size() - 2; i >= 0; --i)
//             stream << setw(base_digits) << setfill('0') << v.z[i];
//         return stream;
//     }

//     static vector<int> convert_base(const vector<int> &a, int old_digits, int new_digits) {
//         vector<long long> p(max(old_digits, new_digits) + 1);
//         p[0] = 1;
//         for (int i = 1; i < (int) p.size(); i++)
//             p[i] = p[i - 1] * 10;
//         vector<int> res;
//         long long cur = 0;
//         int cur_digits = 0;
//         for (int i = 0; i < (int) a.size(); i++) {
//             cur += a[i] * p[cur_digits];
//             cur_digits += old_digits;
//             while (cur_digits >= new_digits) {
//                 res.push_back(int(cur % p[new_digits]));
//                 cur /= p[new_digits];
//                 cur_digits -= new_digits;
//             }
//         }
//         res.push_back((int) cur);
//         while (!res.empty() && res.back() == 0)
//             res.pop_back();
//         return res;
//     }

//     typedef vector<long long> vll;

//     static vll karatsubaMultiply(const vll &a, const vll &b) {
//         int n = a.size();
//         vll res(n + n);
//         if (n <= 32) {
//             for (int i = 0; i < n; i++)
//                 for (int j = 0; j < n; j++)
//                     res[i + j] += a[i] * b[j];
//             return res;
//         }

//         int k = n >> 1;
//         vll a1(a.begin(), a.begin() + k);
//         vll a2(a.begin() + k, a.end());
//         vll b1(b.begin(), b.begin() + k);
//         vll b2(b.begin() + k, b.end());

//         vll a1b1 = karatsubaMultiply(a1, b1);
//         vll a2b2 = karatsubaMultiply(a2, b2);

//         for (int i = 0; i < k; i++)
//             a2[i] += a1[i];
//         for (int i = 0; i < k; i++)
//             b2[i] += b1[i];

//         vll r = karatsubaMultiply(a2, b2);
//         for (int i = 0; i < (int) a1b1.size(); i++)
//             r[i] -= a1b1[i];
//         for (int i = 0; i < (int) a2b2.size(); i++)
//             r[i] -= a2b2[i];

//         for (int i = 0; i < (int) r.size(); i++)
//             res[i + k] += r[i];
//         for (int i = 0; i < (int) a1b1.size(); i++)
//             res[i] += a1b1[i];
//         for (int i = 0; i < (int) a2b2.size(); i++)
//             res[i + n] += a2b2[i];
//         return res;
//     }

//     bigint operator*(const bigint &v) const {
//         vector<int> a6 = convert_base(this->z, base_digits, 6);
//         vector<int> b6 = convert_base(v.z, base_digits, 6);
//         vll a(a6.begin(), a6.end());
//         vll b(b6.begin(), b6.end());
//         while (a.size() < b.size())
//             a.push_back(0);
//         while (b.size() < a.size())
//             b.push_back(0);
//         while (a.size() & (a.size() - 1))
//             a.push_back(0), b.push_back(0);
//         vll c = karatsubaMultiply(a, b);
//         bigint res;
//         res.sign = sign * v.sign;
//         for (int i = 0, carry = 0; i < (int) c.size(); i++) {
//             long long cur = c[i] + carry;
//             res.z.push_back((int) (cur % 1000000));
//             carry = (int) (cur / 1000000);
//         }
//         res.z = convert_base(res.z, 6, base_digits);
//         res.trim();
//         return res;
//     }
// };