#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<sstream>
#include<cassert>
#include<queue>
#include<stack>
#include<bitset>
#include<cstring>

#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n)   REP(i,0,n)
#define ALL(C)     (C).begin(),(C).end()
#define FOR(it,o)  for(__typeof((o).begin()) it=(o).begin(); it!=(o).end(); ++it)

using namespace std;
const long double EPS = 0.000000001;
const long double INF = 1000000001;
typedef long long lli;
int main(){
  int n;
  cin >> n;
  vector<int> pos(n);
  rep(i, n)cin >> pos[i];
  sort(ALL(pos));
  long double left= 0, right = INF, ans[3], d = INF;
  while(right - left > EPS){
    long double now = (left + right)/2, tmp[3];
    vector<int>::iterator p = pos.begin();
    rep(i, 3){
      tmp[i] = now + (*p);
      p = upper_bound(p, pos.end() , now*2 + (*p) );
    }
    if(p == pos.end()){
      if(now < d){
        rep(i, 3){
        ans[i] = tmp[i];
        if(i > 0 && ans[i] < ans[i-1])ans[i] = ans[i-1];
        }
        d = min(d, now);
      }
      right = now;
    }
    if(p != pos.end()){
      left = now;
    }
  }
  //if(d > INF - 100)assert(false);
  sort(ans, ans+3);
  printf("%.6lf\n",(double)d);
  printf("%.6lf %.6lf %.6lf\n", (double)ans[0], (double)ans[1], (double)ans[2]);
  return 0;
}


#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<sstream>
#include<cassert>
#include<queue>
#include<stack>
#include<bitset>
#include<cstring>

#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n)   REP(i,0,n)
#define ALL(C)     (C).begin(),(C).end()
#define FOR(it,o)  for(__typeof((o).begin()) it=(o).begin(); it!=(o).end(); ++it)

using namespace std;
const long double EPS = 0.000000001;
const long double INF = 1000000001;
typedef long long lli;
int main(){
  int n;
  cin >> n;
  vector<int> pos(n);
  rep(i, n)cin >> pos[i];
  sort(ALL(pos));
  long double left= 0, right = INF, ans[3], d = INF;
  while(right - left > EPS){
    long double now = (left + right)/2, tmp[3];
    vector<int>::iterator p = pos.begin();
    rep(i, 3){
      tmp[i] = now + (*p);
      p = upper_bound(p, pos.end() , now*2 + (*p) );
    }
    if(p == pos.end()){
      if(now < d){
        rep(i, 3){
        ans[i] = tmp[i];
        if(i > 0 && ans[i] < ans[i-1])ans[i] = ans[i-1];
        }
        d = min(d, now);
      }
      right = now;
    }
    if(p != pos.end()){
      left = now;
    }
  }
  if(d > INF - 100)assert(false);
  sort(ans, ans+3);
  printf("%.6Lf\n",d);
  printf("%.6Lf %.6Lf %.6Lf\n", ans[0], ans[1], ans[2]);
  return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <cctype>
#include <algorithm>
#define maxn 200005

using namespace std;

int n,x[maxn];
double a[4];

void init()
 {
  scanf("%d",&n);
  for (int i=1;i<=n;i++)scanf("%d",&x[i]);
 }

int bsearch(int l,double c)
 {
  int r=n,mid;
  while (l<r)
   {
    mid=(l+r+1)>>1;
    if (x[mid]-c<=1e-8)l=mid;
     else r=mid-1;
   }
  return l+1;
 }

bool pd(double d)
 {
  int i=1,tot;
  for (tot=1;tot<=3;tot++)
   {
    a[tot]=x[i]+d;
    if (i<=n)i=bsearch(i,a[tot]+d);
   }
  return i>n;
 }

void work()
 {
  sort(x+1,x+n+1);
  double l=0,r=(x[n]-x[1])/6.0,mid;
  while (l+1e-7<=r)
   {
    mid=(l+r)*0.5;
    if (pd(mid))r=mid;
     else l=mid;
   }
  printf("%.6lf\n",r);
  pd(r);
  for (int i=1;i<3;i++)printf("%.6lf ",a[i]);printf("%.6lf\n",a[3]);
 }

int main()
 {
  init();
  work();
  return 0;
 }


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <cctype>
#include <algorithm>
#define maxn 200005

using namespace std;

int n,x[maxn];
double a[4];

void init()
 {
  scanf("%d",&n);
  for (int i=1;i<=n;i++)scanf("%d",&x[i]);
 }

bool flag(double x,int y,double d)
 {
  double t=x-y;if (t<0)t=-t;
  return t-d<=1e-8;
 }

bool pd(double d)
 {
  int i=1,tot;
  for (tot=1;tot<=3;tot++)
   {
    a[tot]=x[i]+d;
    while (i<=n && flag(a[tot],x[i],d))i++;
   }
  return i>n;
 }

void work()
 {
  sort(x+1,x+n+1);
  double l=0,r=(x[n]-x[1])/3.0,mid;
  while (l+1e-8<=r)
   {
    mid=(l+r)*0.5;
    if (pd(mid))r=mid;
     else l=mid;
   }
  printf("%.6lf\n",r);
  pd(r);
  for (int i=1;i<3;i++)printf("%.6lf ",a[i]);printf("%.6lf\n",a[3]);
 }

int main()
 {
  init();
  work();
  return 0;
 }


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <cctype>
#include <algorithm>
#define maxn 200005

using namespace std;

int n,x[maxn];
double a[4];

void init()
 {
  scanf("%d",&n);
  for (int i=1;i<=n;i++)scanf("%d",&x[i]);
 }

int bsearch(int l,double c)
 {
  int r=n,mid;
  while (l<r)
   {
    mid=(l+r+1)>>1;
    if (x[mid]-c<=1e-8)l=mid;
     else r=mid-1;
   }
  return l+1;
 }

bool pd(double d)
 {
  int i=1,tot;
  for (tot=1;tot<=3;tot++)
   {
    a[tot]=x[i]+d;
    if (i<=n)i=bsearch(i,a[tot]+d);
   }
  return i>n;
 }

void work()
 {
  sort(x+1,x+n+1);
  double l=0,r=(x[n]-x[1])/3.0,mid;
  while (l+1e-8<=r)
   {
    mid=(l+r)*0.5;
    if (pd(mid))r=mid;
     else l=mid;
   }
  printf("%.6lf\n",r);
  pd(r);
  for (int i=1;i<3;i++)printf("%.6lf ",a[i]);printf("%.6lf\n",a[3]);
 }

int main()
 {
  init();
  work();
  return 0;
 }


#include <iostream>
#include <sstream>

#include <iterator>

#include <algorithm>
#include <numeric>
#include <utility>
#include <limits>

#include <string>

#include <vector>
#include <deque>
#include <map>
#include <queue>
#include <stack>

#include <cmath>
#include <cstdio>

typedef unsigned long long ULL;
typedef long long LL;
typedef unsigned long UL;
typedef unsigned int UI;
typedef unsigned short US;
typedef unsigned char UC;

using namespace std;

pair<bool, double> check(const vector<UI> &x, double t)
{
	vector<UI>::const_iterator ci1 = upper_bound(x.begin(),x.end(),UI(floor(x[0]+2*t)));
	if(ci1 == x.end()) return make_pair(true,x[0]);
	vector<UI>::const_iterator ci2 = lower_bound(x.begin(),x.end(),UI(ceil(x[x.size()-1]-2*t)-1));
	if(ci2 == x.end()) return make_pair(true,x[x.size()-1]);
//	cerr << '*' << *ci1 << ':' << *ci2 << endl;
	if(*ci1 >= *ci2) return make_pair(true, x[0]);
	if(*ci2-*ci1 <= 2*t) return make_pair(true, (*ci2-*ci1)/2.0+*ci1);
	return make_pair(false,x[0]);
}

pair<double, double> solve(const vector<UI> &x)
{
	double l = 0, r = 1000000000;
	pair<double,double> result;
	while(r-l>=0.000001) {
		double t = (l+r)/2;
//cerr << l << ':' << t << ':' << r << endl;
		pair<bool,double> res = check(x,t);
		if(res.first) {
			r=t;
		} else {
			l=t;
		}
	}
	pair<bool,double> res = check(x,r);
	result.first = r;
	result.second = res.second;
	return result;
}

int main(void)
{
	ios_base::sync_with_stdio(false);

	UI n; cin >> n;
	vector<UI> x(n);
	for(int i=0;i<n;++i) { cin >> x[i]; }
	sort(x.begin(),x.end());
	if(n<=3) {
		printf("0\n");
		printf("%.6f %.6f %.6f\n", double(x[0]), double(n>=2 ? x[1] : x[0]), double(n>=3 ? x[2] : x[0]));
	} else {
		pair<double, double> res = solve(x);
		printf("%.6f\n", res.first);
		printf("%.6f %.6f %.6f\n", x[0]+res.first, res.second, x[x.size()-1]-res.first);
	}

	return 0;
}


#include <iostream>
#include <sstream>

#include <iterator>

#include <algorithm>
#include <numeric>
#include <utility>
#include <limits>

#include <string>

#include <vector>
#include <deque>
#include <map>
#include <queue>
#include <stack>

#include <cmath>
#include <cstdio>

typedef unsigned long long ULL;
typedef long long LL;
typedef unsigned long UL;
typedef unsigned int UI;
typedef unsigned short US;
typedef unsigned char UC;

using namespace std;

pair<bool, double> check(const vector<UI> &x, double t)
{
	vector<UI>::const_iterator ci1 = upper_bound(x.begin(),x.end(),UI(floor(x[0]+2*t)));
	if(ci1 == x.end()) return make_pair(true,x[0]);
//cerr << UI(ceil(x[x.size()-1]-2*t)-1) << endl;
	vector<UI>::const_iterator ci2 = lower_bound(x.begin(),x.end(),UI(ceil(x[x.size()-1]-2*t)));
	if(ci2 == x.begin()) return make_pair(true,x[x.size()-1]);
	--ci2;
//	cerr << '*' << *ci1 << ':' << *ci2 << endl;
	if(*ci1 > *ci2) return make_pair(true, x[0]);
	if(*ci2-*ci1 <= 2*t) return make_pair(true, (*ci2-*ci1)/2.0+*ci1);
	return make_pair(false,x[0]);
}

pair<double, double> solve(const vector<UI> &x)
{
	double l = 0, r = 1000000000;
	pair<double,double> result;
	while(r-l>=0.000001) {
		double t = (l+r)/2;
//cerr << l << ':' << t << ':' << r << endl;
		pair<bool,double> res = check(x,t);
		if(res.first) {
			r=t;
		} else {
			l=t;
		}
	}
	pair<bool,double> res = check(x,r);
	result.first = r;
	result.second = res.second;
	return result;
}

int main(void)
{
	ios_base::sync_with_stdio(false);

	UI n; cin >> n;
	vector<UI> x(n);
	for(int i=0;i<n;++i) { cin >> x[i]; }
	sort(x.begin(),x.end());
	if(n<=3) {
		printf("0\n");
		printf("%.6f %.6f %.6f\n", double(x[0]), double(n>=2 ? x[1] : x[0]), double(n>=3 ? x[2] : x[0]));
	} else {
		pair<double, double> res = solve(x);
		printf("%.6f\n", res.first);
		printf("%.6f %.6f %.6f\n", x[0]+res.first, res.second, x[x.size()-1]-res.first);
	}

	return 0;
}


#include <iostream>
#include <sstream>

#include <iterator>

#include <algorithm>
#include <numeric>
#include <utility>
#include <limits>

#include <string>

#include <vector>
#include <deque>
#include <map>
#include <queue>
#include <stack>

#include <cmath>
#include <cstdio>

typedef unsigned long long ULL;
typedef long long LL;
typedef unsigned long UL;
typedef unsigned int UI;
typedef unsigned short US;
typedef unsigned char UC;

using namespace std;

pair<bool, double> check(const vector<UI> &x, double t)
{
	vector<UI>::const_iterator ci1 = upper_bound(x.begin(),x.end(),UI(floor(x[0]+2*t)));
	if(ci1 == x.end()) return make_pair(true,x[0]);
//cerr << UI(ceil(x[x.size()-1]-2*t)-1) << endl;
	vector<UI>::const_iterator ci2 = lower_bound(x.begin(),x.end(),UI(ceil(x[x.size()-1]-2*t)-1));
	if(ci2 == x.begin()) return make_pair(true,x[x.size()-1]);
	--ci2;
//	cerr << '*' << *ci1 << ':' << *ci2 << endl;
	if(*ci1 > *ci2) return make_pair(true, x[0]);
	if(*ci2-*ci1 <= 2*t) return make_pair(true, (*ci2-*ci1)/2.0+*ci1);
	return make_pair(false,x[0]);
}

pair<double, double> solve(const vector<UI> &x)
{
	double l = 0, r = 1000000000;
	pair<double,double> result;
	while(r-l>=0.0000001) {
		double t = (l+r)/2;
//cerr << l << ':' << t << ':' << r << endl;
		pair<bool,double> res = check(x,t);
		if(res.first) {
			r=t;
		} else {
			l=t;
		}
	}
	pair<bool,double> res = check(x,r);
	result.first = r;
	result.second = res.second;
	return result;
}

int main(void)
{
	ios_base::sync_with_stdio(false);

	UI n; cin >> n;
	vector<UI> x(n);
	for(int i=0;i<n;++i) { cin >> x[i]; }
	sort(x.begin(),x.end());
	if(n<=3) {
		printf("0\n");
		printf("%.6f %.6f %.6f\n", double(x[0]), double(n>=2 ? x[1] : x[0]), double(n>=3 ? x[2] : x[0]));
	} else {
		pair<double, double> res = solve(x);
		printf("%.6f\n", res.first);
		printf("%.6f %.6f %.6f\n", x[0]+res.first, res.second, x[x.size()-1]-res.first);
	}

	return 0;
}


#include <iostream>
#include <sstream>

#include <iterator>

#include <algorithm>
#include <numeric>
#include <utility>
#include <limits>

#include <string>

#include <vector>
#include <deque>
#include <map>
#include <queue>
#include <stack>

#include <cmath>
#include <cstdio>

typedef unsigned long long ULL;
typedef long long LL;
typedef unsigned long UL;
typedef unsigned int UI;
typedef unsigned short US;
typedef unsigned char UC;

using namespace std;

pair<bool, double> check(const vector<UI> &x, double t)
{
	vector<UI>::const_iterator ci1 = upper_bound(x.begin(),x.end(),UI(floor(x[0]+2*t)));
	if(ci1 == x.end()) return make_pair(true,x[0]);
//cerr << UI(ceil(x[x.size()-1]-2*t)-1) << endl;
	vector<UI>::const_iterator ci2 = lower_bound(x.begin(),x.end(),UI(ceil(x[x.size()-1]-2*t)));
	if(ci2 == x.begin()) return make_pair(true,x[x.size()-1]);
	--ci2;
//	cerr << '*' << *ci1 << ':' << *ci2 << endl;
	if(*ci1 > *ci2) return make_pair(true, x[0]);
	if(*ci2-*ci1 <= 2*t) return make_pair(true, (*ci2-*ci1)/2.0+*ci1);
	return make_pair(false,x[0]);
}

pair<double, double> solve(const vector<UI> &x)
{
	double l = 0, r = 1000000000;
	pair<double,double> result;
	while(r-l>=0.0000001) {
		double t = (l+r)/2;
//cerr << l << ':' << t << ':' << r << endl;
		pair<bool,double> res = check(x,t);
		if(res.first) {
			r=t;
		} else {
			l=t;
		}
	}
	pair<bool,double> res = check(x,r);
	result.first = r;
	result.second = res.second;
	return result;
}

int main(void)
{
	ios_base::sync_with_stdio(false);

	UI n; cin >> n;
	vector<UI> x(n);
	for(int i=0;i<n;++i) { cin >> x[i]; }
	sort(x.begin(),x.end());
	if(n<=3) {
		printf("0\n");
		printf("%.6f %.6f %.6f\n", double(x[0]), double(n>=2 ? x[1] : x[0]), double(n>=3 ? x[2] : x[0]));
	} else {
		pair<double, double> res = solve(x);
		printf("%.6f\n", res.first);
		printf("%.6f %.6f %.6f\n", x[0]+res.first, res.second, x[x.size()-1]-res.first);
	}

	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 0.00000000001
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n-1;i++)
    {
        if(num[i]-num[1]-2*x>eps) break;
    }
    re1=i;
    for(i=n-1;i>=2;i--)
    {
        if(num[n]-num[i]-2*x>-eps) break;
    }
    re2=i;
    double m=num[re2]-num[re1];
    a2=num[re1]+x; a=re1,b=re2; d=m;
    if(m-2*x<-eps) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r= 1000000000;
        int time=1000;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=r;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 0.00000000001
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n-1;i++)
    {
        if(num[i]-num[1]-2*x>-eps) break;
    }
    re1=i;
    for(i=n-1;i>=2;i--)
    {
        if(num[n]-num[i]-2*x>-eps) break;
    }
    re2=i;
    double m=num[re2]-num[re1];
    a2=num[re1]+x; a=re1,b=re2; d=m;
    if(m-2*x<-eps) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r= 1000000000;
        int time=1000;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=r;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 0.00000001
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n-1;i++)
    {
        if(num[i]-num[1]-2*x>-eps) break;
    }
    re1=i;
    for(i=n-1;i>=2;i--)
    {
        if(num[n]-num[i]-2*x>-eps) break;
    }
    re2=i;
    double m=num[re2]-num[re1];
    a2=num[re1]+m/2; a=re1,b=re2; d=m;
    if(m-2*x<-eps) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r= 1000000000;
        int time=1000;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=r;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 1e-10
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int cmp(double x){
    return x > eps ? 1 : x < -eps ? -1 : 0;
}
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a2=a3=num[n]-x;
    for(i=1;i<=n;i++)
    {
        if(cmp(num[1]+2*x-num[i])<=0) break;
    }
    re1=i;
    for(i=n;i>=1;i--)
    {
        if(cmp(num[i]+2*x-num[n])<=0 ) break;
    }
    re2=i;

    if( cmp(num[re1]+2*x-num[re2])>=0 )
    {
        a2=num[re1]+x; return 1;
    }
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r=1e10;
        int time=200;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=mid;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 0.00000001
