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

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

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

Input

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

Output

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

Examples

Input

4
1 2 3 4


Output

0.500000
1.500000 2.500000 3.500000


Input

3
10 20 30


Output

0
10.000000 20.000000 30.000000


Input

5
10003 10004 10001 10002 1


Output

0.500000
1.000000 10001.500000 10003.500000

Source: codeforces | Difficulty: MEDIUM_HARD
Tags: Sorting

Greedy algorithms


Solutions:
n = int(input())
houses = sorted(set(map(int, input().split())))
if len(houses) <= 3:
	print(0)
	result = houses[:]
	while len(result) < 3:
		result.append(result[-1])
	print('%.6f %.6f %.6f' % tuple(result))
	import sys
	sys.exit()
span = 0
left = 1
right = len(houses) - 2
while houses[right] - houses[left] > span:
	left_gap = houses[left] - houses[0] - span
	right_gap = houses[-1] - houses[right] - span
	middle = houses[right] - houses[left]
	if left_gap <= right_gap:
		if span + left_gap > middle:
			span = middle
			break
		left += 1
		if left_gap == right_gap:
			right -= 1
		span += left_gap
	else:
		if span + right_gap > middle:
			span = middle
			break
		right -= 1
		span += right_gap
print('%.6f' % (span / 2))
print('%.6f %.6f %.6f' % ((houses[0] + houses[left - 1]) / 2, (houses[left] + houses[right]) / 2, (houses[right + 1] + houses[-1]) / 2))


from decimal import *
n = int(input())
a = sorted(map(int, input().split()))
i = 1 - n
j = n - 2
s = 0
getcontext().prec = 6
Decimal(1) / Decimal(7)
n = a[j] - a[i]
while s < n:
	(l, r) = (a[i] - a[0], a[-1] - a[j])
	if l < r:
		if n <= l:
			s = n
			break
		i += 1
		s = l
	else:
		if n <= r:
			s = n
			break
		j -= 1
		s = r
	n = a[j] - a[i]
s /= 2
print(Decimal(s))
print(s + a[0] + 1e-07, float(a[j] - s), float(a[-1] - s))


n = int(input())
a = sorted(map(int, input().split()))
i = 1 - n
j = n - 2
s = 0
n = a[j] - a[i]
while s < n:
	(l, r) = (a[i] - a[0], a[-1] - a[j])
	if l < r:
		if n <= l:
			s = n
			break
		i += 1
		s = l
	else:
		if n <= r:
			s = n
			break
		j -= 1
		s = r
	n = a[j] - a[i]
s /= 2
print(s)
print(s + a[0], a[j] - s, a[-1] - s)


import math, sys
from collections import defaultdict, deque
import bisect as bi

def yes():
	print('YES')

def no():
	print('NO')

def I():
	return int(sys.stdin.readline())

def In():
	return map(int, sys.stdin.readline().split())

def Sn():
	return sys.stdin.readline().strip()

def dict(a):
	d = {}
	for x in a:
		if d.get(x, -1) != -1:
			d[x] += 1
		else:
			d[x] = 1
	return d

def find_gt(a, x):
	i = bi.bisect_right(a, x)
	if i != len(a):
		return i
	else:
		return len(a)

def check(mid):
	pos = 0
	for i in range(3):
		p = l[pos] + 2 * mid
		if p >= l[n - 1]:
			pos = n
		else:
			pos = find_gt(l, p)
		if pos >= n:
			return True
	return False

def main():
	try:
		global l, n
		n = I()
		l = list(In())
		for x in range(n):
			l[x] *= 2
		l.sort()
		(low, high) = (-1, int(1000000000.0 + 1))
		while low + 1 < high:
			mid = low + (high - low) // 2
			if check(mid):
				high = mid
			else:
				low = mid
		rad = high / 2
		print(rad)
		pos = 0
		i = 0
		while i < 3:
			if pos >= n:
				print(2 * 100000000.0, end=' ')
			else:
				p = l[pos] + 2 * high
				if p >= l[n - 1]:
					pos = n
				else:
					pos = find_gt(l, p)
				print((p - high) / 2, end=' ')
			i += 1
		print()
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(1):
	main()


import os, sys
from io import IOBase, BytesIO
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import sys

class ostream:

	def __lshift__(self, a):
		sys.stdout.write(str(a))
		return self
cout = ostream()
endl = '\n'

def solve():
	n = int(input())
	homes = list(map(int, input().split()))
	homes.sort()

	def can_cover(d_i):
		total_posts = 3
		curr_cover = 0
		ptr = 0
		res = []
		while ptr < len(homes):
			if curr_cover < homes[ptr]:
				if total_posts > 0:
					total_posts -= 1
					curr_cover = homes[ptr] + 2 * d_i
					res.append(float('{:.6f}'.format(min(homes[ptr] + d_i, homes[-1]))))
				else:
					break
			ptr += 1
		if ptr < len(homes):
			return (False, [])
		else:
			return (True, res)
	lo = 0
	hi = 4 * 10 ** 8
	res = -1
	mx = 100
	while lo < hi and mx:
		mid = lo + (hi - lo) / 2
		(r, pos) = can_cover(mid)
		if r:
			res = mid
			hi = mid
		else:
			lo = mid
		mx -= 1
	re = can_cover(res)[1]
	while len(re) < 3:
		re.append(float('{:.6f}'.format(homes[-1])))
	cout << '%.6f' % res << endl
	cout << ' '.join(map(str, re)) << endl

def main():
	solve()
main()