int n;
double num[N],a1,a2,a3,ans;
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n-1;i++)
    {
        if(num[i]-num[1]-2*x>eps) break;
    }
    re1=i;
    for(i=n-1;i>=2;i--)
    {
        if(num[n]-num[i]-2*x>eps) break;
    }
    re2=i;
    double m=num[re2]-num[re1];
    a2=num[re1]+m/2;
    if(m-2*x<-eps) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        double l,r,mid;
        l=0; r= 1000000000;
        int time=1000;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=r;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 1e-10
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int dcmp(double x){
    return x > eps ? 1 : x < -eps ? -1 : 0;
}
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n-1;i++)
    {
        if(dcmp(num[i]-num[1]-2*x)>=0) break;
    }
    re1=i;
    for(i=n-1;i>=2;i--)
    {
        if(dcmp(num[n]-num[i]-2*x)>=0) break;
    }
    re2=i;
    double m=num[re2]-num[re1];
    a2=num[re1]+x; a=re1,b=re2; d=m;
    if(m-2*x<-eps) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r= 1000000000;
        int time=100;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=r;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 1e-10
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int cmp(double x){
    return x > eps ? 1 : x < -eps ? -1 : 0;
}
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a2=a3=num[n]-x;
    for(i=2;i<=n;i++)
    {
        if(cmp(num[1]+2*x-num[i])<=0) break;
    }
    re1=i;
    for(i=n-1;i>=1;i--)
    {
        if(cmp(num[i]+2*x-num[n])<=0 ) break;
    }
    re2=i;

    if( cmp(num[re1]+2*x-num[re2])>=0 )
    {
        a2=num[re1]+x; return 1;
    }
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r=1e10;
        int time=200;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=mid;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 0.00000000001
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n-1;i++)
    {
        if(num[i]-num[1]-2*x>-eps) break;
    }
    re1=i;
    for(i=n-1;i>=2;i--)
    {
        if(num[n]-num[i]-2*x>-eps) break;
    }
    re2=i;
    double m=num[re2]-num[re1];
    a2=num[re1]+m/2; a=re1,b=re2; d=m;
    if(m-2*x<-eps) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r= 1000000000;
        int time=1000;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=r;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 1e-10
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int cmp(double x){
    return x > eps ? 1 : x < -eps ? -1 : 0;
}
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=1;i<=n;i++)
    {
        if(cmp(num[1]+2*x-num[i])<=0) break;
    }
    re1=i;
    for(i=n;i>=1;i--)
    {
        if(cmp(num[i]+2*x-num[n])<=0 ) break;
    }
    re2=i;
    a2=num[re1]+x;
    if( cmp(num[re1]+2*x-num[re2])>=0 ) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r=1e10;
        int time=200;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=mid;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 1e-10
int n;
double num[N],a1,a2,a3,ans;
int cmp(double x){
    return x > eps? 1:x<-eps? -1:0;
}
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n;i++)
    {
        if(cmp(num[i]-num[1]-2*x)>0) break;
    }
    re1=i;
    for(i=n-1;i>=1;i--)
    {
        if(cmp(num[n]-num[i]-2*x)>0) break;
    }
    re2=i;
    if(cmp(num[re2]-num[re1]-2*x)<=0)
    {
        a2=num[re1]+x; return 1;
    }
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r=1e10;
        int time=200;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=mid;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        //test(ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 1e-10
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n-1;i++)
    {
        if(num[i]-num[1]-2*x>-eps) break;
    }
    re1=i;
    for(i=n-1;i>=2;i--)
    {
        if(num[n]-num[i]-2*x>-eps) break;
    }
    re2=i;
    double m=num[re2]-num[re1];
    a2=num[re1]+x; a=re1,b=re2; d=m;
    if(m-2*x<-eps) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r= 1000000000;
        int time=1000;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=r;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 1e-10
int n;
double num[N],a1,a2,a3,ans;
int cmp(double x){
    return x > eps? 1:x<-eps? -1:0;
}
int test(double x)
{
    int re1=1,re2=n,i;
    a1=num[1]+x;
    a2=a3=num[n]-x;
    for(i=1;i<=n;i++)
    {
        if(cmp(num[i]-num[1]-2*x)<=0) re1++;
        else break;
    }
    for(i=n;i>=1;i--)
    {
        if( cmp(num[i] - num[n] + 2*x)>=0) re2--;
        else break;
    }

    if( cmp(num[re1]+2*x-num[re2])>=0 )
    {
        a2=num[re1]+x; return 1;
    }
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r=1e10;
        int time=200;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=mid;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        test(ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 1e-10
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int dcmp(double x){
    return x > eps ? 1 : x < -eps ? -1 : 0;
}
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n-1;i++)
    {
        if(dcmp(num[i]-num[1]-2*x)>0) break;
    }
    re1=i;
    for(i=n-1;i>=2;i--)
    {
        if(dcmp(num[n]-num[i]-2*x)>0) break;
    }
    re2=i;
    double m=num[re2]-num[re1];
    a2=num[re1]+x; a=re1,b=re2; d=m;
    if(m-2*x<-eps) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r=1e10;
        int time=200;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=r;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 0.00000000001
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n-1;i++)
    {
        if(num[i]-num[1]-2*x>eps) break;
    }
    re1=i;
    for(i=n-1;i>=2;i--)
    {
        if(num[n]-num[i]-2*x>-eps) break;
    }
    re2=i;
    double m=num[re2]-num[re1];
    a2=num[re1]+m/2; a=re1,b=re2; d=m;
    if(m-2*x<-eps) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r= 1000000000;
        int time=1000;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=r;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 0.000000000000000001
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n-1;i++)
    {
        if(num[i]-num[1]-2*x>-eps) break;
    }
    re1=i;
    for(i=n-1;i>=2;i--)
    {
        if(num[n]-num[i]-2*x>-eps) break;
    }
    re2=i;
    double m=num[re2]-num[re1];
    a2=num[re1]+x; a=re1,b=re2; d=m;
    if(m-2*x<-eps) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r= 1000000000;
        int time=1000;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=r;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 1e-10
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n-1;i++)
    {
        if(num[i]-num[1]-2*x>-eps) break;
    }
    re1=i;
    for(i=n-1;i>=2;i--)
    {
        if(num[n]-num[i]-2*x>-eps) break;
    }
    re2=i;
    double m=num[re2]-num[re1];
    a2=num[re1]+x; a=re1,b=re2; d=m;
    if(m-2*x<-eps) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r= 1000000000;
        int time=50;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=r;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 0.000000001
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n-1;i++)
    {
        if(num[i]-num[1]-2*x>eps) break;
    }
    re1=i;
    for(i=n-1;i>=2;i--)
    {
        if(num[n]-num[i]-2*x>-eps) break;
    }
    re2=i;
    double m=num[re2]-num[re1];
    a2=num[re1]+m/2; a=re1,b=re2; d=m;
    if(m-2*x<-eps) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r= 1000000000;
        int time=1000;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=r;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 1e-10
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n-1;i++)
    {
        if(num[i]-num[1]-2*x>-eps) break;
    }
    re1=i;
    for(i=n-1;i>=2;i--)
    {
        if(num[n]-num[i]-2*x>-eps) break;
    }
    re2=i;
    double m=num[re2]-num[re1];
    a2=num[re1]+x; a=re1,b=re2; d=m;
    if(m-2*x<-eps) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r= 1000000000;
        int time=100;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=r;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 1000000000
#define N 200004
#define eps 1e-10
int n;
double num[N],a1,a2,a3,ans;
int a,b,c;
double d,e,f;
int test(double x)
{
    int re1,re2,i;
    a1=num[1]+x;
    a3=num[n]-x;
    for(i=2;i<=n-1;i++)
    {
        if(num[i]-num[1]-2*x>-eps) break;
    }
    re1=i;
    for(i=n-1;i>=2;i--)
    {
        if(num[n]-num[i]-2*x>-eps) break;
    }
    re2=i;
    double m=num[re2]-num[re1];
    a2=num[re1]+x; a=re1,b=re2; d=m;
    if(m-2*x<-eps) return 1;
    return 0;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%lf",&num[i]);
        sort(num+1,num+n+1);
        //for(int i=1;i<=n;i++) printf("%.0lf ",num[i]);
        double l,r,mid;
        l=0; r= 1000000000;
        int time=500;
        while(time--)
        {
            mid=(l+r)/2;
            if(test(mid))
            {
                ans=r;
                r=mid;
            }
            else
            {
                l=mid;
            }
        }// printf("!! %d %d %lf\n",a,b,d);
        printf("%.6lf\n",ans);
        printf("%.6lf %.6lf %.6lf\n",a1,a2,a3);
    }

    return 0;
}


#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <vector>
#include <stack>
#include <set>
#include <map>
#include <string>
#include <cctype>
#include <cstring>

using namespace std;
double a[200005];
int main()
{
	int n;
	cin>>n;
	for(int i=0;i<n;i++)scanf("%lf",a+i);
	sort(a,a+n);
	double lo=0,hi=1e10,m,last=1e10;
	double x,y,z;
	while(lo<hi){
		m=(lo+hi)/2;
		if(fabs(m-last)<1e-10)break;
		last=m;
		//printf("%lf\n",m);
		int j=0;
		x=a[0]+m;
		while(j<n&&a[j]<=x+m)j++;
		if(j==n){
			hi=m;
			continue;
		}
		y=a[j]+m;
		while(j<n&&a[j]<=y+m)j++;
		if(j==n){
			hi=m;
			continue;
		}
		z=a[j]+m;
		while(j<n&&a[j]<=z+m)j++;
		if(j==n){
			hi=m;
		}
		else {
			lo=m;
		}
	}
	printf("%lf\n",m);
	printf("%lf %lf %lf\n",x,y,z);
	return 0;
}


#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <vector>
#include <stack>
#include <set>
#include <map>
#include <string>
#include <cctype>
#include <cstring>

using namespace std;
double a[200005];
int main()
{
	int n;
	cin>>n;
	for(int i=0;i<n;i++)scanf("%lf",a+i);
	sort(a,a+n);
	double lo=0,hi=1e10,m,last=1e10;
	double x,y,z;
	while(lo<hi-1e-8){
		m=(lo+hi)/2;
		//if(fabs(m-last)<1e-7)break;
		last=m;
		int j=0;
		x=a[0]+m;
		//printf("m=%lf\nx=%lf,",m,x);
		while(j<n&&a[j]<=x+m)j++;
		if(j==n){
			hi=m;
			continue;
		}
		y=a[j]+m;
		//printf("y=%lf,",y);
		while(j<n&&a[j]<=y+m)j++;
		if(j==n){
			hi=m;
			continue;
		}
		z=a[j]+m;
		//printf("z=%lf\n",z);
		while(j<n&&a[j]<=z+m)j++;
		if(j==n){
			hi=m;
		}
		else {
			lo=m;
		}
	}
	printf("%lf\n",m);
	printf("%lf %lf %lf\n",x,y,z);
	return 0;
}


#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <vector>
#include <stack>
#include <set>
#include <map>
#include <string>
#include <cctype>
#include <cstring>

using namespace std;
double a[200005];
int main()
{
	int n;
	cin>>n;
	for(int i=0;i<n;i++)scanf("%lf",a+i);
	sort(a,a+n);
	double lo=0,hi=1e10,m,last=1e10;
	double x,y,z;
	while(lo<hi){
		m=(lo+hi)/2;
		int j=0;
		x=a[0]+m;
		//printf("lo=%lf,hi=%lf,m=%lf\n",lo,hi,m);
		while(j<n&&a[j]<=a[0]+m+m)j++;
		if(j==n){
			hi=m-1e-7;
			continue;
		}
		y=a[j]+m;
		int ty=j;
		//printf("y=%lf,",y);
		while(j<n&&a[j]<=a[ty]+m+m)j++;
		if(j==n){
			hi=m-1e-7;
			continue;
		}
		z=a[j]+m;
		int tz=j;
		//printf("z=%lf\n",z);
		while(j<n&&a[j]<=a[tz]+m+m)j++;
		if(j==n){
			hi=m-1e-7;
		}
		else {
			lo=m+1e-7;
		}
	}
	printf("%lf\n",m);
	printf("%lf %lf %lf\n",x,y,z);
	return 0;
}


#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <vector>
#include <stack>
#include <set>
#include <map>
#include <string>
#include <cctype>
#include <cstring>

using namespace std;
double a[200005];
int main()
{
	int n;
	cin>>n;
	for(int i=0;i<n;i++)scanf("%lf",a+i);
	sort(a,a+n);
	double lo=0,hi=1e10,m,last=1e10;
	double x,y,z;
	while(lo<hi-1e-7){
		m=(lo+hi)/2;
		//if(fabs(m-last)<1e-7)break;
		last=m;
		int j=0;
		x=a[0]+m;
		//printf("m=%lf\nx=%lf,",m,x);
		while(j<n&&a[j]<=x+m)j++;
		if(j==n){
			hi=m;
			continue;
		}
		y=a[j]+m;
		//printf("y=%lf,",y);
		while(j<n&&a[j]<=y+m)j++;
		if(j==n){
			hi=m;
			continue;
		}
		z=a[j]+m;
		//printf("z=%lf\n",z);
		while(j<n&&a[j]<=z+m)j++;
		if(j==n){
			hi=m;
		}
		else {
			lo=m;
		}
	}
	printf("%lf\n",m);
	printf("%lf %lf %lf\n",x,y,z);
	return 0;
}


#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <vector>
#include <stack>
#include <set>
#include <map>
#include <string>
#include <cctype>
#include <cstring>

using namespace std;
double a[200005],b[200005];
int main()
{
	int n=0,n1;
	cin>>n1;
	for(int i=0;i<n1;i++)scanf("%lf",a+i);
	sort(a,a+n1);
	b[n++]=a[0];
	for(int i=1;i<n1;i++)if(b[n-1]!=a[i])b[n++]=a[i];
	//for(int i=0;i<n;i++)printf("%lf\n",b[i]);
	double lo=0,hi=1e10,m;
	double x,y=b[0],z=b[0];
	while(lo<hi){
		m=(lo+hi)/2;
		int j=0;
		x=b[0]+m;
		//printf("lo=%lf,hi=%lf,m=%lf\n",lo,hi,m);
		while(j<n&&b[j]<=x+m)j++;
		if(j==n){
			hi=m-1e-8;
			continue;
		}
		y=b[j]+m;
		int ty=j;
		while(j<n&&b[j]<=y+m)j++;
		if(j==n){
			hi=m-1e-8;
			continue;
		}
		z=b[j]+m;
		int tz=j;
		//printf("z=%lf\n",z);
		while(j<n&&b[j]<=z+m)j++;
		if(j==n){
			hi=m-1e-8;
		}
		else {
			lo=m+1e-8;
		}
	}
	int j=0;
	while(b[j]<=(b[0]+m+m+1e-7))j++;
	if(j<n)y=b[j]+m;
	z=b[n-1]-m;
	printf("%lf\n",m);
	printf("%lf %lf %lf\n",x,y,z);
	return 0;
}


#include <iostream>
#include <algorithm>
#include <cstdio>

#define rep(i,n) for(int i=0;i<n;i++)
#define eps      1e-9

using namespace std;

int n;
double a[200010],t,l,r,pos[10];

int main(){
  cin>>n;
  rep(i,n)cin>>a[i];
  sort(a,a+n);
  l = 0; r = a[n-1];

  rep(ii,100){
    double mid = (l+r)/2;
    int p = 0,b=0;
    rep(i,3){
      if(ii==99)pos[i]=a[b]+mid;
      while(a[b]+2*mid+eps>a[p] && p<n)p++;b=p;
    }
    if(p==n)r=mid;
    else l = mid;
  }
  printf("%.6f\n",r);
  rep(i,3)printf("%.6f ",pos[i]);

}


#include <iostream>
#include <algorithm>
#include <cstdio>

#define rep(i,n) for(int i=0;i<n;i++)

using namespace std;

int n;
double a[200010],t,l,r,pos[10];

int main(){
  cin>>n;
  rep(i,n)cin>>a[i];
  sort(a,a+n);
  l = 0; r = a[n-1];

  rep(ii,100){
    double mid = (l+r)/2;
    int p = 0,b=0;
    rep(i,3){
      if(ii==99)pos[i]=a[b]+mid;
      while(a[b]+2*mid>=a[p] && p<n)p++;b=p;
    }
    if(p==n)r=mid;
    else l = mid;
  }
  printf("%.6f\n",r);
  rep(i,3)printf("%.6f ",pos[i]);

}


#include <iostream>
#include <algorithm>
#include <cstdio>

#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;

int n;
double a[200010],t,l,r,pos[10];

int main(){
  cin>>n;
  rep(i,n)cin>>a[i];
  sort(a,a+n);
  l = 0; r = a[n-1];

  rep(ii,100){
    double mid = (l+r)/2;
    int p = 0,b=0;
    rep(i,3){
      if(ii==99)pos[i]=a[b]+mid;
      while(a[p]-a[b]<=2.0*mid && p<n)p++;
      b=p;
    }
    if(p==n)r=mid;
    else l = mid;
  }
  printf("%.6f\n",r);
  rep(i,3)printf("%.6f ",pos[i]);

}


#include <iostream>
#include <algorithm>
#include <cstdio>

#define rep(i,n) for(int i=0;i<n;i++)
#define eps      1e-9

using namespace std;

int n;
double a[200010],t,l,r,pos[10];

int main(){
  cin>>n;
  rep(i,n)cin>>a[i];
  sort(a,a+n);
  l = 0; r = a[n-1];

  rep(ii,100){
    double mid = (l+r)/2;
    int p = 0,b=0;
    rep(i,3){
      if(ii==99)pos[i]=a[b]+mid;
      while(a[b]+2*mid+eps>=a[p] && p<n)p++;b=p;
    }
    if(p==n)r=mid;
    else l = mid;
  }
  printf("%.6f\n",r);
  rep(i,3)printf("%.6f ",pos[i]);

}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define LL long long
#define N 200005

int jml,sem,ya;
LL ki,ka,piv;
double jawab,p,d,ar[N],maks;
bool flag;

int main()
{
    scanf("%d",&jml);
    ka = ki = 0;
    for (int i=1;i<=jml;i++)
    {
        scanf("%lf",&ar[i]);
        ka = max(ka,(LL)ar[i]);
    }

    sort(ar+1,ar+1+jml);

    maks = (double)ka;
    jawab = 2000000000.0;
    ki *= 1000000LL;
    ka *= 1000000LL;
    while (ki <= ka)
    {
        piv = (ki+ka)/2LL; //powernya
        d = (double)piv / 1000000.0;
        p = ar[1] + d;
        sem = 1;
        for (int i=2;i<=jml;i++)
        {
            if (p+d < ar[i])
            {
                sem++;
                p = min(ar[i] + d,maks);
            }
        }
        if (sem <= 3)
        {
            jawab = min(jawab,d);
            ka = piv-1LL;
        }
        else ki = piv+1LL;
    }

    printf("%.6lf\n",jawab);
    p = ar[1] + jawab;
    printf("%.6lf",p);
    for (int i=2;i<=jml;i++)
    {
        if (p+jawab < ar[i])
        {
            ya++;
            p = min(ar[i] + jawab,maks);
            printf(" %.6lf",p);
        }
    }
    if (ya<1) printf(" %.6lf",p);
    if (ya<2) printf(" %.6lf",p);
    printf("\n");

//    system("PAUSE");
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define LL long long
#define N 200005

int jml,sem,ya;
LL ki,ka,piv;
double jawab,p,d,ar[N];
bool flag;

int main()
{
    scanf("%d",&jml);
    ka = ki = 0;
    for (int i=1;i<=jml;i++)
    {
        scanf("%lf",&ar[i]);
        ka = max(ka,(LL)ar[i]);
    }

    sort(ar+1,ar+1+jml);

    jawab = 2000000000.0;
    ki *= 1000000LL;
    ka *= 1000000LL;
    while (ki <= ka)
    {
        piv = (ki+ka)/2LL; //powernya
        d = (double)piv / 1000000.0;
        p = 0.0;
        sem = 0;
        for (int i=1;i<=jml;i++)
        {
            if (p+d < ar[i])
            {
                sem++;
                p = ar[i] + d;
            }
        }
        if (sem <= 3)
        {
            jawab = min(jawab,d);
            ka = piv-1LL;
        }
        else ki = piv+1LL;
    }

    printf("%.6lf\n",jawab);
    p = 0.0;
    for (int i=1;i<=jml;i++)
    {
        if (p+jawab < ar[i])
        {
            if (flag) printf(" ");
            flag = true;
            ya++;
            p = ar[i] + jawab;
            printf("%.6lf",p);
        }
    }
    if (ya<2) printf(" %.6lf",p);
    if (ya<3) printf(" %.6lf",p);
    printf("\n");

//    system("PAUSE");
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define LL long long
#define N 200005

int jml,sem,ya;
LL ki,ka,piv;
double jawab,p,d,ar[N],maks;
bool flag;

int main()
{
    scanf("%d",&jml);
    ka = ki = 0;
    for (int i=1;i<=jml;i++)
    {
        scanf("%lf",&ar[i]);
        ka = max(ka,(LL)ar[i]);
    }

    sort(ar+1,ar+1+jml);

    maks = (double)ka;
    jawab = 2000000000.0;
    ki *= 1000000LL;
    ka *= 1000000LL;
    while (ki <= ka)
    {
        piv = (ki+ka)/2LL; //powernya
        d = (double)piv / 1000000.0;
        p = ar[1] + d;
        sem = 1;
        for (int i=2;i<=jml;i++)
        {
            if (p+d < ar[i])
            {
                sem++;
                p = min(ar[i] + d,maks);
            }
        }
        if (sem <= 3)
        {
            jawab = min(jawab,d);
            ka = piv-1LL;
        }
        else ki = piv+1LL;
    }

    printf("%.6lf\n",jawab);
    p = ar[1] + jawab;
    printf("%.6lf",p);
    for (int i=2;i<=jml;i++)
    {
        if (p+jawab < ar[i])
        {
            ya++;
            p = min(ar[i] + jawab,maks);
            printf(" %.6lf",p);
        }
    }
    if (ya<1) printf(" %.6lf",p);
    if (ya<2) printf(" %.6lf",p);
    printf("\n");

//    system("PAUSE");
//cuma ngulang
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define LL long long
#define N 200005

int jml,sem,ya;
LL ki,ka,piv;
double jawab,p,d,ar[N];
bool flag;

int main()
{
    scanf("%d",&jml);
    ka = ki = 0;
    for (int i=1;i<=jml;i++)
    {
        scanf("%lf",&ar[i]);
        ka = max(ka,(LL)ar[i]);
    }

    sort(ar+1,ar+1+jml);

    jawab = 2000000000.0;
    ki *= 1000000LL;
    ka *= 1000000LL;
    while (ki <= ka)
    {
        piv = (ki+ka)/2LL; //powernya
        d = (double)piv / 1000000.0;
        p = 0.0;
        sem = 0;
        for (int i=1;i<=jml;i++)
        {
            if (p+d < ar[i])
            {
                sem++;
                p = ar[i] + d;
            }
        }
        if (sem <= 3)
        {
            jawab = min(jawab,d);
            ka = piv-1LL;
        }
        else ki = piv+1LL;
    }

    printf("%.6lf\n",jawab);
    p = 0.0;
    for (int i=1;i<=jml;i++)
    {
        if (p+jawab < ar[i])
        {
            if (flag) printf(" ");
            flag = true;
            ya++;
            p = ar[i] + jawab;
            printf("%.6lf",p);
        }
    }
    if (ya<2) printf(" %.6lf",p);
    if (ya<3) printf(" %.6lf",p);
    printf("\n");

//    system("PAUSE");
    return 0;
}


#include<iostream>
#include<sstream>

#include<vector>
#include<string>
#include<queue>
#include<map>
#include<set>
#include<stack>

#include<algorithm>
#include<utility>
#include<functional>
#include<iterator>
#include<iomanip>

#include<cstdio>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<cstring>

#define FOR(i,a,n) for(int i =(int)(a); i < (int)(n); i++)
#define REP(i, n) FOR(i,0,n)
#define ALL(v) (v).begin(), (v).end()
#define FOR_EACH(i,v) for(__typeof((v).begin())i=(v).begin();i!=(v).end();i++)
#define MP make_pair

using namespace std;

long double EPS(1.0e-10);

bool coverable(long double d, vector<int>& dat){
  long double sep = dat[0] + d;
  vector<int>::iterator ite = upper_bound(ALL(dat), (int)(sep+EPS));
  if(ite == dat.end()) return true;
  sep = (*ite) + d;
  ite = upper_bound(ALL(dat), (int)(sep+EPS));
  if(ite == dat.end()) return true;
  long double end = (*ite) + d;
  if(end+EPS >= dat.back()) return true;
  else return false;
}

int main(){
  int n;
  scanf("%d", &n);
  vector<int> dat(n);
  REP(i, n){
    scanf("%d",&dat[i]);
  }
  sort(ALL(dat));
  long double minv(0), maxv(1e10);
  REP(i, 10000){
    long double d = (minv + maxv);
    long double midv(d * 0.5);
    if(coverable(d, dat)){
      maxv = midv;
    }else{
      minv = midv;
    }
  }
  printf("%.6f\n", (double)minv);
  double p1 = dat[0] + minv;
  vector<int>::iterator ite = upper_bound(ALL(dat), p1+minv);
  double p2 = ite != dat.end() ? (*ite) + minv : min(p1+minv, 2.0L*1000000000);
  double p3 = max(0.0L, dat.back() - minv);
  printf("%.6f %.6f %.6f\n", p1, p2, p3);
  return 0;
}


#include<iostream>
#include<sstream>

#include<vector>
#include<string>
#include<queue>
#include<map>
#include<set>
#include<stack>

#include<algorithm>
#include<utility>
#include<functional>
#include<iterator>
#include<iomanip>

#include<cstdio>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<cstring>

#define FOR(i,a,n) for(int i =(int)(a); i < (int)(n); i++)
#define REP(i, n) FOR(i,0,n)
#define ALL(v) (v).begin(), (v).end()
#define FOR_EACH(i,v) for(__typeof((v).begin())i=(v).begin();i!=(v).end();i++)
#define MP make_pair

using namespace std;

long double EPS(1.0e-10);

bool coverable(long double d, vector<int>& dat){
  long double sep = dat[0] + d;
  vector<int>::iterator ite = upper_bound(ALL(dat), (int)(sep+EPS));
  if(ite == dat.end()) return true;
  sep = (*ite) + d;
  ite = upper_bound(ALL(dat), (int)(sep+EPS));
  if(ite == dat.end()) return true;
  long double end = (*ite) + d;
  if(end+EPS >= dat.back()) return true;
  else return false;
}

int main(){
  int n;
  scanf("%d", &n);
  vector<int> dat(n);
  REP(i, n){
    scanf("%d",&dat[i]);
  }
  sort(ALL(dat));
  long double minv(0), maxv(1e10);
  REP(i, 10000){
    long double d = (minv + maxv);
    long double midv(d * 0.5);
    if(coverable(d, dat)){
      maxv = midv;
    }else{
      minv = midv;
    }
  }
  printf("%.6f\n", (double)minv);
  long double p1 = dat[0] + minv;
  vector<int>::iterator ite = upper_bound(ALL(dat), (int)(p1+minv+EPS));
  long double p2 = ite != dat.end() ? (*ite) + minv : min(p1+minv, 2.0L*1000000000);
  long double p3 = max(0.0L, dat.back() - minv);
  printf("%.6f %.6f %.6f\n", (double)p1, (double)p2, (double)p3);
  return 0;
}


#include<iostream>
#include<sstream>

#include<vector>
#include<string>
#include<queue>
#include<map>
#include<set>
#include<stack>

#include<algorithm>
#include<utility>
#include<functional>
#include<iterator>
#include<iomanip>

#include<cstdio>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<cstring>

#define FOR(i,a,n) for(int i =(int)(a); i < (int)(n); i++)
#define REP(i, n) FOR(i,0,n)
#define ALL(v) (v).begin(), (v).end()
#define FOR_EACH(i,v) for(__typeof((v).begin())i=(v).begin();i!=(v).end();i++)
#define MP make_pair

using namespace std;

long double EPS(1.0e-10);

int idx_upperthan(int begin, long double threshold, vector<int>& dat){
  FOR(i, begin, dat.size()) if(dat[i] > threshold + EPS) return i;
  return (int)dat.size();
}
bool coverable(long double d, vector<int>& dat){
  long double sep = dat[0] + d;
  int idx = idx_upperthan(0, sep, dat);
  if(idx == dat.size()) return true;
  sep = dat[idx] + d;
  idx = idx_upperthan(idx, sep, dat);
  if(idx == dat.size()) return true;
  long double end = dat[idx] + d;
  if(end+EPS >= dat.back()) return true;
  else return false;
}

int main(){
  int n;
  scanf("%d", &n);
  vector<int> dat(n);
  REP(i, n){
    scanf("%d",&dat[i]);
  }
  sort(ALL(dat));
  long double minv(0), maxv(1e10);
  REP(i, 100){
    long double d = (minv + maxv);
    long double midv(d * 0.5);
    if(coverable(d, dat)){
      maxv = midv;
    }else{
      minv = midv;
    }
  }
  printf("%.6f\n", (double)minv);
  long double p1 = dat[0] + minv;
  int idx = idx_upperthan(0, p1+minv, dat);
  long double p2 = min(idx != (int)dat.size() ? dat[idx] + minv : p1+minv, 2.0L*1000000000);
  long double p3 = max(0.0L, dat.back() - minv);
  printf("%.6f %.6f %.6f\n", (double)p1, (double)p2, (double)p3);
  return 0;
}


#include<iostream>
#include<sstream>

#include<vector>
#include<string>
#include<queue>
#include<map>
#include<set>
#include<stack>

#include<algorithm>
#include<utility>
#include<functional>
#include<iterator>
#include<iomanip>

#include<cstdio>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<cstring>

#define FOR(i,a,n) for(int i =(int)(a); i < (int)(n); i++)
#define REP(i, n) FOR(i,0,n)
#define ALL(v) (v).begin(), (v).end()
#define FOR_EACH(i,v) for(__typeof((v).begin())i=(v).begin();i!=(v).end();i++)
#define MP make_pair

using namespace std;

long double EPS(1.0e-10);

bool coverable(long double d, vector<int>& dat){
  long double sep = dat[0] + d;
  vector<int>::iterator ite = upper_bound(ALL(dat), (int)(sep+EPS));
  if(ite == dat.end()) return true;
  sep = (*ite) + d;
  ite = upper_bound(ALL(dat), (int)(sep+EPS));
  if(ite == dat.end()) return true;
  long double end = (*ite) + d;
  if(end+EPS >= dat.back()) return true;
  else return false;
}

int main(){
  int n;
  scanf("%d", &n);
  vector<int> dat(n);
  REP(i, n){
    scanf("%d",&dat[i]);
  }
  sort(ALL(dat));
  long double minv(0), maxv(1e10);
  REP(i, 10000){
    long double d = (minv + maxv);
    long double midv(d * 0.5);
    if(coverable(d, dat)){
      maxv = midv;
    }else{
      minv = midv;
    }
  }
  printf("%.6Lf\n", minv);
  double p1 = dat[0] + minv;
  vector<int>::iterator ite = upper_bound(ALL(dat), p1+minv);
  double p2 = ite != dat.end() ? (*ite) + minv : min(p1+minv, 2.0L*1000000000);
  double p3 = max(0.0L, dat.back() - minv);
  printf("%.6f %.6f %.6f\n", p1, p2, p3);
  return 0;
}


#include<iostream>
#include<sstream>

#include<vector>
#include<string>
#include<queue>
#include<map>
#include<set>
#include<stack>

#include<algorithm>
#include<utility>
#include<functional>
#include<iterator>
#include<iomanip>

#include<cstdio>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<cstring>

#define FOR(i,a,n) for(int i =(int)(a); i < (int)(n); i++)
#define REP(i, n) FOR(i,0,n)
#define ALL(v) (v).begin(), (v).end()
#define FOR_EACH(i,v) for(__typeof((v).begin())i=(v).begin();i!=(v).end();i++)
#define MP make_pair

using namespace std;

long double EPS(1.0e-10);
long double delta(1.0e-12);

bool coverable(long double d, vector<int>& dat){
  long double sep = dat[0] + d;
  vector<int>::iterator ite = upper_bound(ALL(dat), (int)(sep+delta));
  if(ite == dat.end()) return true;
  sep = (*ite) + d;
  ite = upper_bound(ALL(dat), (int)(sep+delta));
  if(ite == dat.end()) return true;
  long double end = (*ite) + d;
  if(end+delta >= dat.back()) return true;
  else return false;
}

int main(){
  int n;
  scanf("%d", &n);
  vector<int> dat(n);
  REP(i, n){
    scanf("%d",&dat[i]);
  }
  sort(ALL(dat));
  long double minv(0), maxv(1e10);
  REP(i, 10000){
    long double d = (minv + maxv);
    long double midv(d * 0.5);
    if(coverable(d, dat)){
      maxv = midv;
    }else{
      minv = midv;
    }
  }
  printf("%.6f\n", (double)minv);
  long double p1 = dat[0] + minv;
  vector<int>::iterator ite = upper_bound(ALL(dat), (int)(p1+minv+EPS));
  long double p2 = ite != dat.end() ? (*ite) + minv : min(p1+minv, 2.0L*1000000000);
  long double p3 = max(0.0L, dat.back() - minv);
  printf("%.6f %.6f %.6f\n", (double)p1, (double)p2, (double)p3);
  return 0;
}


#include<iostream>
#include<sstream>

#include<vector>
#include<string>
#include<queue>
#include<map>
#include<set>
#include<stack>

#include<algorithm>
#include<utility>
#include<functional>
#include<iterator>
#include<iomanip>

#include<cstdio>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<cstring>

#define FOR(i,a,n) for(int i =(int)(a); i < (int)(n); i++)
#define REP(i, n) FOR(i,0,n)
#define ALL(v) (v).begin(), (v).end()
#define FOR_EACH(i,v) for(__typeof((v).begin())i=(v).begin();i!=(v).end();i++)
#define MP make_pair

using namespace std;

long double EPS(1.0e-10);
long double delta(1.0e-12);

int idx_upperthan(int begin, long double threshold, vector<int>& dat, long double eps){
  FOR(i, begin, dat.size()) if(dat[i] > threshold + eps)  return i;
  return (int)dat.size();
}
bool coverable(long double d, vector<int>& dat){
  long double sep = dat[0] + d;
  int idx = idx_upperthan(0, sep, dat, delta);
  if(idx == dat.size()) return true;
  sep = dat[idx] + d;
  idx = idx_upperthan(idx, sep, dat, delta);
  if(idx == dat.size()) return true;
  long double end = dat[idx] + d;
  if(end+delta >= dat.back()) return true;
  else return false;
}

int main(){
  int n;
  scanf("%d", &n);
  vector<int> dat(n);
  REP(i, n){
    scanf("%d",&dat[i]);
  }
  sort(ALL(dat));
  long double minv(0), maxv(1e10);
  REP(i, 100){
    long double d = (minv + maxv);
    long double midv(d * 0.5);
    if(coverable(d, dat)){
      maxv = midv;
    }else{
      minv = midv;
    }
  }
  printf("%.6f\n", (double)minv);
  long double p1 = dat[0] + minv;
  int idx = idx_upperthan(0, p1+minv, dat, EPS);
  //cerr << idx << " " << dat[idx] << " " << p1+minv << endl;
  long double p2 = min(idx != (int)dat.size() ? dat[idx] + minv : p1+minv, 2.0L*1000000000);
  long double p3 = max(0.0L, dat.back() - minv);
  printf("%.6f %.6f %.6f\n", (double)p1, (double)p2, (double)p3);
  return 0;
}


#include<iostream>
#include<sstream>

#include<vector>
#include<string>
#include<queue>
#include<map>
#include<set>
#include<stack>

#include<algorithm>
#include<utility>
#include<functional>
#include<iterator>
#include<iomanip>

#include<cstdio>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<cstring>

#define FOR(i,a,n) for(int i =(int)(a); i < (int)(n); i++)
#define REP(i, n) FOR(i,0,n)
#define ALL(v) (v).begin(), (v).end()
#define FOR_EACH(i,v) for(__typeof((v).begin())i=(v).begin();i!=(v).end();i++)
#define MP make_pair

using namespace std;

long double EPS(1.0e-10);

int idx_upperthan(int begin, long double threshold, vector<int>& dat){
  FOR(i, begin, dat.size()) if(dat[i] > threshold + EPS) return i;
  return (int)dat.size();
}
bool coverable(long double d, vector<int>& dat){
  long double sep = dat[0] + d;
  int idx = idx_upperthan(0, sep, dat);
  if(idx == dat.size()) return true;
  sep = dat[idx] + d;
  idx = idx_upperthan(idx, sep, dat);
  if(idx == dat.size()) return true;
  long double end = dat[idx] + d;
  if(end+EPS >= dat.back()) return true;
  else return false;
}

int main(){
  int n;
  scanf("%d", &n);
  vector<int> dat(n);
  REP(i, n){
    scanf("%d",&dat[i]);
  }
  sort(ALL(dat));
  long double minv(0), maxv(1e10);
  REP(i, 10000){
    long double d = (minv + maxv);
    long double midv(d * 0.5);
    if(coverable(d, dat)){
      maxv = midv;
    }else{
      minv = midv;
    }
  }
  printf("%.6f\n", (double)minv);
  long double p1 = dat[0] + minv;
  vector<int>::iterator ite = upper_bound(ALL(dat), (int)(p1+minv+EPS));
  int idx = idx_upperthan(0, p1+minv+EPS, dat);
  long double p2 = idx != min((int)dat.size() ? dat[idx] + minv : p1+minv, 2.0L*1000000000);
  long double p3 = max(0.0L, dat.back() - minv);
  printf("%.6f %.6f %.6f\n", (double)p1, (double)p2, (double)p3);
  return 0;
}


#include<iostream>
#include<sstream>

#include<vector>
#include<string>
#include<queue>
#include<map>
#include<set>
#include<stack>

#include<algorithm>
#include<utility>
#include<functional>
#include<iterator>
#include<iomanip>

#include<cstdio>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<cstring>

#define FOR(i,a,n) for(int i =(int)(a); i < (int)(n); i++)
#define REP(i, n) FOR(i,0,n)
#define ALL(v) (v).begin(), (v).end()
#define FOR_EACH(i,v) for(__typeof((v).begin())i=(v).begin();i!=(v).end();i++)
#define MP make_pair

using namespace std;

long double EPS(1.0e-10);
long double delta(1.0e-12);

int idx_upperthan(int begin, long double threshold, vector<int>& dat){
  FOR(i, begin, dat.size()) if(dat[i] > threshold + EPS)  return i;
  return (int)dat.size();
}
bool coverable(long double d, vector<int>& dat){
  long double sep = dat[0] + d;
  int idx = idx_upperthan(0, sep, dat);
  if(idx == dat.size()) return true;
  sep = dat[idx] + d;
  idx = idx_upperthan(idx, sep, dat);
  if(idx == dat.size()) return true;
  long double end = dat[idx] + d;
  if(end+delta >= dat.back()) return true;
  else return false;
}

int main(){
  int n;
  scanf("%d", &n);
  vector<int> dat(n);
  REP(i, n){
    scanf("%d",&dat[i]);
  }
  sort(ALL(dat));
  long double minv(0), maxv(1e10);
  REP(i, 10000){
    long double d = (minv + maxv);
    long double midv(d * 0.5);
    if(coverable(d, dat)){
      maxv = midv;
    }else{
      minv = midv;
    }
  }
  printf("%.6f\n", (double)minv);
  long double p1 = dat[0] + minv;
  int idx = idx_upperthan(0, p1+minv, dat);
  //cerr << idx << " " << dat[idx] << " " << p1+minv << endl;
  long double p2 = min(idx != (int)dat.size() ? dat[idx] + minv : p1+minv, 2.0L*1000000000);
  long double p3 = max(0.0L, dat.back() - minv);
  printf("%.6f %.6f %.6f\n", (double)p1, (double)p2, (double)p3);
  return 0;
}


#include<iostream>
#include<sstream>

#include<vector>
#include<string>
#include<queue>
#include<map>
#include<set>
#include<stack>

#include<algorithm>
#include<utility>
#include<functional>
#include<iterator>
#include<iomanip>

#include<cstdio>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<cstring>

#define FOR(i,a,n) for(int i =(int)(a); i < (int)(n); i++)
#define REP(i, n) FOR(i,0,n)
#define ALL(v) (v).begin(), (v).end()
#define FOR_EACH(i,v) for(__typeof((v).begin())i=(v).begin();i!=(v).end();i++)
#define MP make_pair

using namespace std;

long double EPS(1.0e-10);

int idx_upperthan(int begin, long double threshold, vector<int>& dat){
  FOR(i, begin, dat.size()) if(dat[i] > threshold + EPS) return i;
  return (int)dat.size();
}
bool coverable(long double d, vector<int>& dat){
  long double sep = dat[0] + d;
  int idx = idx_upperthan(0, sep, dat);
  if(idx == dat.size()) return true;
  sep = dat[idx] + d;
  idx = idx_upperthan(idx, sep, dat);
  if(idx == dat.size()) return true;
  long double end = dat[idx] + d;
  if(end+EPS >= dat.back()) return true;
  else return false;
}

int main(){
  int n;
  scanf("%d", &n);
  vector<int> dat(n);
  REP(i, n){
    scanf("%d",&dat[i]);
  }
  sort(ALL(dat));
  long double minv(0), maxv(1e10);
  REP(i, 80){
    long double d = (minv + maxv);
    long double midv(d * 0.5);
    if(coverable(d, dat)){
      maxv = midv;
    }else{
      minv = midv;
    }
  }
  printf("%.6f\n", (double)minv);
  long double p1 = dat[0] + minv;
  vector<int>::iterator ite = upper_bound(ALL(dat), (int)(p1+minv+EPS));
  int idx = idx_upperthan(0, p1+minv, dat);
  long double p2 = min(idx != (int)dat.size() ? dat[idx] + minv : p1+minv, 2.0L*1000000000);
  long double p3 = max(0.0L, dat.back() - minv);
  printf("%.6f %.6f %.6f\n", (double)p1, (double)p2, (double)p3);
  return 0;
}


#include <cstdio>
#include <set>
#include <algorithm>

unsigned int houses[100000];
unsigned int houses_cnt=0;

unsigned int stations[3];

bool test(unsigned int D){
  //fprintf(stderr,"test %u: ",D);
  unsigned int *p=houses;
  for(unsigned int i=0;i<3;i++){
    unsigned int *p2=std::upper_bound(houses,houses+houses_cnt,*p+D);
    if(p2==houses+houses_cnt){
      for(;i<3;i++){
	stations[i]=*p*2+D;
      }
      //fprintf(stderr,"%d %d %d\n",stations[0],stations[1],stations[2]);
      return true;
    }
    stations[i]=*p*2+D;
    p=p2;
  }
  //fprintf(stderr,"failed\n");
  return false;
}

void printhalf(unsigned int num){
  if(num%2==0){
    printf("%d.000000",num/2);
  }else{
    printf("%d.500000",num/2);
  }
}

int main(){
  std::set<unsigned int> hs;
  unsigned int N;
  scanf("%u",&N);
  for(unsigned int i=0;i<N;i++){
    unsigned int H;
    scanf("%d",&H);
    hs.insert(H);
  }
  for(std::set<unsigned int>::iterator
	it=hs.begin();it!=hs.end();it++){
    houses[houses_cnt++]=*it;
  }

  unsigned int low=-1,high=1e9;
  while(high-low>1){
    unsigned int mid=(low+high)/2;
    if(test(mid)){
      high=mid;
    }else{
      low=mid;
    }
  }
  test(high);
  printhalf(high);
  printf("\n");
  for(int i=0;i<3;i++){
    printhalf(stations[i]);
    if(i<2){
      printf(" ");
    }else{
      printf("\n");
    }
  }
  return 0;
}


#include <cstdio>
#include <set>
#include <algorithm>

unsigned int houses[100000];
unsigned int houses_cnt=0;

unsigned int stations[3];

bool test(unsigned int D){
  fprintf(stderr,"test %u: ",D);
  unsigned int *p=houses;
  for(unsigned int i=0;i<3;i++){
    unsigned int *p2=std::upper_bound(houses,houses+houses_cnt,*p+D);
    if(p2==houses+houses_cnt){
      for(;i<3;i++){
	stations[i]=*p*2+D;
      }
      fprintf(stderr,"%d %d %d\n",stations[0],stations[1],stations[2]);
      return true;
    }
    stations[i]=*p*2+D;
    p=p2;
  }
  fprintf(stderr,"failed\n");
  return false;
}

int main(){
  std::set<unsigned int> hs;
  unsigned int N;
  scanf("%u",&N);
  for(unsigned int i=0;i<N;i++){
    unsigned int H;
    scanf("%d",&H);
    hs.insert(H);
  }
  for(std::set<unsigned int>::iterator
	it=hs.begin();it!=hs.end();it++){
    houses[houses_cnt++]=*it;
  }

  unsigned int low=-1,high=1e9;
  while(high-low>1){
    unsigned int mid=(low+high)/2;
    if(test(mid)){
      high=mid;
    }else{
      low=mid;
    }
  }
  printf("%d\n",high);
  for(int i=0;i<3;i++){
    if(stations[i]%2==0){
      printf("%d.000000",stations[i]/2);
    }else{
      printf("%d.500000",stations[i]/2);
    }
    if(i<2){
      printf(" ");
    }else{
      printf("\n");
    }
  }
  return 0;
}


#include <cstdio>
#include <set>
#include <algorithm>

unsigned int houses[100000];
unsigned int houses_cnt=0;

unsigned int stations[3];

bool test(unsigned int D){
  //fprintf(stderr,"test %u: ",D);
  unsigned int *p=houses;
  for(unsigned int i=0;i<3;i++){
    unsigned int *p2=std::upper_bound(houses,houses+houses_cnt,*p+D);
    if(p2==houses+houses_cnt){
      for(;i<3;i++){
	stations[i]=*p*2+D;
      }
      //fprintf(stderr,"%d %d %d\n",stations[0],stations[1],stations[2]);
      return true;
    }
    stations[i]=*p*2+D;
    p=p2;
  }
  //fprintf(stderr,"failed\n");
  return false;
}

void printhalf(unsigned int num){
  if(num%2==0){
    printf("%d.000000",num/2);
  }else{
    printf("%d.500000",num/2);
  }
}

int main(){
  std::set<unsigned int> hs;
  unsigned int N;
  scanf("%u",&N);
  for(unsigned int i=0;i<N;i++){
    unsigned int H;
    scanf("%d",&H);
    hs.insert(H);
  }
  for(std::set<unsigned int>::iterator
	it=hs.begin();it!=hs.end();it++){
    houses[houses_cnt++]=*it;
  }

  unsigned int low=-1,high=1e9;
  while(high-low>1){
    unsigned int mid=(low+high)/2;
    if(test(mid)){
      high=mid;
    }else{
      low=mid;
    }
  }
  printhalf(high);
  printf("\n");
  for(int i=0;i<3;i++){
    printhalf(stations[i]);
    if(i<2){
      printf(" ");
    }else{
      printf("\n");
    }
  }
  return 0;
}


#include <cstdio>
#include <set>
#include <algorithm>

unsigned int houses[200000];
unsigned int houses_cnt=0;

unsigned int stations[3];

bool test(unsigned int D){
  //fprintf(stderr,"test %u: ",D);
  unsigned int *p=houses;
  for(unsigned int i=0;i<3;i++){
    unsigned int *p2=std::upper_bound(houses,houses+houses_cnt,*p+D);
    if(p2==houses+houses_cnt){
      for(;i<3;i++){
	stations[i]=*p*2+D;
      }
      //fprintf(stderr,"%d %d %d\n",stations[0],stations[1],stations[2]);
      return true;
    }
    stations[i]=*p*2+D;
    p=p2;
  }
  //fprintf(stderr,"failed\n");
  return false;
}

void printhalf(unsigned int num){
  if(num%2==0){
    printf("%d.000000",num/2);
  }else{
    printf("%d.500000",num/2);
  }
}

int main(){
  std::set<unsigned int> hs;
  unsigned int N;
  scanf("%u",&N);
  for(unsigned int i=0;i<N;i++){
    unsigned int H;
    scanf("%d",&H);
    hs.insert(H);
  }
  for(std::set<unsigned int>::iterator
	it=hs.begin();it!=hs.end();it++){
    houses[houses_cnt++]=*it;
  }

  unsigned int low=-1,high=1e9;
  while(high-low>1){
    unsigned int mid=(low+high)/2;
    if(test(mid)){
      high=mid;
    }else{
      low=mid;
    }
  }
  test(high);
  printhalf(high);
  printf("\n");
  for(int i=0;i<3;i++){
    printhalf(stations[i]);
    if(i<2){
      printf(" ");
    }else{
      printf("\n");
    }
  }
  return 0;
}


#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include <stdio.h>

using namespace std;

long long H[300100];

bool can(long long d, int n) {

	int last = 0;
	int cnt = 1;

	for(int i=0 ; i<n ; i++) {
		if(H[i]-H[last] > d ){
			cnt++;
			last = i;
		}
	}
	return cnt<=3;
}

int main() {

	int n;
	cin >> n;
	for(int i=0 ; i<n ; i++) cin >> H[i];

	sort(H, H+n);

	long long l=0, r=2000000001LL;
	while(l<r) {
		long long mid = (l+r)/2LL;
		if( can(mid, n) ) r = mid;
		else l = mid+1;
	}

	printf("%.6lf\n", (double)l/2.);

	int last = 0;
	int cnt = 0;

	for(int i=0 ; i<n ; i++) {
		if(H[i]-H[last] > l ){
			printf("%.6lf ", ((double)H[i-1]+H[last])/2.);
			cnt++;
			last = i;
		}
	}

	while(cnt < 3) {
		printf("%.6lf ", ((double)H[n-1]+H[last])/2.);
		cnt++;
	}
	printf("\n");

	return 0;
}


#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include <stdio.h>

using namespace std;

long long H[100100];

bool can(long long d, int n) {

	int last = 0;
	int cnt = 1;

	for(int i=0 ; i<n ; i++) {
		if(H[i]-H[last] > d ){
			cnt++;
			last = i;
		}
	}
	return cnt<=3;
}

int main() {

	int n;
	cin >> n;
	for(int i=0 ; i<n ; i++) cin >> H[i];

	sort(H, H+n);

	long long l=0, r=2000000001LL;
	while(l<r) {
		long long mid = (l+r)/2LL;
		if( can(mid, n) ) r = mid;
		else l = mid+1;
	}

	printf("%.6lf\n", (double)l/2.);

	int last = 0;
	int cnt = 0;

	for(int i=0 ; i<n ; i++) {
		if(H[i]-H[last] > l ){
			printf("%.6lf ", ((double)H[i-1]+H[last])/2.);
			cnt++;
			last = i;
		}
	}

	while(cnt < 3) {
		printf("%.6lf ", ((double)H[n-1]+H[last])/2.);
		cnt++;
	}
	printf("\n");

	return 0;
}


//80081TU
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>

using namespace std;

#define REP(i, n) for(int i=0;i<int(n);i++)
#define PB push_back
#define MP(X,Y) make_pair(X,Y)
#define SZ(X) ((int)(X.size()))
#define ALL(x)   (x).begin(),(x).end()
#define foreach(it, c)  for(typeof((c).begin()) it = (c).begin();it!=(c).end();++it)
#define F first
#define S second
#define CLEAR(A, V) memset(A, V, sizeof(A))

typedef  long long   ll;
typedef vector<int> VI;
typedef vector<string> VS;
typedef pair<int,int> II;
typedef vector<II> VII;

template<class T> inline int countbit(T n){return (n==0)?0:(1+countbit(n&(n-1)));}
template<class T> inline T gcd(T a, T b){ return b?gcd(b, a%b):a;}
const double EPS = 1e-7;
const double PI = acos(-1.0);

int n;
VI H;

int can(ll d) {

	int last = 0;
	int cnt = 1;

	for(int i=0 ; i<n ; i++) {
		ll aux = H[i] - H[last];
		if( aux <= d) continue;
		else {
			cnt++;
			last = i;
		}
	}

	return cnt <= 3;
}

int main(void) {

	set<int> Q;
	int x;
	cin >> n;
	REP(i, n) {
		cin >> x;
		Q.insert(x);
	}
	H = vector<int>(ALL(Q));
	n = SZ(H);

	ll l=0LL, r=2000000000LL;
	while(l<r-EPS) {
		ll mid = (l+r)/2.;
		if(can(mid)) r = mid;
		else l = mid+1;
	}
	printf("%.6lf\n", l/2.);

	int last = 0;
	int cnt = 0;
	ll d = l;
	for(int i=0 ; i<n ; i++) {
		ll aux = H[i] - H[last];

		if( aux <= d) continue;
		else {
			printf("%.6lf ", (H[i-1] - H[last])/2.+H[last]);
			cnt ++;
			last = i;
		}
	}
	while(cnt<3){
		printf("%.6lf ", (H[n-1] - H[last])/2.+H[last]);
		cnt++;
	}
	printf("\n");

	return 0;
}


#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include <stdio.h>

using namespace std;

int H[100100];

bool can(int d, int n) {

	int last = 0;
	int cnt = 1;

	for(int i=0 ; i<n ; i++) {
		if(H[i]-H[last] > d ){
			cnt++;
			last = i;
		}
	}
	return cnt<=3;
}

int main() {

	int n;
	scanf("%d", &n);
	for(int i=0 ; i<n ; i++) scanf("%d", H+i);

	sort(H, H+n);

	long long l=0, r=2000000001LL;
	while(l<r) {
		long long mid = (l+r)/2LL;
		if( can(mid, n) ) r = mid;
		else l = mid+1;
	}

	printf("%.6lf\n", (double)l/2.);

	int last = 0;
	int cnt = 0;

	for(int i=0 ; i<n ; i++) {
		if(H[i]-H[last] > l ){
			printf("%.6lf ", ((double)H[i-1]+H[last])/2.);
			cnt++;
			last = i;
		}
	}

	while(cnt < 3) {
		printf("%.6lf ", ((double)H[n-1]+H[last])/2.);
		cnt++;
	}
	printf("\n");

	return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int main(void)
{
    int n,i,a[200005];
    cin>>n;
    for(i=0;i<n;i++) scanf("%d",&a[i]);
    sort(a,a+n);
    if(n<=3)
    {
        cout<<0<<endl;
        for(i=0;i<3;i++) printf("%.6lf ",double(a[min(i,n-1)]));
        cout<<endl;
        return 0;
    }
    double r=a[n-1],l=0,m;
//    printf("..%.6lf\n",r-l);
    while(r-l>1e-10)
    {
        m=(l+r)/2;
//        printf("....%.6lf\n",m);
        int sum=1,zuo=0;
//        double d=0;
        for(i=0;i<n;i++)
            if(double(a[i]-a[zuo])-2*m>1e-9) {zuo=i;sum++;}
        if(sum>3) l=m;
        else r=m;
    }
    int zuo=0,sum=0;
    printf("%.6lf\n",l);
    for(i=0;i<n;i++)
        if(a[i]-a[zuo]-2*l>1e-7)
        {
            printf("%.6lf ",double(a[i-1]+a[zuo])/2);
            zuo=i;sum++;
        }
    printf("%.6lf",double(a[n-1]+a[zuo])/2);sum++;
    if(sum<3)
        {
            for(i=0;i<3-sum;i++) printf(" %.6lf",double(a[n-1]));
            cout<<endl;
        }
    else printf("\n");
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int main(void)
{
    int n,i,a[200005];
    cin>>n;
    for(i=0;i<n;i++) scanf("%d",&a[i]);
    sort(a,a+n);
    if(n<=3)
    {
        cout<<0<<endl;
        for(i=0;i<3;i++) printf("%.6lf ",double(a[min(i,n-1)]));
        cout<<endl;
        return 0;
    }
    double r=a[n-1],l=0,m;
//    printf("..%.6lf\n",r-l);
    while(r-l>1e-10)
    {
        m=(l+r)/2;
//        printf("....%.6lf\n",m);
        int sum=1,zuo=0;
//        double d=0;
        for(i=0;i<n;i++)
            if(double(a[i]-a[zuo])-2*m>1e-9) {zuo=i;sum++;}
        if(sum>3) l=m;
        else r=m;
    }
    int zuo=0,sum=0;
    printf("%.6lf\n",l);
    for(i=0;i<n;i++)
        if(a[i]-a[zuo]-2*l>1e-7)
        {
            printf("%.6lf ",double(a[i-1]+a[zuo])/2);
            zuo=i;sum++;
        }
    printf("%.6lf",double(a[n-1]+a[zuo])/2);sum++;
    if(sum<3) printf(" %.6lf\n",double(a[n-1])); else printf("\n");
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int main(void)
{
    int n,i,a[200005];
    cin>>n;
    for(i=0;i<n;i++) scanf("%d",&a[i]);
    sort(a,a+n);
    if(n<=3)
    {
        cout<<0<<endl;
        for(i=0;i<3;i++) printf("%.6lf ",double(a[min(i,n-1)]));
        cout<<endl;
        return 0;
    }
    double r=a[n-1],l=0,m;
//    printf("..%.6lf\n",r-l);
    while(r-l>1e-12)
    {
        m=(l+r)/2;
//        printf("....%.6lf\n",m);
        int sum=1,zuo=0;
//        double d=0;
        for(i=0;i<n;i++)
            if(double(a[i]-a[zuo])-2*m>1e-10) {zuo=i;sum++;}
        if(sum>3) l=m;
        else r=m;
    }
    int zuo=0,sum=0;
    printf("%.6lf\n",l);
    for(i=0;i<n;i++)
        if(a[i]-a[zuo]-2*l>1e-7)
        {
            printf("%.6lf ",double(a[i-1]+a[zuo])/2);
            zuo=i;sum++;
        }
    printf("%.6lf",double(a[n-1]+a[zuo])/2);sum++;
    if(sum<3) printf(" %.6lf\n",double(a[n-1])); else printf("\n");
    return 0;
}


#include <string>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <map>
#include <set>
#include <cmath>
#include <sstream>
#include <iostream>
#include <cstring>
#define REP(i,x,v)for(int i=x;i<=v;i++)
#define REPD(i,x,v)for(int i=x;i>=v;i--)
#define FOR(i,v)REP(i,0,(int)(v)-1)
#define FORD(i,v)REPD(i,(int)(v)-1,0)
#define pb push_back
#define sz size
#define mp make_pair
#define fi first
#define se second
#define ll long long
#define IN(x,y) ((y).find((x))!=(y).end())
#define DBG(vari) cout<<#vari<<" = "<<vari<<endl;
#define DBG2(v1,v2) cout<<(v1)<<" - "<<(v2)<<endl;
#define MIN(a,b) ((a)<(b)?a:b)
#define MAX(a,b) ((a)<(b)?b:a)
using namespace std;
vector<ll> p;
ll M,mn,mx,h1,h2;
set<ll> st;
ll n,b;

bool check(ll d)
{
    if (2*d>=M)
    {
        h1=mn;
        h2=mx;
        return 1;
    }

    h1=*(upper_bound(p.begin(),p.end(),mn+2*d));
    h2=*(--(lower_bound(p.begin(),p.end(),mx-2*d)));
    return (h2-h1<=2*d);
}

int main()
{
    ios_base::sync_with_stdio(0);
    scanf("%d",&n);
    st.insert(-100);
    st.insert(20000000001LL);
    mn=200000000000LL;
    mx=-1;
    FOR(i,n)
    {
        scanf("%d",&b);
        b*=2;
        st.insert(b);
        mn=MIN(mn,b);
        mx=MAX(mx,b);
    }
    for(set<ll>::iterator it=st.begin();it!=st.end();it++)
        p.pb(*it);
    ll lo=0,hi=200000000000LL,mid;
    M=mx-mn;
    DBG(M);
    while (hi-lo>1)
    {
        mid=(hi+lo)/2;
        if (check(mid))
            hi=mid;
        else lo=mid;
    }
    if (check(lo)) mid=lo; else mid=hi;
    double D=0.5*mid;
    mn/=2;
    mx/=2;
    printf("%.6f\n%.6f %.6f %.6f",D,double(mn)+D,0.25*(h1+h2),double(mx)-D);
    return 0;
}


#include <string>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <map>
#include <set>
#include <cmath>
#include <sstream>
#include <iostream>
#include <cstring>
#define REP(i,x,v)for(int i=x;i<=v;i++)
#define REPD(i,x,v)for(int i=x;i>=v;i--)
#define FOR(i,v)REP(i,0,(int)(v)-1)
#define FORD(i,v)REPD(i,(int)(v)-1,0)
#define pb push_back
#define sz size
#define mp make_pair
#define fi first
#define se second
#define ll long long
#define IN(x,y) ((y).find((x))!=(y).end())
#define DBG(vari) cout<<#vari<<" = "<<vari<<endl;
#define DBG2(v1,v2) cout<<(v1)<<" - "<<(v2)<<endl;
#define MIN(a,b) ((a)<(b)?a:b)
#define MAX(a,b) ((a)<(b)?b:a)
using namespace std;
vector<ll> p;
ll M,mn,mx,h1,h2;
set<ll> st;
ll n,b;

bool check(ll d)
{
    if (2*d>=M)
    {
        h1=mn;
        h2=mx;
        return 1;
    }

    h1=*(upper_bound(p.begin(),p.end(),mn+2*d));
    h2=*(--(lower_bound(p.begin(),p.end(),mx-2*d)));
    return (h2-h1<=2*d);
}

int main()
{
    ios_base::sync_with_stdio(0);
    scanf("%d",&n);
    st.insert(-100);
    st.insert(20000000001LL);
    mn=200000000000LL;
    mx=-1;
    FOR(i,n)
    {
        scanf("%d",&b);
        b*=2;
        st.insert(b);
        mn=MIN(mn,b);
        mx=MAX(mx,b);
    }
    for(set<ll>::iterator it=st.begin();it!=st.end();it++)
        p.pb(*it);
    ll lo=0,hi=200000000000LL,mid;
    M=mx-mn;
    //DBG(M);
    while (hi-lo>1)
    {
        mid=(hi+lo)/2;
        if (check(mid))
            hi=mid;
        else lo=mid;
    }
    if (check(lo)) mid=lo; else mid=hi;
    double D=0.5*mid;
    mn/=2;
    mx/=2;
    printf("%.6f\n%.6f %.6f %.6f",D,double(mn)+D,0.25*(h1+h2),double(mx)-D);
    return 0;
}


#include <string>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <map>
#include <set>
#include <cmath>
#include <sstream>
#include <iostream>
#include <cstring>
#define REP(i,x,v)for(int i=x;i<=v;i++)
#define REPD(i,x,v)for(int i=x;i>=v;i--)
#define FOR(i,v)REP(i,0,(int)(v)-1)
#define FORD(i,v)REPD(i,(int)(v)-1,0)
#define pb push_back
#define sz size
#define mp make_pair
#define fi first
#define se second
#define ll long long
#define IN(x,y) ((y).find((x))!=(y).end())
#define DBG(vari) cout<<#vari<<" = "<<vari<<endl;
#define DBG2(v1,v2) cout<<(v1)<<" - "<<(v2)<<endl;
#define MIN(a,b) ((a)<(b)?a:b)
#define MAX(a,b) ((a)<(b)?b:a)
using namespace std;
vector<ll> p;
ll M,mn,mx,h1,h2;
set<int> st;
int n,b;

bool check(double d)
{
    if (2*d>=M)
    {
        h1=mn;
        h2=mx;
         return 1;
    }

    h1=*(upper_bound(p.begin(),p.end(),mn+(ll)(2*d)));
    h2=*(--(lower_bound(p.begin(),p.end(),mx-(ll)(2*d))));
    return (h2-h1<=2*d);
}

int main()
{
    ios_base::sync_with_stdio(0);
    scanf("%d",&n);
    st.insert(-100);
    st.insert(2000000001);
    mn=2000000000;
    mx=-1;
    FOR(i,n)
    {
        scanf("%d",&b);
        st.insert(b);
        mn=MIN(mn,b);
        mx=MAX(mx,b);
    }
    for(set<int>::iterator it=st.begin();it!=st.end();it++)
        p.pb(*it);
    double lo=0.0,hi=100000000000.0,mid;
    M=mx-mn;
    DBG(M);
    while (hi-lo>1e-9)
    {
        mid=0.5*(hi+lo);
        if (check(mid))
            hi=mid;
        else lo=mid;
    }
    printf("%.8f\n%.8f %.8f %.8f",mid,double(mn)+mid,0.5*(h1+h2),double(mx)-mid);
    return 0;
}


#include <string>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <map>
#include <set>
#include <cmath>
#include <sstream>
#include <iostream>
#include <cstring>
#define REP(i,x,v)for(int i=x;i<=v;i++)
#define REPD(i,x,v)for(int i=x;i>=v;i--)
#define FOR(i,v)REP(i,0,(int)(v)-1)
#define FORD(i,v)REPD(i,(int)(v)-1,0)
#define pb push_back
#define sz size
#define mp make_pair
#define fi first
#define se second
#define ll long long
#define IN(x,y) ((y).find((x))!=(y).end())
#define DBG(vari) cout<<#vari<<" = "<<vari<<endl;
#define DBG2(v1,v2) cout<<(v1)<<" - "<<(v2)<<endl;
#define MIN(a,b) ((a)<(b)?a:b)
#define MAX(a,b) ((a)<(b)?b:a)
using namespace std;
vector<ll> p;
ll M,mn,mx,h1,h2;
set<ll> st;
ll n,b;

bool check(ll d)
{
    if (2*d>=M)
    {
        h1=mn;
        h2=mx;
        return 1;
    }

    h1=*(upper_bound(p.begin(),p.end(),mn+2*d));
    h2=*(--(lower_bound(p.begin(),p.end(),mx-2*d)));
    return (h2-h1<=2*d);
}

int main()
{
    ios_base::sync_with_stdio(0);
    scanf("%d",&n);
    st.insert(-100);
    st.insert(20000000001LL);
    mn=200000000000LL;
    mx=-1;
    FOR(i,n)
    {
        scanf("%d",&b);
        b*=2;
        st.insert(b);
        mn=MIN(mn,b);
        mx=MAX(mx,b);
    }
    for(set<ll>::iterator it=st.begin();it!=st.end();it++)
        p.pb(*it);
    ll lo=0,hi=200000000000LL,mid;
    M=mx-mn;
    DBG(M);
    while (hi-lo>1)
    {
        mid=(hi+lo)/2;
        if (check(mid))
            hi=mid;
        else lo=mid;
    }
    if (check(lo)) mid=lo; else mid=hi;
    double D=0.5*mid;
    mn/=2;
    mx/=2;
    printf("%.8f\n%.8f %.8f %.8f",D,double(mn)+D,0.25*(h1+h2),double(mx)-D);
    return 0;
}


#include <string>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <map>
#include <set>
#include <cmath>
#include <sstream>
#include <iostream>
#include <cstring>
#define REP(i,x,v)for(int i=x;i<=v;i++)
#define REPD(i,x,v)for(int i=x;i>=v;i--)
#define FOR(i,v)REP(i,0,(int)(v)-1)
#define FORD(i,v)REPD(i,(int)(v)-1,0)
#define pb push_back
#define sz size
#define mp make_pair
#define fi first
#define se second
#define ll long long
#define IN(x,y) ((y).find((x))!=(y).end())
#define DBG(vari) cout<<#vari<<" = "<<vari<<endl;
#define DBG2(v1,v2) cout<<(v1)<<" - "<<(v2)<<endl;
#define MIN(a,b) ((a)<(b)?a:b)
#define MAX(a,b) ((a)<(b)?b:a)
using namespace std;
vector<ll> p;
ll M,mn,mx,h1,h2;
set<ll> st;
ll n,b;

bool check(ll d)
{
    if (d>=M)
    {
        h1=mn;
        h2=mx;
        return 1;
    }

    h1=*(upper_bound(p.begin(),p.end(),mn+d));
    h2=*(--(lower_bound(p.begin(),p.end(),mx-d)));
    return (h2-h1<=d);
}

int main()
{
    ios_base::sync_with_stdio(0);
    scanf("%d",&n);
    st.insert(-100);
    st.insert(200000000001LL);
    mn=2000000000000LL;
    mx=-1;
    FOR(i,n)
    {
        scanf("%d",&b);
        st.insert(b);
        mn=MIN(mn,b);
        mx=MAX(mx,b);
    }
    for(set<ll>::iterator it=st.begin();it!=st.end();it++)
        p.pb(*it);
    ll lo=0,hi=200000000000LL,mid;
    M=mx-mn;
    //DBG(M);
    while (hi-lo>1)
    {
        mid=(hi+lo)/2;
        if (check(mid))
            hi=mid;
        else lo=mid;
    }
    if (check(lo)) mid=lo; else mid=hi;
    check(mid);
    double D=0.5*mid;
    printf("%.6f\n%.6f %.6f %.6f",D,double(mn)+D,0.5*(h1+h2),double(mx)-D);
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
using namespace std;
#define p(x) cout<<#x<<":"<<x<<"\n"

int n,i,j;
double mn,s1,s2,a,b,c;
int A[200001];

int main()
{
  scanf("%d",&n);
  for(i=0;i<n;i++)
    scanf("%d",&A[i]);
  sort(A,A+n);
	if(n<=3)
	{
	  printf("%.6lf\n",0);
		for(i=0;i<3;i++)
		  printf("%.6lf ",(double)A[min(i,n-1)]);
		return 0;
	}
	i=0;
	j=n-1;
	mn=A[n-1]-A[0]+1;
	while(i<j)
	{
	  if(A[i+1]-A[0]<=A[n-1]-A[j-1])
		  s1=A[++i]-A[0];
		else
		  s2=A[n-1]-A[--j];
		if(max(max(s1,s2),(double)A[j-1]-A[i+1])<mn)
		{
		  mn=max(max(s1,s2),(double)A[j-1]-A[i+1]);
			a=(A[0]+A[i])/2.;
			b=(A[i+1]+A[j-1])/2.;
			c=(A[j]+A[n-1])/2.;
		}
	}
	printf("%.6lf\n%.6lf %.6lf %.6lf ",mn/2,a,b,c);
	return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
using namespace std;
#define p(x) cout<<#x<<":"<<x<<"\n"

int n,i,j;
double mn,s1,s2,a,b,c;
int A[200001];

int main()
{
  scanf("%d",&n);
  for(i=0;i<n;i++)
    scanf("%d",&A[i]);
  sort(A,A+n);
	if(n<=3)
	{
	  printf("%.6lf\n",0);
		for(i=0;i<3;i++)
		  printf("%.6lf ",(double)A[min(i,n-1)]);
		return 0;
	}
	i=0;
	j=n-1;
	mn=A[n-1]-A[0]+1;
	while(i<j)
	{
		if(max(max(s1,s2),(double)A[j-1]-A[i+1])<mn)
		{
		  mn=max(max(s1,s2),(double)A[j-1]-A[i+1]);
			a=(A[0]+A[i])/2.;
			b=(A[i+1]+A[j-1])/2.;
			c=(A[j]+A[n-1])/2.;
		}
	  if(A[i+1]-A[0]<=A[n-1]-A[j-1])
		  s1=A[++i]-A[0];
		else
		  s2=A[n-1]-A[--j];
	}
	printf("%.6lf\n%.6lf %.6lf %.6lf ",mn/2,a,b,c);
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

int n,a[200005];

bool ok(int mid)
{
    int temp=a[0]+mid,k=0;
    for(int i=0; i<n; i++)
    {
        if(a[i]>temp)
        {
            if(k<2)
            {
                temp=a[i]+mid;
                k++;
            }
            else
                return 0;
        }

    }
    return 1;
}

int main()
{
    int st=0,ed,mid,temp,k=0;
    double answer;
    cin>>n;
    for(int i=0; i<n; i++)
    {
        cin>>a[i];
    }
    sort(a,a+n);
    ed=a[n-1];
    while(st<ed)
    {
        mid=(st+ed)/2;
        if(ok(mid))
            ed=mid;
        else
            st=mid+1;
    }
    temp=a[0]+st;
    answer=st/2.0;
    cout<<fixed<<setprecision(6)<<answer<<endl;
    cout<<fixed<<setprecision(6)<<a[0]+answer<<" ";
    for(int i=0; i<n; i++)
    {
        if(a[i]>temp)
        {
            temp=a[i]+st;
            k++;
            cout<<fixed<<setprecision(6)<<a[i]+answer<<" ";
        }
    }
    if(k<2)
    {
        cout<<fixed<<setprecision(6)<<a[n-1]/1.0;
    }
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

int n,a[200005];

bool ok(int mid)
{
    int temp=a[0]+mid,k=0;
    for(int i=0; i<n; i++)
    {
        if(a[i]>temp)
        {
            if(k<2)
            {
                temp=a[i]+mid;
                k++;
            }
            else
                return 0;
        }

    }
    return 1;
}

int main()
{
    int st=0,ed,mid,temp,k=0;
    double answer;
    cin>>n;
    for(int i=0; i<n; i++)
    {
        cin>>a[i];
    }
    sort(a,a+n);
    ed=a[n-1];
    while(st<ed)
    {
        mid=(st+ed)/2;
        if(ok(mid))
            ed=mid;
        else
            st=mid+1;
    }
    temp=a[0]+st;
    answer=st/2.0;
    cout<<fixed<<setprecision(6)<<answer<<endl;
    cout<<fixed<<setprecision(6)<<a[0]+answer<<" ";
    for(int i=0; i<n; i++)
    {
        if(a[i]>temp)
        {
            temp=a[i]+st;
            k++;
            cout<<fixed<<setprecision(6)<<a[i]+answer<<" ";
        }
    }
    while(k<2)
    {
        k++;
        cout<<fixed<<setprecision(6)<<a[n-1]/1.0;
    }
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

int n,a[200005];

bool ok(int mid)
{
    int temp=a[0]+mid,k=0;
    for(int i=0; i<n; i++)
    {
        if(a[i]>temp)
        {
            if(k<2)
            {
                temp=a[i]+mid;
                k++;
            }
            else
                return 0;
        }

    }
    return 1;
}

int main()
{
    int st=0,ed,mid,temp,k=0;
    double answer;
    cin>>n;
    for(int i=0; i<n; i++)
    {
        cin>>a[i];
    }
    sort(a,a+n);
    ed=a[n-1];
    while(st<ed)
    {
        mid=(st+ed)/2;
        if(ok(mid))
            ed=mid;
        else
            st=mid+1;
    }
    temp=a[0]+st;
    answer=st/2.0;
    cout<<fixed<<setprecision(6)<<answer<<endl;
    cout<<fixed<<setprecision(6)<<a[0]+answer<<" ";
    for(int i=0; i<n; i++)
    {
        if(a[i]>temp)
        {
            temp=a[i]+st;
            k++;
            cout<<fixed<<setprecision(6)<<a[i]+answer<<" ";
        }
    }
    while(k<2)
    {
        k++;
        cout<<fixed<<setprecision(6)<<a[n-1]/1.0<<" ";
    }
    return 0;
}


#define _CRT_SECURE_NO_DEPRECATE
#include <cstdio>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <list>
#include <map>
#include <set>
#include <iostream>
#include <memory.h>
#include <fstream>
using namespace std;

typedef long long int64;

int n;
vector<int64> x, pos;

bool ok(int64 d)
{
	pos.clear();
	int cnt = 3;
	int lastPos = -1;
	for (int j = 0; j < n && cnt >= 0; ++j)
	{
		if (lastPos == -1 || x[j] - x[lastPos] > 2 * d)
		{
			lastPos = j;
			pos.push_back(x[lastPos] + d);
			--cnt;
		}
	}
	pos.resize(3);
	return cnt >= 0;
}

int main()
{
	cin >> n;
	x.resize(n);
	for (int i = 0; i < n; ++i)
	{
		cin >> x[i];
		x[i] *= 2;
	}
	sort(x.begin(), x.end());
	int64 l = -1, r = (int64)1e10;
	while (r - l > 1)
	{
		int64 k = (l + r) / 2;
		if (ok(k))
			r = k;
		else
			l = k;
	}
	printf("%.6f\n", r / 2.0);
	ok(r);
	for (int i = 0; i < 3; ++i)
		printf("%.6f ", pos[i] / 2.0);
    return 0;
}


#define _CRT_SECURE_NO_DEPRECATE
#include <cstdio>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <list>
#include <map>
#include <set>
#include <iostream>
#include <memory.h>
#include <fstream>
using namespace std;

typedef long long int64;

int n;
vector<int64> x, pos;

bool ok(int64 d)
{
	pos.clear();
	int cnt = 3;
	int lastPos = -1;
	for (int j = 0; j < n && cnt >= 0; ++j)
	{
		if (lastPos == -1 || x[j] - x[lastPos] > 2 * d)
		{
			lastPos = j;
			pos.push_back(x[lastPos] + d);
			--cnt;
		}
	}
	pos.resize(3);
	return cnt >= 0;
}

void main()
{
	cin >> n;
	x.resize(n);
	for (int i = 0; i < n; ++i)
	{
		cin >> x[i];
		x[i] *= 2;
	}
	sort(x.begin(), x.end());
	int64 l = -1, r = (int64)1e10;
	while (r - l > 1)
	{
		int64 k = (l + r) / 2;
		if (ok(k))
			r = k;
		else
			l = k;
	}
	printf("%.6f\n", r / 2.0);
	ok(r);
	for (int i = 0; i < 3; ++i)
		printf("%.6f ", pos[i] / 2.0);
}


// User: lovelotus(Prem Kamal)

//#include<bits/stdc++.h>
//#define _ ios_base::sync_with_stdio(0);cin.tie(0);

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<map>
#include<string>
#include<vector>
#include<queue>
#include<cstring>
#include<cstdlib>
#include<cassert>
#include<cmath>
#include<stack>
#include<set>
#include<utility>
#define pii pair<int,int>
#define pip pair<int,pii>
#define F first
#define S second
#define lli long long int
using namespace std;
#define eps 0.0000001

double a[200001];
int n,k;

int valid(double val)
{
    double pos=a[0]+val;
    int i,cnt=1;
    for(i=1;i<n;i++)
    {
        if(a[i]-pos - val>eps)
        {
            cnt++;
            pos=a[i]+val;
        }
    }
    return (cnt<=3);
}

void printSol(double val)
{
    double pos=a[0]+val;
    int cnt=1;
    for(int i=1;i<n;i++)
    {
        if(a[i]-pos-val>eps)
        {
            printf("%.6lf ",pos);
            cnt++;
            pos=a[i]+val;
        }
    }
    while(cnt<3)
    {
        printf("%.6lf ",pos);
        cnt++;
    }
    printf("%.6lf\n",pos);
}

double bin_search( double l, double r)
{
    if(r-l < eps) return (r+l)/2.0;
    double mid =(r+l)/2.0;
    if(valid(mid)) return bin_search(l,mid);
    return bin_search(mid,r);
}

int main()
{
    int i;
    scanf("%d",&n);
    double maxm=0.0;
    for(i=0;i<n;i++)
    {
        scanf("%lf",&a[i]);
        if(a[i]>maxm) maxm=a[i];
    }
    sort(a,a+n);
    double ans = bin_search(0.0,maxm);
    printf("%.6lf\n",ans);
    printSol(ans);
    return 0;
}


// User: lovelotus(Prem Kamal)

//#include<bits/stdc++.h>
//#define _ ios_base::sync_with_stdio(0);cin.tie(0);

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<map>
#include<string>
#include<vector>
#include<queue>
#include<cstring>
#include<cstdlib>
#include<cassert>
#include<cmath>
#include<stack>
#include<set>
#include<utility>
#define pii pair<int,int>
#define pip pair<int,pii>
#define F first
#define S second
#define lli long long int
using namespace std;
#define eps 1e-7

double a[200001];
int n,k;

int valid(double val)
{
    double pos=a[0]+val;
    int i,cnt=1;
    for(i=1;i<n;i++)
    {
        if(a[i]-pos - val>eps)
        {
            cnt++;
            pos=a[i]+val;
        }
    }
    return (cnt<=3);
}

void printSol(double val)
{
    double pos=a[0]+val;
    int cnt=1;
    for(int i=1;i<n;i++)
    {
        if(a[i]-pos-val>eps)
        {
            printf("%.6lf ",pos);
            cnt++;
            pos=a[i]+val;
        }
    }
    while(cnt<=3)
    {
        printf("%.6lf ",pos);
        cnt++;
    }
    printf("\n");
}

double bin_search( double l, double r)
{
    if(r-l < eps) return (r+l)/2.0;
    double mid =(r+l)/2.0;
    if(valid(mid)) return bin_search(l,mid);
    return bin_search(mid,r);
}

int main()
{
    int i;
    scanf("%d",&n);
    double maxm=0.0;
    for(i=0;i<n;i++)
    {
        scanf("%lf",&a[i]);
        if(a[i]>maxm) maxm=a[i];
    }
    sort(a,a+n);
    double ans = bin_search(0.0,maxm);
    printf("%.6lf\n",ans);
    printSol(ans);
    return 0;
}


// User: lovelotus(Prem Kamal)

//#include<bits/stdc++.h>
//#define _ ios_base::sync_with_stdio(0);cin.tie(0);

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<map>
#include<string>
#include<vector>
#include<queue>
#include<cstring>
#include<cstdlib>
#include<cassert>
#include<cmath>
#include<stack>
#include<set>
#include<utility>
#define pii pair<int,int>
#define pip pair<int,pii>
#define F first
#define S second
#define lli long long int
using namespace std;
#define eps 0.0000001

double a[200001];
int n,k;

int valid(double val)
{
    double pos=a[0]+val;
    int i,cnt=1;
    for(i=1;i<n;i++)
    {
        if(a[i]-pos - val>eps)
        {
            cnt++;
            pos=a[i]+val;
        }
    }
    return (cnt<=3);
}

void printSol(double val)
{
    double pos=a[0]+val;
    int cnt=1;
    for(int i=1;i<n;i++)
    {
        if(a[i]-pos-val>eps)
        {
            printf("%.6lf ",pos);
            cnt++;
            pos=a[i]+val;
        }
    }
    while(cnt<=3)
    {
        printf("%.6lf ",pos);
        cnt++;
    }
    printf("\n");
}

double bin_search( double l, double r)
{
    if(r-l < eps) return (r+l)/2.0;
    double mid =(r+l)/2.0;
    if(valid(mid)) return bin_search(l,mid);
    return bin_search(mid,r);
}

int main()
{
    int i;
    scanf("%d",&n);
    double maxm=0.0;
    for(i=0;i<n;i++)
    {
        scanf("%lf",&a[i]);
        if(a[i]>maxm) maxm=a[i];
    }
    sort(a,a+n);
    double ans = bin_search(0.0,maxm);
    printf("%.6lf\n",ans);
    printSol(ans);
    return 0;
}


// User: lovelotus(Prem Kamal)

//#include<bits/stdc++.h>
//#define _ ios_base::sync_with_stdio(0);cin.tie(0);

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<map>
#include<string>
#include<vector>
#include<queue>
#include<cstring>
#include<cstdlib>
#include<cassert>
#include<cmath>
#include<stack>
#include<set>
#include<utility>
#define pii pair<int,int>
#define pip pair<int,pii>
#define F first
#define S second
#define lli long long int
using namespace std;
#define eps 1e-6

double a[200001];
int n,k;

int valid(double val)
{
    double pos=a[0]+val;
    int i,cnt=1;
    for(i=1;i<n;i++)
    {
        if(a[i]-pos - val>eps)
        {
            cnt++;
            pos=a[i]+val;
        }
    }
    return (cnt<=3);
}

void printSol(double val)
{
    double pos=a[0]+val;
    int cnt=1;
    for(int i=1;i<n;i++)
    {
        if(a[i]-pos-val>eps)
        {
            printf("%.6lf ",pos);
            cnt++;
            pos=a[i]+val;
        }
    }
    while(cnt<=3)
    {
        printf("%.6lf ",pos);
        cnt++;
    }
    printf("\n");
}

double bin_search( double l, double r)
{
    if(r-l < eps) return (r+l)/2.0;
    double mid =(r+l)/2.0;
    if(valid(mid)) return bin_search(l,mid);
    return bin_search(mid,r);
}

int main()
{
    int i;
    scanf("%d",&n);
    double maxm=0.0;
    for(i=0;i<n;i++)
    {
        scanf("%lf",&a[i]);
        if(a[i]>maxm) maxm=a[i];
    }
    sort(a,a+n);
    double ans = bin_search(0.0,maxm);
    printf("%.6lf\n",ans);
    printSol(ans);
    return 0;
}


// User: lovelotus(Prem Kamal)

//#include<bits/stdc++.h>
//#define _ ios_base::sync_with_stdio(0);cin.tie(0);

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<map>
#include<string>
#include<vector>
#include<queue>
#include<cstring>
#include<cstdlib>
#include<cassert>
#include<cmath>
#include<stack>
#include<set>
#include<utility>
#define pii pair<int,int>
#define pip pair<int,pii>
#define F first
#define S second
#define lli long long int
using namespace std;
#define eps 1e-9

double a[200001];
int n,k;

int valid(double val)
{
    double pos=a[0]+val;
    int i,cnt=1;
    for(i=1;i<n;i++)
    {
        if(a[i]-pos - val>eps)
        {
            cnt++;
            pos=a[i]+val;
        }
    }
    return (cnt<=3);
}

void printSol(double val)
{
    double pos=a[0]+val;
    int cnt=1;
    for(int i=1;i<n;i++)
    {
        if(a[i]-pos-val>eps)
        {
            printf("%.6lf ",pos);
            cnt++;
            pos=a[i]+val;
        }
    }
    while(cnt<=3)
    {
        printf("%.6lf ",pos);
        cnt++;
    }
    printf("\n");
}

double bin_search( double l, double r)
{
    if(r-l < eps) return (r+l)/2.0;
    double mid =(r+l)/2.0;
    if(valid(mid)) return bin_search(l,mid);
    return bin_search(mid,r);
}

int main()
{
    int i;
    scanf("%d",&n);
    double maxm=0.0;
    for(i=0;i<n;i++)
    {
        scanf("%lf",&a[i]);
        if(a[i]>maxm) maxm=a[i];
    }
    sort(a,a+n);
    double ans = bin_search(0.0,maxm);
    printf("%.6lf\n",ans);
    printSol(ans);
    return 0;
}