Vanya walks late at night along a straight street of length l, lit by n lanterns. Consider the coordinate system with the beginning of the street corresponding to the point 0, and its end corresponding to the point l. Then the i-th lantern is at the point a_{i}. The lantern lights all points of the street that are at the distance of at most d from it, where d is some positive number, common for all lanterns. 

Vanya wonders: what is the minimum light radius d should the lanterns have to light the whole street?


-----Input-----

The first line contains two integers n, l (1 ≤ n ≤ 1000, 1 ≤ l ≤ 10^9) — the number of lanterns and the length of the street respectively. 

The next line contains n integers a_{i} (0 ≤ a_{i} ≤ l). Multiple lanterns can be located at the same point. The lanterns may be located at the ends of the street.


-----Output-----

Print the minimum light radius d, needed to light the whole street. The answer will be considered correct if its absolute or relative error doesn't exceed 10^{ - 9}.


-----Examples-----
Input
7 15
15 5 3 7 9 14 0

Output
2.5000000000

Input
2 5
2 5

Output
2.0000000000



-----Note-----

Consider the second sample. At d = 2 the first lantern will light the segment [0, 4] of the street, and the second lantern will light segment [3, 5]. Thus, the whole street will be lit.

Difficulty: EASY
Tags: Mathematics

Sorting

Implementation
Skill types: Sorting

Starter code:

Solutions:
(n, l) = map(int, input().split())
lst = list(map(int, input().split()))
lst.sort()
a = lst[0]
b = lst[n - 1]
e = [lst[i + 1] - lst[i] for i in range(n - 1)]
if len(e) > 0:
	print(max(a, l - b, max(e) / 2))
else:
	print(max(a, l - b))


s = [int(n) for n in input().split()]
z = [int(n) for n in input().split()]
z.sort()
m = z[0]
for n in range(len(z) - 1):
	j = (z[n + 1] - z[n]) / 2
	m = max(m, j)
m = max(m, s[1] - z[len(z) - 1])
print(m)


def main():
	(num, len_r) = map(int, input().split())
	lan = list(map(int, input().split()))
	lan.sort()
	max_d = 0
	for i in range(1, len(lan)):
		max_d = max(max_d, (lan[i] - lan[i - 1]) / 2)
	if lan[0] != 0:
		max_d = max(max_d, lan[0] - 0)
	if lan[-1] != len_r:
		max_d = max(max_d, len_r - lan[-1])
	print(max_d)
main()


(n, l) = map(lambda x: int(x), input().split())
ar = list(map(lambda x: int(x), input().split()))
ar.sort()
ans = 0
for i in range(1, n):
	ans = max(ans, (ar[i] - ar[i - 1]) / 2)
print(max(ans, ar[0] - 0, l - ar[-1]))


s = input()
(m, n) = map(int, s.split())
s = input()
l = list(map(int, s.split()))
l.sort()
max = 0
for j in range(m - 1):
	d1 = l[j + 1] - l[j]
	if d1 > max:
		max = d1
d1 = max / 2
d2 = 0
d3 = 0
if l[0] != 0:
	d2 = l[0]
else:
	d2 = 0
if l[-1] != n:
	d3 = n - l[-1]
else:
	d3 = 0
if d1 > d2:
	pass
else:
	d1 = d2
if d1 > d3:
	pass
else:
	d1 = d3
print(d1)


(n, l) = map(int, input().split())
w = sorted(list(map(int, input().split())))
ans = max(w[0], l - w[n - 1]) * 2
for k in range(n - 1):
	comp = w[k + 1] - w[k]
	ans = max(ans, comp)
print(ans / 2)


inp_a = list(map(int, input().split()))
coord = list(map(int, input().split()))
n = inp_a[0]
l = inp_a[1]
coord.sort()
m = 0
flag = 0
for i in range(n - 1):
	if coord[i + 1] - coord[i] > m:
		m = coord[i + 1] - coord[i]
if coord[0] > m / 2:
	m = coord[0]
	flag = 2
if flag == 2:
	if l - coord[n - 1] > m:
		m = l - coord[n - 1]
		flag == 1
elif l - coord[n - 1] > m / 2:
	m = l - coord[n - 1]
	flag = 1
if flag == 1 or flag == 2:
	print(float(m))
else:
	print(float(m / 2))


a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
b.sort()
answer = b[0]
for x in range(len(b) - 1):
	if (b[x + 1] - b[x]) / 2 > answer:
		answer = (b[x + 1] - b[x]) / 2
if answer > a[1] - b[-1]:
	print(answer)
else:
	print(a[1] - b[-1])


I = lambda : map(int, input().split())
(n, l) = I()
L = sorted(set(I()))
M = 0
for i in range(len(L) - 1):
	if M < L[i + 1] - L[i]:
		M = L[i + 1] - L[i]
if M / 2 < L[0]:
	M = 2 * L[0]
if M / 2 < l - L[-1]:
	M = 2 * (l - L[-1])
print(M / 2)


(n, l) = [int(i) for i in input().split()]
list1 = [int(i) for i in input().split()]
list1.sort()
max_dist = max(list1[0], l - list1[-1])
prev = list1[0]
for x in range(1, n):
	diff = (list1[x] - prev) / 2
	if diff > max_dist:
		max_dist = diff
	prev = list1[x]
print(max_dist)


(n, m) = map(int, input().split())
a = [int(i) for i in input().split()]
a.sort()
k = 0
for i in range(n - 1):
	if a[i + 1] - a[i] > k:
		k = a[i + 1] - a[i]
print(max(a[0] - 0, k / 2, m - a[-1]))


import random, math
from copy import deepcopy as dc

def solution(li, l):
	li.sort()
	diff = float('-inf')
	for i in range(len(li) - 1):
		if li[i] == 0 or li[i] == l:
			diff = max(diff, (li[i + 1] - li[i]) / 2)
			continue
		elif i == 0:
			diff = max(diff, li[i])
			diff = max(diff, (li[i + 1] - li[i]) / 2)
		else:
			diff = max(diff, (li[i + 1] - li[i]) / 2)
	diff = max(diff, l - li[-1])
	diff = max(diff, li[0])
	return diff

def input_test():
	(n, l) = map(int, input().strip().split(' '))
	li = list(map(int, input().strip().split(' ')))
	out = solution(li, l)
	print('%.9f' % out)
input_test()


(n, l) = map(int, input().split())
a = sorted(map(int, input().split()))
x = max([a[0], l - a[n - 1]] + [(a[i + 1] - a[i]) / 2.0 for i in range(n - 1)])
print(x)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
mx = 0
for i in range(n - 1):
	if a[i + 1] - a[i] > mx:
		mx = a[i + 1] - a[i]
mx = max(float(mx / 2), float(max(a[0], m - a[n - 1])))
print(float(mx))


aux = input().split(' ')
n = int(aux[0])
t = int(aux[1])
lights = input().split(' ')
for i in range(n):
	lights[i] = int(lights[i])
lights.sort()
answer = max(lights[0], t - lights[n - 1]) * 2
for i in range(n - 1):
	answer = max(answer, lights[i + 1] - lights[i])
print(float(answer / 2))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
b = list((a[i] - a[i - 1] for i in range(1, len(a))))
while 0 in b:
	b.remove(0)
print(max([a[0], l - a[-1]] + [(a[i + 1] - a[i]) / 2 for i in range(n - 1)]))


(n, m) = [int(x) for x in input().split()]
a = sorted([int(x) for x in input().split()])
if n > 1:
	print(max([max([abs(a[i] - a[i + 1]) for i in range(n - 1)]) / 2, a[0], abs(m - a[-1])]))
if n == 1:
	print(max(a[0], m - a[0]))


(n, l) = map(int, input().split())
li = list(map(int, input().split()))
li.sort()
k = 0
for i in range(n - 1):
	k = max(k, (li[i + 1] - li[i]) / 2)
k = max(k, li[0])
k = max(k, l - li[-1])
print(k)


(n, l) = [int(x) for x in input().split()]
light = list(map(int, input().split()))
light.sort()
m = 0
if len(light) == 1:
	print('%.9f' % max(light[0] - 0, l - light[0]))
else:
	for i in range(len(light) - 1):
		a = light[i + 1] - light[i]
		if m <= a:
			m = a
	b = round(m / 2, 9)
	c = max(light[0] - 0, b, l - light[-1])
	print('%.9f' % c)


(n, l) = map(int, input().split())
lanterns = sorted(list(map(int, input().split())) + [0, l])
max_d = 0
prev = 0
for lantern in lanterns:
	max_d = max([max_d, (lantern - prev) / 2])
	prev = lantern
max_d = max([max_d, lanterns[1]])
max_d = max([max_d, l - lanterns[-2]])
print(max_d)


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
maxDist = l[0]
for i in range(n - 1):
	if l[i + 1] - l[i] > maxDist:
		maxDist = l[i + 1] - l[i]
maxDist /= 2
if maxDist < l[0]:
	maxDist = l[0]
if m - l[-1] > maxDist:
	maxDist = m - l[-1]
print(maxDist)


import math
(n, l) = map(int, input().split())
poi = [int(x) for x in input().split()]
poi.sort()
bulk = [0] * (n - 1)
for i in range(n - 1):
	bulk[i] = poi[i + 1] - poi[i]
bulk.append(2 * (l - poi[-1]))
bulk.append(2 * poi[0])
d = max(bulk) / 2
print(d)


[n, l] = [int(x) for x in input().split()]
fl = [int(x) for x in input().split()]
fl.sort()
pr = 0
res = max(fl[0] + fl[0], l - fl[len(fl) - 1] + l - fl[len(fl) - 1])
for x in fl:
	res = max(res, x - pr)
	pr = x
print(res / 2)


(n, l) = map(int, input().split(' '))
alist = input().split(' ')
a = [int(i) for i in alist]
a.sort()
if a[0] != 0:
	max = a[0] * 2
else:
	max = 0
if a[-1] != l:
	if max < (l - a[-1]) * 2:
		max = (l - a[-1]) * 2
for i in range(n - 1):
	if max < a[i + 1] - a[i]:
		max = a[i + 1] - a[i]
d = max / 2
print('{0:.10f}'.format(d))


(n, l) = map(int, input().split())
S = [int(i) for i in input().split()]
S.sort()
Q = []
Q.append(S[0])
Q.append(l - S[len(S) - 1])
for i in range(len(S) - 1):
	Q.append(float((S[i + 1] - S[i]) / 2))
Q.sort()
P = float(Q[len(Q) - 1])
print('%.10f' % P)


(n, l) = [int(j) for j in input().split()]
a = [int(j) for j in input().split()]
a.sort()
md = 0
for i in range(1, n):
	d = a[i] - a[i - 1]
	if d > md:
		md = d
if md / 2 > a[0] and md / 2 > l - a[n - 1]:
	print(md / 2)
elif a[0] > md / 2 and a[0] > l - a[n - 1]:
	print(a[0])
else:
	print(l - a[n - 1])


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
max = 0
a.sort()
for i in range(n - 1):
	if a[i + 1] - a[i] > max:
		max = a[i + 1] - a[i]
an = max / 2
if an < a[0]:
	an = a[0]
if an < l - a[n - 1]:
	an = l - a[n - 1]
print(an)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
ans = a[0]
for i in range(1, n):
	ans = max(ans, (a[i] - a[i - 1]) / 2)
ans = max(ans, l - a[-1])
print(ans)


(n, l) = map(int, input().split(' '))
A = list(map(int, input().split(' ')))
A.sort()
d = 0
for i in range(0, n - 1):
	if (A[i + 1] - A[i]) / 2 > d:
		d = (A[i + 1] - A[i]) / 2
if 0 not in A:
	if A[0] > d:
		d = A[0]
if l not in A:
	if l - A[n - 1] > d:
		d = l - A[n - 1]
print(d)


(n, l) = map(int, input().split())
lista = list(map(int, input().split()))
lista.sort()
if l - lista[n - 1] > lista[0]:
	Max = 2 * (l - lista[n - 1])
else:
	Max = 2 * lista[0]
for i in range(n - 1):
	if lista[i + 1] - lista[i] > Max:
		Max = lista[i + 1] - lista[i]
print(Max / 2)


(a, b) = [int(i) for i in input().split()]
c = [int(i) for i in input().split()]
c.sort()
res = -1
for i in range(a - 1):
	temp = (c[i + 1] - c[i]) / 2
	if temp > res:
		res = temp
if c[0] != 0 and res < c[0]:
	res = c[0]
if c[-1] != b and res < b - c[-1]:
	res = b - c[-1]
print('{:.10f}'.format(res))


(n, l) = map(int, input().split())
diff = []
val = [int(x) for x in input().split()]
val.sort()
for i in range(n - 1):
	diff.append((val[i + 1] - val[i]) / 2)
if diff:
	k = max(diff)
else:
	k = val[0]
if 0 in val and n in val:
	print(max(diff))
else:
	print(max(k, val[0], l - val[n - 1]))


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
if n > 1:
	b = max((a[i + 1] - a[i] for i in range(n - 1))) / 2
	b = max(b, a[0], l - a[n - 1])
else:
	b = max(a[0], l - a[0])
print('{:.10f}'.format(b))


(n, l) = map(int, input().split())
m = [int(x) for x in input().split()]
m = sorted(m)
s = [max(m[0], l - m[n - 1])]
if n > 2:
	for i in range(0, n - 1):
		s.append((m[i + 1] - m[i]) / 2)
	print(float(max(s)))
elif n == 2:
	print(max(l - m[1], m[0], (m[1] - m[0]) / 2))
else:
	print(max(m[0], l - m[0]))


from __future__ import division, print_function
from sys import stdin, stdout
import bisect
from bisect import bisect_left as bl
from bisect import bisect_right as br
import itertools
from collections import Counter
import collections
import math
import heapq
import re

def modinv(n, p):
	return pow(n, p - 2, p)

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l

def most_frequent(list):
	return max(set(list), key=list.count)

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def ncr(n, r, p):
	t = fact[n] * (ifact[r] * ifact[n - r] % p) % p
	return t

def Convert(string):
	li = list(string.split(''))
	return li

def SieveOfEratosthenes(n):
	global prime
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	f = []
	for p in range(2, n):
		if prime[p]:
			f.append(p)
	return f
prime = []
q = []

def dfs(n, d, v, c):
	global q
	v[n] = 1
	x = d[n]
	q.append(n)
	j = c
	for i in x:
		if i not in v:
			f = dfs(i, d, v, c + 1)
			j = max(j, f)
	return j

def main():
	(n, l) = map(int, input().split())
	a = ain()
	a.sort()
	temp = [a[0], l - a[-1]]
	for i in range(n - 1):
		temp.append((a[i + 1] - a[i]) / 2)
	print(float(max(temp)))
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
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')
main()


(n, l) = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
m = 0
for i in range(n - 1):
	m = max(A[i + 1] - A[i], m)
M = max(m / 2, A[0] - 0, l - A[n - 1])
print('{0:.10f}'.format(M))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
if n == 1:
	t = a[0]
	res = max(t, l - t)
else:
	a.sort()
	tmp = max((a[i] - a[i - 1] for i in range(1, n))) / 2
	if a[0] == 0 and a[n - 1] == l:
		res = tmp
	elif a[0] == 0 and a[n - 1] != l:
		res = max(tmp, l - a[n - 1])
	elif a[0] != 0 and a[n - 1] == l:
		res = max(tmp, a[0])
	else:
		res = max(tmp, l - a[n - 1], a[0])
print('%.10f' % res)


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
max_dist = a[0] - 0
i = 1
while i < n:
	if (a[i] - a[i - 1]) / 2 > max_dist:
		max_dist = (a[i] - a[i - 1]) / 2
	i += 1
if l - a[n - 1] > max_dist:
	max_dist = l - a[n - 1]
print('%.10f' % max_dist)


arr = input().split()
n = int(arr[0])
l = int(arr[1])
a = [int(i) for i in input().split()]
a = sorted(a)
maxdist = float('-inf')
for i in range(1, len(a)):
	if a[i] - a[i - 1] > maxdist:
		maxdist = a[i] - a[i - 1]
print(max(maxdist / 2, l - a[len(a) - 1], a[0] - 0))


I = lambda : map(int, input().split())
(n, l) = I()
a = sorted(list(I()))
d = a[0]
for i in range(1, n):
	d = max(d, (a[i] - a[i - 1]) / 2)
d = max(d, l - a[-1])
print(d)


def fonary(lst, l):
	(lst1, m) = (sorted(lst), 0)
	for i in range(len(lst)):
		m = max((lst1[i] - lst1[i - 1]) / 2.0, m)
	m = max(m, max(lst1[0], l - lst1[len(lst) - 1]))
	return '{0:.10f}'.format(m)
(n, L) = [int(j) for j in input().split()]
a = [int(x) for x in input().split()]
print(fonary(a, L))


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
count = []
for i in range(len(a) - 1):
	count.append(a[i + 1] - a[i])
v = 2 * max(a[0] - 0, l - a[n - 1])
if len(count) != 0:
	count = max(max(count), v)
else:
	count = v
count = count / 2
print('{0:.10f}'.format(count))


(n, l) = [int(x) for x in input().split()]
a = [int(s) for s in input().split()]
a.sort()
b = []
if n != 1:
	for i in range(len(a) - 1):
		b.append(a[i + 1] - a[i])
	t = max(max(b) / 2, float(min(a)), float(abs(max(a) - l)))
	print('%.10f' % t)
else:
	t = max(abs(a[0] - l), a[0])
	print('%.10f' % t)


def main():
	(n, l) = map(int, input().split())
	lanterns = list(map(int, input().split()))
	lanterns.sort()
	maxDist = 0
	for i in range(n - 1):
		maxDist = max(lanterns[i + 1] - lanterns[i], maxDist)
	ans = max(lanterns[0], l - lanterns[n - 1], maxDist / 2)
	print(ans)
	return
main()


(n, l) = (int(x) for x in input().split())
list_a = list(map(int, input().split()))
list_a.sort()
caosiqunjie = max(list_a[0], l - list_a[-1])
counter_ = 0
max = caosiqunjie
for current_lan in list_a:
	cur = (current_lan - list_a[counter_ - 1]) / 2.0
	if cur > max:
		max = cur
	counter_ += 1
print(float(max))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
lol = max(a[0], l - a[-1])
ans = 0
for i in range(1, len(a)):
	m = a[i] - a[i - 1]
	ans = max(m, ans)
if lol > ans / 2:
	print(lol)
else:
	print(ans / 2)


(n, lar) = tuple(map(int, input().split()))
lin = list(map(int, input().split()))
lin.sort()
r = max(lin[0], lar - lin[n - 1])
anterior = lin[0]
for i in range(1, n):
	r = max(r, (lin[i] - anterior) / 2)
	anterior = lin[i]
print(r)


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
maxrange = a[0]
for x in range(len(a) - 1):
	if (a[x + 1] - a[x]) / 2 > maxrange:
		maxrange = (a[x + 1] - a[x]) / 2
if l - a[-1] > maxrange:
	maxrange = l - a[-1]
print(maxrange)


y = [int(x) for x in input().split()]
n = y[0]
l = y[1]
a = [int(x) for x in input().split()]
a.sort()
ans = a[0]
if n == 2:
	ans = max(a[0], (a[1] - a[0]) / 2)
	ans = max(ans, l - a[1])
	print(ans)
	exit(0)
for i in range(1, n - 1):
	ans = max(ans, max((a[i] - a[i - 1]) / 2, (a[i + 1] - a[i]) / 2))
ans = max(ans, l - a[n - 1])
print(ans)


(n, k) = input().split()
n = int(n)
k = int(k)
l = sorted([int(i) for i in input().split()])
maxradius = 0
x = 1
for x in range(n):
	radius = (l[x] - l[x - 1]) / 2
	maxradius = max(maxradius, radius, l[0], k - l[n - 1])
print(maxradius)


h = input().split()
a = int(h[0])
b = int(h[1])
l = []
c = input().split()
mx = 0
for i in range(a):
	k = int(c[i])
	l.append(k)
l.sort()
for i in range(1, a):
	p = l[i] - l[i - 1]
	if p > mx:
		mx = p
if l[0] * 2 > mx:
	mx = l[0] * 2
if (b - l[-1]) * 2 > mx:
	mx = (b - l[-1]) * 2
print(mx / 2)


(n, l) = map(int, input().split())
pos = list(map(int, input().split()))
maxd = []
pos.sort()
for i in range(n - 1):
	maxd.append(pos[i + 1] - pos[i])
if pos[0] != 0 or pos[n - 1] != l:
	initial = pos[0] * 2
	final = (l - pos[n - 1]) * 2
	maxd.append(initial)
	maxd.append(final)
print(max(maxd) / 2)


(a, b) = map(int, input().split())
z = sorted(map(int, input().split()))
q = z[0] * 2
for i in range(1, a):
	q = max(q, z[i] - z[i - 1])
q = max(q, (b - z[-1]) * 2)
print(q / 2)


(numLampadas, tamEstrada) = [int(x) for x in input().split()]
lampadas = [int(x) for x in input().split()]
lampadas.sort()
firstV = lampadas[0]
secondV = tamEstrada - lampadas[numLampadas - 1]
maxValue = 0
for i in range(numLampadas - 1):
	if lampadas[i + 1] - lampadas[i] > maxValue:
		maxValue = lampadas[i + 1] - lampadas[i]
thirdV = maxValue / 2
print(max(max(firstV, secondV), thirdV))


from sys import stdin as inp
from sys import stdout as out
from sys import maxsize as ma
(n, d) = list(map(int, inp.readline().split()))
a = list(map(int, inp.readline().split()))
a.sort()
ans = a[0] - 0
for i in range(n - 1):
	ans = max(ans, a[i + 1] - a[i])
ans = max(ans, d - a[-1])
ans /= float(2)
if a[0] != 0 and d != a[-1]:
	out.write(str(float(max(a[0] - 0, d - a[-1], ans))))
elif a[0] != 0:
	out.write(str(float(max(a[0] - 0, ans))))
else:
	out.write(str(float(max(d - a[-1], ans))))


(n, l) = [int(x) for x in input().split()]
lanterns = sorted([int(x) for x in input().split()])
distances = [(lanterns[i + 1] - lanterns[i]) / 2 for i in range(n - 1)]
if n > 1:
	m = max(distances)
else:
	m = 0
print(max(lanterns[0], l - lanterns[-1], m))


(n, l) = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
b = sorted(a)
if b[0] != 0:
	m = b[0]
else:
	m = 0
for i in range(1, n):
	if (b[i] - b[i - 1]) / 2 > m:
		m = (b[i] - b[i - 1]) / 2
if l - b[-1] > m:
	m = l - b[-1]
print(float(m))


(n, ln) = map(int, input().split())
k = list(map(int, input().split()))
k.sort()
d1 = min(k)
d3 = ln - max(k)
if n == 1:
	print(max(d1, d3))
else:
	d2_l = []
	for i in range(1, n):
		d2_l.append(abs((k[i] - k[i - 1]) / 2))
	d2 = max(d2_l)
	print(max(d1, d2, d3))


def check(mid, l):
	coveredTill = 0
	for item in arr:
		left = item - mid
		if left <= coveredTill:
			coveredTill = item + mid
		else:
			return False
	return coveredTill >= l
(n, l) = map(int, input().split())
arr = sorted([int(x) for x in input().split()])
(low, high) = (0, 2 * l)
while low < high:
	mid = (low + high) // 2
	if check(mid / 2, l):
		high = mid
	else:
		low = mid + 1
print('{:.10f}'.format(low / 2))


def inp():
	return map(int, input().split())

def arr_inp():
	return [int(x) for x in input().split()]
(n, l) = inp()
a = arr_inp()
a.sort()
m = max(a[0] - 0, l - a[-1])
for i in range(1, n):
	m = max(m, (a[i] - a[i - 1]) / 2)
print('{:.10f}'.format(m))


__author__ = 'myduomilia'
(n, l) = list(map(int, input().split()))
ans = 0
arr = list(map(int, input().split()))
arr.sort()
for i in range(1, len(arr)):
	ans = max(ans, (arr[i] - arr[i - 1]) / 2)
ans = max(ans, arr[0] - 0, l - arr[-1])
print('%0.10f' % ans)


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
i = 0
if n == 1:
	d = max(l - a[0], a[0])
else:
	d = float((a[1] - a[0]) * 0.5)
	while i <= n - 2:
		if (a[i + 1] - a[i]) * 0.5 > d:
			d = float((a[i + 1] - a[i]) * 0.5)
		i += 1
d = max(d, l - a[n - 1], a[0])
print(d)


(n, l) = map(int, input().split())
a = [int(ai) for ai in input().split()]
a.sort()
d = max(a[0], l - a[-1])
for i in range(1, n):
	if (a[i] - a[i - 1]) / 2 > d:
		d = (a[i] - a[i - 1]) / 2
print(d)


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
Max = 0
for i in range(len(a) - 1):
	if a[i + 1] - a[i] > Max:
		Max = a[i + 1] - a[i]
Max = max(Max, 2 * a[0])
Max = max(Max, 2 * (l - a[n - 1]))
print(Max / 2.0)


(n, l) = map(int, input().split())
a = list(map(int, input().split()[:n]))
a.sort()
a1 = []
a0 = a[0] - 0
an = l - a[-1]
if n > 1:
	for i in range(n - 1):
		a1.append(a[i + 1] - a[i])
	d1 = max(a1) / 2
	d2 = max(a0, an)
	print(max(d1, d2))
else:
	print(max(a0, an))


def read_nums():
	return [int(x) for x in input().split()]

def main():
	(_, length) = read_nums()
	trees = sorted(read_nums())
	if len(trees) == 1:
		res = max(trees[0], length - trees[-1])
	else:
		res = max(max([x - y for (x, y) in zip(trees[1:], trees[:-1])]) / 2, trees[0], length - trees[-1])
	print(res)
main()


(n, b) = map(int, input().split())
l = list(map(int, input().split()))
l = sorted(l)
k = b - l[-1]
if k < l[0]:
	k = l[0]
d = 0
for i in range(n - 1):
	if l[i + 1] - l[i] > d:
		d = l[i + 1] - l[i]
if d / 2 > k:
	print(d / 2)
else:
	print(k)


(n, l) = map(int, input().split())
k = sorted(list(map(int, input().split())))
a = 0
r = 0
for i in range(len(k)):
	if i + 1 < len(k):
		r = k[i + 1] - k[i]
		a = max(a, r)
a = a / 2
f = 0
if k[0] != 0:
	f = max(k[0], a)
else:
	f = a
if k[-1] != l:
	u = l - k[-1]
	f = max(f, u, a)
else:
	f = max(a, f)
print(f)


def function1(n, l, a):
	maxl = 0
	if len(a) == 1:
		return max(l - max(a), min(a), l / 2)
	a = sorted(a)
	maxl = max([a[i] - a[i - 1] for i in range(1, len(a))])
	maxl = max(l - max(a), min(a), maxl / 2)
	return maxl

def main():
	(n, l) = list(map(int, input().split()))
	a = list(map(int, input().split()))
	print(function1(n, l, a))
main()


def special_minus(e, d):
	return max(e - d, 0)

def special_add(e, d, l):
	return min(e + d, l)

def not_intersect(inter1, inter2):
	a_s = inter1[0]
	a_e = inter1[1]
	b_s = inter2[0]
	b_e = inter2[1]
	return b_s > a_e or a_s > b_e

def find_size(tab, d, l):
	union_intervals = [special_minus(tab[0], d), special_add(tab[0], d, l)]
	for i in range(1, len(tab)):
		e = tab[i]
		interval = [special_minus(e, d), special_add(e, d, l)]
		if not_intersect(union_intervals, interval):
			return False
		else:
			union_intervals = [min(min(interval), min(union_intervals)), max(max(interval), max(union_intervals))]
	if union_intervals[0] > 0 or union_intervals[1] < l:
		return False
	else:
		return True

def binary_search(tab, n, l):
	left = 0
	right = l
	break_point = 100
	while left <= right and break_point != 0:
		mid = (left + right) / 2
		if find_size(tab, mid, l):
			right = mid
		else:
			left = mid
		break_point -= 1
	return left
(n, l) = map(int, input().split())
tab = sorted(list(map(int, input().split())))
print(binary_search(tab, n, l))


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
maxR = 0
if 0 not in l:
	maxR = min(l) * 2
if m not in l and m - max(l) > maxR / 2:
	maxR = (m - max(l)) * 2
for i in range(1, n):
	if maxR < l[i] - l[i - 1]:
		maxR = l[i] - l[i - 1]
print(maxR / 2)


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
max1 = max(a[0], l - a[-1])
for i in range(1, n):
	if (a[i] - a[i - 1]) / 2 > max1:
		max1 = (a[i] - a[i - 1]) / 2
print('%.10f' % max1)


def main():
	(n, l) = map(int, input().split())
	lantern = list(map(int, input().split()))
	lantern.sort()
	if len(lantern) == 1:
		ans = max(lantern[0] - 0, l - lantern[0])
		print(ans)
	else:
		for i in lantern:
			if i == 0:
				l1 = lantern[1:]
				l2 = lantern[:-1]
				distance = []
				zip_object = zip(l1, l2)
				for (l1_i, l2_i) in zip_object:
					distance.append(l1_i - l2_i)
				y = 0
				for i in distance:
					x = i / 2
					y = max(x, y)
					z = l - lantern[-1]
					ans = max(y, z)
				print(ans)
				break
			else:
				l1 = lantern[1:]
				l2 = lantern[:-1]
				distance = []
				zip_object = zip(l1, l2)
				for (l1_i, l2_i) in zip_object:
					distance.append(l1_i - l2_i)
				y = 0
				for i in distance:
					x = i / 2
					y = max(x, y)
					z = l - lantern[-1]
					ans = max(y, z, lantern[0])
				print(ans)
				break
main()


(n, l) = map(int, input().split())
i = 0
li = list(map(float, input().split()))
li.sort()
mx = -1
i = 0
for i in range(0, n - 1):
	d = abs(li[i] - li[i + 1])
	mx = max(d, mx)
	i += 1
print(max(li[0] - 0, l - li[n - 1], mx / 2))


b = []
for _ in input().split():
	b.append(int(_))
n = b[0]
l = b[1]
b = []
for a in input().split():
	b.append(int(a))
b.sort()
max1 = b[0]
for i in range(1, n):
	if (b[i] - b[i - 1]) / 2 > max1:
		max1 = (b[i] - b[i - 1]) / 2
if l - b[n - 1] > max1:
	max1 = l - b[n - 1]
print(max1)


(n, k) = map(int, input().strip().split())
import math
arr = list(map(int, input().strip().split()))
arr = sorted(arr)
ans = 0
ans = arr[0]
for i in range(1, n):
	if 2 * ans < arr[i] - arr[i - 1]:
		ans = math.ceil((arr[i] - arr[i - 1]) / 2)
ans = max(ans, k - arr[n - 1])
te = (2 * ans - 1) // 2
ll = 0
c = 1
for i in range(n):
	l = max(arr[i] - te, 0)
	r = min(arr[i] + te, k)
	if l <= ll:
		ll = r
	else:
		if i != 0:
			if l <= ll + 1:
				ll = r
				continue
		c = 0
		break
if c == 1:
	if r >= k:
		pass
	else:
		c = 0
if c == 0:
	print(ans)
else:
	print((2 * ans - 1) / 2)


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
ans = max(min(a), l - max(a))
for i in range(n - 1):
	ans = max(ans, (a[i + 1] - a[i]) / 2)
print(ans)


Datos = input()
Datos = Datos.split()
N = int(Datos[0])
L = int(Datos[1])
F = input()
F = F.split()
NF = []
for K in range(N):
	X = int(F[K])
	NF = NF + [X]
NF.sort()
RadioMayor = NF[0] - 0
for J in range(N):
	if J < N - 1:
		Y = NF[J + 1] - NF[J]
		if Y / 2 > RadioMayor:
			RadioMayor = Y / 2
	else:
		Z = NF[J] - NF[J - 1]
		if Z / 2 > RadioMayor:
			RadioMayor = Z / 2
W = L - NF[N - 1]
if W > RadioMayor:
	RadioMayor = W
if RadioMayor == 0:
	print(1)
else:
	print(RadioMayor)


def mr(n, l, v):
	v.sort()
	m = 0
	for x in range(n - 1):
		t = v[x + 1] - v[x]
		if t > m:
			m = t
	return max(m / 2, v[0], l - v[-1])
(n, l) = [int(x) for x in input().split()]
v = [int(x) for x in input().split()]
print(mr(n, l, v))


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
m = max(a[0], l - a[-1]) * 2
for i in range(1, len(a)):
	m = max(a[i] - a[i - 1], m)
print(m / 2)


(n, l) = map(int, input().split())
coord = [int(x) for x in input().split()]
coord.sort()
distance = []
for i in range(n - 1):
	distance.append(coord[i + 1] - coord[i])
for i in range(len(distance)):
	distance[i] = distance[i] / 2
if 0 not in coord:
	distance.append(coord[0])
if l not in coord:
	distance.append(l - coord[n - 1])
print(max(distance))


(n, m) = map(int, input().split())
arr = list(map(int, input().split()))
if len(arr) == 1:
	print(max(m - arr[0], arr[0]))
	exit()
j = 0
ans = 0
arr.sort()
ans = max(arr[0] - 0, m - arr[n - 1])
j = arr[0]
if n == 2:
	ans = max(ans, (arr[n - 1] - arr[0]) / 2)
del arr[0]
for i in arr:
	ans = max((i - j) / 2, ans)
	j = i
print(ans)


(n, l) = map(int, input().split())
DistF = list(map(int, input().split()))
SortDistF = sorted(DistF)

def Inspect(d):
	if d < SortDistF[0] or d < l - SortDistF[-1]:
		return False
	for i in range(len(SortDistF) - 1):
		if abs(SortDistF[i] - SortDistF[i + 1]) >= 2 * d:
			return False
	return True
c = 0
(left, right, middle) = (0, l, 0)
while right - left >= 10 ** (-10):
	c += 1
	middle = (right + left) / 2
	if Inspect(middle):
		right = middle
	else:
		left = middle
	if c > 10 ** 3:
		break
if c == 10 ** 3 + 1:
	print(round(left, 5))
else:
	print(round(left, 10))


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
d = max(arr[0], l - arr[-1])
for i in range(len(arr) - 1):
	if d < (arr[i + 1] - arr[i]) / 2:
		d = (arr[i + 1] - arr[i]) / 2
print(d)


(n, l) = map(int, input().split())
array = sorted(list(map(int, input().split())))
distance = 0
for i in range(len(array) - 1):
	distance = max(distance, array[i + 1] - array[i])
distance = max(array[0] - 0, l - array[-1], distance / 2)
print(distance)


L = input().split()
n = int(L[0])
l = int(L[1])
A = input().split()
A = [int(i) for i in A]
A.sort()
mini = A[0]
maxi = A[n - 1]
max_dif = 0
dif = 0
for i in range(len(A) - 1):
	dif = A[i + 1] - A[i]
	if dif > max_dif:
		max_dif = dif
print(max(mini, max_dif / 2, l - maxi))


k = input()
n = int(k.split()[0])
l = int(k.split()[1])
a = input()
a = a.split()
a = [int(i) for i in a]
a = sorted(a)
dis = 0
for i in range(1, n):
	if dis < a[i] - a[i - 1]:
		dis = a[i] - a[i - 1]
if a[0] - 0 > l - a[-1]:
	m = a[0] - 0
else:
	m = l - a[-1]
if m < dis / 2:
	print(dis / 2)
else:
	print(m)


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
maxi = 0
b = a[0] - 0
c = l - a[n - 1]
for i in range(len(a) - 1):
	if a[i + 1] - a[i] > maxi:
		maxi = a[i + 1] - a[i]
xx = max(maxi / 2, max(b, c))
print('{0:.10f}'.format(round(xx, 10)))


from sys import stdin
a = [int(x) for x in stdin.readline().split()]
n = sorted([int(x) for x in stdin.readline().split()])
m = [n[0] - 0, a[1] - n[-1]]
for i in range(len(n) - 1):
	m.append((n[i + 1] - n[i]) / 2)
print(max(m))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
gap = 0
rez = 0
maxn = float(max(a))
minn = float(min(a))
a.sort()
if n > 1:
	gap = max((abs(x - y) for (x, y) in zip(a[1:], a[:-1])))
	rez = gap / 2
if minn > rez and minn != 0:
	rez = minn
if l - maxn > rez:
	rez = l - maxn
print(rez)


(a, b) = list(map(int, input().split(' ')))
c = list(map(int, input().split(' ')))
c.sort()
d = list()
e = abs(0 - c[0])
f = abs(b - c[-1])
for i in range(0, a - 1):
	d.append(abs(c[i] - c[i + 1]))
if len(d) == 0 or a == 1:
	g = max(e, f)
	print('%0.10f' % g)
else:
	g = max(d) / 2
	if g > e and g > f:
		print('%0.10f' % g)
	else:
		print('%0.10f' % max(e, f))


from collections import *
from sys import *
inp = stdin.readline
(n, l) = map(int, inp().split())
nl = list(map(int, inp().split()))
nl.sort()
minans = 0
for i in range(n - 1):
	if nl[i + 1] - nl[i] > minans:
		minans = nl[i + 1] - nl[i]
print(max(minans / 2, nl[0] - 0, l - nl[-1]))


arr = list(map(int, input().strip().split()))
l = list(map(int, input().strip().split()))
l.sort()
m = 0
if 0 not in l:
	m = max(m, l[0])
if arr[1] not in l:
	m = max(m, arr[1] - l[-1])
for i in range(len(l) - 1):
	a = l[i + 1] - l[i]
	m = max(m, a / 2)
print(m)


(a, m) = map(int, input().split())
n = input().split()
n = sorted(n, key=int)
cmax = 0
c = 0
for i in range(a - 1):
	c = int(n[i + 1]) - int(n[i])
	if c > cmax:
		cmax = c
c1 = cmax / 2
ol = m - int(n[a - 1])
lmm = max(int(n[0]), ol)
if c1 > lmm:
	print('%.10f' % c1)
else:
	print('%.10f' % lmm)


(n, l1) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
raz = 0
for i in range(len(a) - 1):
	raz = max(raz, a[i + 1] - a[i])
print(max(raz / 2, max(a[0] - 0, l1 - a[n - 1])))


a = list(map(int, input().split()))
b = list(map(int, input().split()))
n = a[0]
l = a[1]
b = sorted(b)
maxdiff = max(b[0] * 2, (l - b[-1]) * 2)
for i in range(len(b) - 1):
	diff = b[i + 1] - b[i]
	maxdiff = max(diff, maxdiff)
print(maxdiff / 2)


(n, l) = map(int, input().split())
lan = input().split()
lan = sorted(lan, key=int)
count = int(lan[0])
for i in range(1, n):
	if int(lan[i]) - int(lan[i - 1]) > count:
		count = int(lan[i]) - int(lan[i - 1])
radius = count / 2
if radius > int(lan[0]):
	radius = radius
else:
	radius = int(lan[0])
if radius > l - int(lan[-1]):
	radius = radius
else:
	radius = l - int(lan[-1])
print(radius)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
a.append(l)
x = a[0] - 0
for i in range(1, n + 1):
	y = (a[i] - a[i - 1]) / 2
	if i == n:
		if 2 * y > x:
			x = 2 * y
	elif y > x:
		x = y
x = float(x)
z = '%.10f' % x
print(z)


(n, l) = map(lambda x: int(x), input().split())
num = input()
list = [int(x) for x in num.split()]
list.sort()
l1 = []
for i in range(n - 1):
	l1.append((list[i + 1] - list[i]) / 2)
if 0 not in list:
	l1.append(list[0])
if l not in list:
	l1.append(l - list[-1])
print(max(l1))


n = input().split(' ')
l = int(n[1])
n = int(n[0])
lamps = list(map(int, input().split()))
lamps.sort()
longest = -1
for i in range(0, len(lamps) - 1):
	if lamps[i + 1] - lamps[i] > longest:
		longest = lamps[i + 1] - lamps[i]
longest = longest / 2
if longest < lamps[0] - 0:
	longest = lamps[0] - 0
if longest < l - lamps[-1]:
	longest = l - lamps[-1]
print(longest)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
t1 = [a[i + 1] - a[i] for i in range(len(a) - 1)]
t2 = [t1[i] / 2 for i in range(len(t1))]
if n == 1:
	print(max(a[0], l - a[0]))
elif '0' in a and int(l) in a:
	print(max(t2))
elif '0' in a and int(l) not in a:
	print(max(max(t2), l - a[-1]))
elif '0' not in a and int(l) in a:
	print(max(a[0], max(t2)))
else:
	print(max(max(t2), a[0], l - a[-1]))


x = input()
(n, l) = (int(x.split()[0]), int(x.split()[1]))
y = input()
values = [int(i) for i in y.split()]
result = l - max(values)
if min(values) > result:
	result = min(values)
values.sort()
for i in range(len(values) - 1):
	c = values[i + 1] - values[i]
	if c > result:
		result = c
print(max(result / 2, l - max(values), min(values)))


(n, l) = map(int, input().split())
array = list(map(int, input().split()[:n]))
if n == 1:
	if l - array[0] > array[0]:
		print(l - array[0])
	else:
		print(array[0])
else:
	array.sort()
	max0 = array[1] - array[0]
	for x in range(n - 1):
		if array[x + 1] - array[x] > max0:
			max0 = array[x + 1] - array[x]
	if max0 / 2 < array[0] and max0 / 2 < l - array[-1]:
		if l - array[-1] > array[0]:
			print(l - array[-1])
		else:
			print(array[0])
	elif max0 / 2 < array[0]:
		print(array[0])
	elif max0 / 2 < l - array[-1]:
		print(l - array[-1])
	else:
		print(max0 / 2)


(n, length) = [int(x) for x in input().split()]
lanterns = set((int(x) for x in input().split()))
positions = [0] + sorted(lanterns) + [length]
max_distance = max(((b - a) * (2 if pos == 0 or pos == len(positions) - 2 else 1) for (pos, (a, b)) in enumerate(zip(positions, positions[1:]))))
print(max_distance / 2)


def func(k):
	n = list(map(int, input().split()))
	n.sort()
	maximum = 0
	if 0 in n and k[1] in n:
		for i in range(len(n) - 1):
			temp = n[i + 1] - n[i]
			if temp > maximum:
				maximum = temp
		print(maximum / 2)
		return
	else:
		if 0 not in n:
			n.insert(0, 0)
		if k[1] not in n:
			n.append(k[1])
			last_difference = n[-1] - n[-2]
		else:
			last_difference = n[-1] - k[1]
		difference_zero = n[1] - n[0]
		temp = max(difference_zero, last_difference)
		for i in range(len(n) - 1):
			if (n[i + 1] - n[i]) / 2 > temp:
				temp = (n[i + 1] - n[i]) / 2
		if temp / 2 >= max(difference_zero, last_difference) / 2:
			print(temp)
		else:
			print(temp / 2)
k = list(map(int, input().split()))
func(k)


(n, k) = map(int, input().split())
list = list(map(int, input().split()))
list.sort()
m = float(0)
for i in range(0, n - 1):
	m = max(list[i + 1] - list[i], m)
m = float(m) / 2
if list[0] != 0:
	m = max(m, list[0])
if list[n - 1] != k:
	m = max(m, k - list[n - 1])
print(str(float(m)) + '0' * 8)


(num, long) = input().split()
num = int(num)
long = int(long)
lamp_place = input().split()
for m in range(num):
	lamp_place[m] = int(lamp_place[m])
lamp_place.sort()
ans_group = []
for i in range(num - 1):
	a = lamp_place[i + 1] - lamp_place[i]
	a = a / 2
	ans_group.append(a)
ans_group.append(lamp_place[0])
ans_group.append(long - lamp_place[-1])
ans = float(max(ans_group))
print('%.10f' % ans)


A = list(map(int, input().split()))
L = list(map(int, input().split()))
L.append(-min(L))
L.sort()

def Fasl(Array):
	Out = 0
	for I in range(len(Array) - 1):
		if Array[I + 1] - Array[I] > Out:
			Out = Array[I + 1] - Array[I]
	return Out
fasl = Fasl(L) / 2
If = A[1] - max(L)
if If > fasl:
	print(If)
else:
	print(fasl)


(n, l) = map(int, input().split())
lanterns = list(map(int, input().split()))
lanterns.sort()
dx = []
for i in range(n + 1):
	if i == 0:
		dx.append(lanterns[0])
	elif i == n:
		dx.append(l - lanterns[n - 1])
	else:
		dx.append(lanterns[i] - lanterns[i - 1])
print(format(max(max(dx) / 2, dx[0], dx[n]), '.10f'))


def main():
	(n, l) = map(int, input().split())
	lst = list(map(int, input().split()))
	lst.sort()
	rez = 2 * max(lst[0], l - lst[n - 1])
	for i in range(n - 1):
		rez = max(rez, lst[i + 1] - lst[i])
	print(rez / 2)
main()


(n, l) = map(int, input().split())
s = [int(x) for x in input().split()]
s.sort(reverse=True)
s1 = [l - s[0]]
k = 0
if n > 2:
	for i in range(n - 1):
		s1.append(s[i] - s[i + 1])
	k = max(s1[1:])
elif n == 2:
	k = s[0] - s[1]
s1.append(s[n - 1] - 0)
t = max(k / 2, s1[0], s1[-1])
print(t)


inp = input().split(' ')
n = inp[0]
l = inp[1]
a = []
inp1 = input().split(' ')
p = []
z = 0
for i in range(int(n)):
	a.append(int(inp1[i]))
a.sort()
for i in range(int(int(n) - 1)):
	p = int(a[i + 1] - a[i])
	if p > z:
		z = p
k1 = a[0] - 0
k = int(l) - int(a[int(n) - 1])
j = z / 2
if k1 >= k:
	o = k1
else:
	o = k
if j > o:
	print(j)
else:
	print(o)


(n, l) = map(int, input().split())
L = list(map(int, input().split()))
L.sort()
max_d = max(L[0], l - L[-1])
for i in range(1, n):
	max_d = max(max_d, (L[i] - L[i - 1]) / 2)
print(max_d)


k = input().split(' ')
inp = input().split(' ')
no_of_lanterns = int(k[0])
l = int(k[1])
lanterns = [int(i) for i in inp]
lanterns.sort()
max_dist = 0
for i in range(1, no_of_lanterns):
	difference = lanterns[i] - lanterns[i - 1]
	if difference > max_dist:
		max_dist = difference
radius = max(lanterns[0] - 0, l - lanterns[-1], max_dist / 2)
print(radius)


(n, k) = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
d = -999
for i in range(len(a) - 1):
	if abs(a[i] - a[i + 1]) > d:
		d = abs(a[i] - a[i + 1])
m = max(a[0] - 0, k - a[-1])
d = d / 2
if m > d:
	d = m
print(d)


[n, l] = list(map(int, input().split(' ')))
X = list(map(int, input().split(' ')))
X = sorted(X)
roz = 2 * max(X[0] - 0, l - X[-1])
for i in range(1, len(X)):
	roz = max(roz, X[i] - X[i - 1])
print(roz / 2)


from decimal import *
getcontext().prec = 30
(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()

def p(x):
	if arr[0] > x:
		return False
	for i in range(n - 1):
		if arr[i + 1] - arr[i] > 2 * x:
			return False
	if l - arr[-1] > x:
		return False
	return True
low = Decimal(0)
high = Decimal(l)
while high - low > 1e-09:
	mid = low + (high - low) / 2
	if p(mid):
		high = mid
	else:
		low = mid
print(low)


(n, l) = map(int, input().split(' '))
items = map(int, input().split(' '))
points = sorted(items)
a = points[0] * 2
b = (l - points[-1]) * 2
x = max(a, b)
for i in range(len(points) - 1):
	y = points[i + 1] - points[i]
	if x < y:
		x = y
r = x / 2
print(r)


(n, l) = map(int, input().split())
k = input().split(' ')
arr = []
for i in range(n):
	arr.append(int(k[i]))
arr.sort()
if arr[0] == 0 and arr[n - 1] == l:
	d = 0
	for i in range(n - 1):
		if d < arr[i + 1] - arr[i]:
			d = arr[i + 1] - arr[i]
	print(d / 2)
elif arr[0] == 0:
	d = 0
	for i in range(n - 1):
		if d < arr[i + 1] - arr[i]:
			d = arr[i + 1] - arr[i]
	print(max(d / 2, l - arr[n - 1]))
elif arr[n - 1] == l:
	d = 0
	for i in range(n - 1):
		if d < arr[i + 1] - arr[i]:
			d = arr[i + 1] - arr[i]
	print(max(d / 2, arr[0]))
else:
	d = 0
	for i in range(n - 1):
		if d < arr[i + 1] - arr[i]:
			d = arr[i + 1] - arr[i]
	print(max(d / 2, l - arr[n - 1], arr[0]))


(a, b) = map(int, input().split())
s = list(map(int, input().split()))
s.sort()
m = []
m.append(s[0])
m.append(b - s[a - 1])
for i in range(a - 1):
	t = (s[i + 1] - s[i]) / 2
	m.append(t)
print(max(m))


def lanterns():
	i1 = input()
	i1 = i1.split(' ')
	nolanters = int(i1[0])
	streetl = int(i1[1])
	lpos = input()
	lpos = lpos.split(' ')
	lanternpos = []
	for k in range(len(lpos)):
		lanternpos.append(int(lpos[k]))
	insertionsort(lanternpos)
	maxdist = 0
	for k in range(len(lanternpos) - 1):
		dist = (lanternpos[k + 1] - lanternpos[k]) / 2
		if dist > maxdist:
			maxdist = dist
	if lanternpos[0] > maxdist:
		maxdist = lanternpos[0]
	if int(streetl) - lanternpos[-1] > maxdist:
		maxdist = int(streetl) - lanternpos[-1]
	print('%0.10f' % maxdist)

def insertionsort(alist):
	for i in range(len(alist)):
		for j in range(0, i):
			if alist[j] > alist[i]:
				(alist[i], alist[j]) = (alist[j], alist[i])
	return alist
lanterns()


(n, l) = [int(i) for i in input().split()]
a = sorted([float(i) for i in input().split()])
maximo = max(a[0], l - a[n - 1])
for i in range(1, n, 1):
	maximo = max(maximo, (a[i] - a[i - 1]) / 2)
print('%.10f' % maximo)
exit(0)


def mergeSort(lst):
	if len(lst) > 1:
		mid = len(lst) // 2
		left = lst[:mid]
		mergeSort(left)
		right = lst[mid:]
		mergeSort(right)
		(i, j, k) = (0, 0, 0)
		while i < len(left) and j < len(right):
			if left[i] <= right[j]:
				lst[k] = left[i]
				i += 1
			else:
				lst[k] = right[j]
				j += 1
			k += 1
		while i < len(left):
			lst[k] = left[i]
			k += 1
			i += 1
		while j < len(right):
			lst[k] = right[j]
			k += 1
			j += 1

def minimumRadius(lst, end):
	start = 0
	end = end
	mergeSort(lst)
	distance = max(lst[0], end - lst[-1])
	for i in range(len(lst) - 1):
		if distance < (lst[i + 1] - lst[i]) / 2:
			distance = (lst[i + 1] - lst[i]) / 2
	return distance
(n, l) = [int(x) for x in input().split()]
lst = [int(x) for x in input().split()]
print(minimumRadius(lst, l))


(n, l) = (int(z) for z in input().split())
list = input().split()
list = [int(i) for i in list]
list.sort()
n = 0
m = max(list[0] - 0, l - list[n - 1])
for x in range(len(list) - 1):
	n = max(n, list[x + 1] - list[x])
if m > n / 2:
	print(m)
else:
	print('{:.9f}'.format(n / 2))


(a, b) = input().split(' ')
c = input().split(' ')
c.append(b)
c.append(0)
for i in range(len(c)):
	c[i] = int(c[i])
c.sort(reverse=True)
d = 0
for i in range(len(c) - 1):
	if i == 0:
		if (c[i] - c[i + 1]) * 2 > d:
			d = (c[i] - c[i + 1]) * 2
	elif i == len(c) - 2:
		if (c[i] - c[i + 1]) * 2 > d:
			d = (c[i] - c[i + 1]) * 2
	elif c[i] - c[i + 1] > d:
		d = c[i] - c[i + 1]
print(d / 2)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
r = max(arr[0], k - arr[-1])
for i in range(1, n):
	r = max(r, (arr[i] - arr[i - 1]) / 2)
print('%.10f' % r)


(n, l) = [int(i) for i in input().split(' ')]
lanterns = sorted([int(i) for i in input().split(' ')])
min_radius = max(lanterns[0], l - lanterns[-1])
for i in range(len(lanterns) - 1):
	min_radius = max(min_radius, (lanterns[i + 1] - lanterns[i]) / 2)
print(f'{min_radius:.10f}')


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
b = []
for i in range(n - 1):
	b.append((a[i + 1] - a[i]) / 2)
if a[0] != 0:
	b.append(a[0])
if a[n - 1] != l:
	b.append(l - a[n - 1])
print(max(b))


(l, n) = map(int, input().split())
x = list(sorted(map(int, input().split())))
maxval = 0
if x[0] - 0 > n - x[-1]:
	maxval = x[0] - 0
else:
	maxval = n - x[-1]
for i in range(1, len(x)):
	tmp = (x[i] - x[i - 1]) / 2
	maxval = max(maxval, tmp)
print(format(maxval, '.10f'))


(n, t) = map(int, input().split())
l = list(map(int, input().split()))
l = sorted(l)
m = float(0)
for i in range(0, n - 1):
	m = max(l[i + 1] - l[i], m)
m = float(m) / 2
if l[0] != 0:
	m = max(m, l[0])
if l[n - 1] != t:
	m = max(m, t - l[n - 1])
m = float(m)
print(str(m) + '0' * 8)


(n, L) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
diff = []
j = 0
if 0 not in a:
	diff.append(a[0])
if L not in a:
	diff.append(abs(L - a[len(a) - 1]))
for i in range(len(a) - 1):
	diff.append(abs(a[i + 1] - a[i]) / 2)
print(max(diff))


(a, b) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
s = max(l[0], b - l[-1])
for i in range(a - 1):
	if l[i + 1] - l[i] > 2 * s:
		s = (l[i + 1] - l[i]) / 2
print(s)


zzzz = input().split(' ')
(nxxx, lantrn) = (int(zzzz[0]), int(zzzz[1]))
listw = [int(x) for x in input().split(' ')]
listw.sort()
list2 = []
for i in range(0, nxxx - 1):
	list2.append((listw[i + 1] - listw[i]) / 2)
if listw.count(0) == 0:
	list2.append(listw[0])
if listw.count(listw) == 0:
	list2.append(lantrn - listw[nxxx - 1])
print(max(list2))


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
first_post = arr[0] - 0
arr.append(0)
arr.append(l)
arr.sort()
last_pos = abs(arr[-2] - arr[-1])
max_dist = -1
for i in range(len(arr) - 1):
	if abs(arr[i + 1] - arr[i]) > max_dist:
		max_dist = abs(arr[i + 1] - arr[i])
print(max(float(first_post), float(max_dist / 2), float(last_pos)))


a = input('')
b = input('')
l = a.split(' ')
d = []
c = b.split(' ')
for z in c:
	d.append(int(z))
m = sorted(d)
p = []
if m[0] != 0:
	p.append(m[0] - 0)
if m[len(m) - 1] != int(l[1]):
	p.append(int(l[1]) - m[len(m) - 1])
i = 1
while i < len(m):
	p.append(float(m[i] - m[i - 1]) / 2)
	i = i + 1
q = sorted(p)
print('{:.10f}'.format(q[len(q) - 1]))


(n, l) = map(int, input().split())
road = list(map(int, input().split()))
road.sort()
if n != 1:
	tmp = max(road[0] - 0, l - road[n - 1])
	ans = road[1] - road[0]
	for i in range(n - 1):
		temp = road[i + 1] - road[i]
		if temp > ans:
			ans = temp
	if tmp < ans / 2:
		print(str(round(ans / 2, 10)))
	else:
		print(str(tmp))
else:
	print(str(max((road[0] - 0, l - road[0]))))


(n, l) = [int(x) for x in input().split()]
vals = [int(x) for x in input().split()]
vals.sort()
d = max(vals[0], l - vals[len(vals) - 1])
for i in range(len(vals) - 1):
	dif = vals[i + 1] - vals[i]
	if dif > 2 * d:
		d = dif / 2
print(d)


(lights, str_len) = [int(x) for x in input().split()]
coors = [int(x) for x in input().split()]
coors.sort()
max_rad = coors[0]
for i in range(1, len(coors)):
	rad = (coors[i] - coors[i - 1]) / 2
	max_rad = rad if rad > max_rad else max_rad
if coors[-1] != str_len:
	rad = str_len - coors[lights - 1]
	max_rad = rad if rad > max_rad else max_rad
if coors[0] != 0:
	rad = coors[0]
	max_rad = rad if rad > max_rad else max_rad
print(max_rad)


MI = lambda : map(int, input().split())
LI = lambda : list(MI())
(n, l) = MI()
a = sorted(LI())
ans = a[0]
for i in range(1, len(a)):
	ans = max([ans, (a[i] - a[i - 1]) / 2])
if a[-1] != l:
	ans = max([ans, l - a[-1]])
print(ans)


(n, l) = map(int, input().split())
l = float(l)
A = sorted(list(map(float, input().split())))
d = 0.0
for i in range(1, n):
	d = max(d, (A[i] - A[i - 1]) / 2)
d = max(d, A[0] - 0)
d = max(d, l - A[-1])
print(d)


(n, l) = list(map(int, input().split()))
lanterns = list(map(int, input().split()))
lanterns.sort()
adj_diff = list(map(lambda x: (lanterns[x + 1] - lanterns[x]) / 2, list(range(len(lanterns) - 1))))
adj_diff += [lanterns[0] - 0, l - lanterns[-1]]
print(max(adj_diff))


temp = list(map(int, input().split()))
number_of_laterns = temp[0]
length_of_street = temp[1]
latern_locations = list(map(int, input().split()))
latern_locations = sorted(latern_locations)
radius = 0
temp_max = 0
final_max = 0
for element in range(len(latern_locations) - 1):
	temp_max = 0
	temp_max = latern_locations[element + 1] - latern_locations[element]
	if temp_max > final_max:
		final_max = temp_max
	radius = final_max / 2
if latern_locations[0] - radius > 0:
	radius = radius + (latern_locations[0] - radius)
if latern_locations[-1] + radius < length_of_street:
	radius = length_of_street - latern_locations[-1]
print(radius)


f = lambda : map(int, input().split())
(n, l) = f()
s = sorted(f())
print(max([s[0], l - s[n - 1]] + [(b - a) / 2 for (a, b) in zip(s, s[1:])]))


(n, l) = map(int, input().rstrip().split())
mylist = sorted(list(map(int, input().rstrip().split())))
ans = 0
prev = 0
for i in range(n):
	curr = mylist[i]
	if i + 1 < n:
		next = mylist[i + 1]
	else:
		next = l
	if i == 0:
		if curr == 0:
			if next == l and i + 1 >= n:
				ans = l
			else:
				ans = (next - curr) / 2
			continue
		else:
			leftd = curr - prev
			rightd = next - curr
			if next == l and i + 1 >= n:
				ans = max(ans, max(leftd, rightd))
			else:
				ans = max(ans, max(leftd, rightd / 2))
			prev = curr
			continue
	if i == n - 1:
		if curr == l:
			ans = max(ans, (curr - prev) / 2)
			continue
		else:
			leftd = curr - prev
			rightd = next - curr
			ans = max(ans, max(leftd / 2, rightd))
			continue
	rightd = next - curr
	ans = max(ans, rightd / 2)
	prev = curr
print(ans)


(n, l) = map(int, input().split())
s = list(map(int, input().split()))
s.sort()
d = max(s[0], l - s[-1])
i = 1
while i < n:
	a = (s[i] - s[i - 1]) / 2
	if a > d:
		d = a
	i = i + 1
print(d)


def main():
	(n, l) = tuple(map(int, input().rstrip().split()))
	A = sorted(map(int, input().rstrip().split()))
	ma = 0
	if n != 1:
		D = (j - i for (i, j) in zip(A, A[1:]))
		ma = max(D) / 2
	print(max(ma, A[0], l - A[-1]))
main()


(n, k) = map(int, input().split())
u = [0]
l = sorted(list(map(int, input().split())))
for i in range(len(l) - 1):
	u.append(l[i + 1] - l[i])
y = max(l[0] - 0, k - l[-1])
z = max(u) / 2
print(max(y, z))


(n, l) = input().split()
n = int(n)
l = int(l)
arr = list(map(int, input().split()))
arr.sort()
b = -1
for i in range(0, n - 1):
	d = (arr[i + 1] - arr[i]) / 2
	if d > b:
		b = d
if arr[0] != 0:
	d = arr[0] - 0
	if d > b:
		b = d
if arr[n - 1] != l:
	d = l - arr[n - 1]
	if d > b:
		b = d
print('{:0.10f}'.format(b))


(n, l) = input().split()
n = int(n)
l = int(l)
a = [int(x) for x in input().split()]
a.sort()
Max = 0
for i in range(n - 1):
	if a[i + 1] - a[i] > Max:
		Max = a[i + 1] - a[i]
dis = Max / 2.0
d = max(a[0] - 0, l - a[n - 1], dis)
print('%.10f' % d)


(n, l) = list(map(int, input().split()))
li = list(map(int, input().split()))[:n]
li.sort()
li2 = []
if len(li) == 1:
	if li[0] == 0 or li[0] == l:
		print(format(l, '.10f'))
	else:
		beforediff = li[0] - 0
		afterdiff = l - li[0]
		print(format(max(afterdiff, beforediff), '.10f'))
else:
	for i in range(len(li)):
		if i == 0:
			if li[i] == 0:
				afterdiff = (li[i + 1] - li[i]) / 2
				li2.append(afterdiff)
			else:
				beforediff = li[i] - 0
				afterdiff = (li[1] - li[0]) / 2
				li2.append(max(beforediff, afterdiff))
		elif i == len(li) - 1:
			if li[i] == l:
				beforediff = (li[i] - li[i - 1]) / 2
				li2.append(beforediff)
			else:
				afterdiff = l - li[i]
				beforediff = (li[i] - li[i - 1]) / 2
				li2.append(max(beforediff, afterdiff))
		else:
			beforediff = (li[i] - li[i - 1]) / 2
			afterdiff = (li[i + 1] - li[i]) / 2
			li2.append(max(beforediff, afterdiff))
	print(format(max(li2), '.10f'))


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
x = 0
for i in range(n - 1):
	x = max(x, a[i + 1] - a[i])
x = x / 2
x = max(x, max(a[0], l - a[n - 1]))
x = str(x)
if x[len(x) - 2] == '.':
	print(x + 8 * '0')
else:
	print(x + '.' + 9 * '0')


(n, l) = input().split()
(n, l) = (int(n), int(l))
a = input().split()
for i in range(len(a)):
	a[i] = int(a[i])
a.sort()
diff = []
for i in range(len(a) - 1):
	diff.append((a[i + 1] - a[i]) / 2)
if a[0] != 0:
	diff.append(a[0])
if a[len(a) - 1] != l:
	diff.append(l - a[len(a) - 1])
ans = max(diff)
print(ans)


(ln, l) = map(int, input().split())
pl = list(map(int, input().split()))
pl = sorted(pl)
maxo = 0
if 0 not in pl:
	maxo = pl[0]
for i in range(0, len(pl) - 1):
	temp = (pl[i + 1] - pl[i]) / 2
	if temp > maxo:
		maxo = temp
if l not in pl:
	temp = l - pl[-1]
	if temp > maxo:
		maxo = temp
print('%.10f' % maxo)


(n, l) = map(int, input().split())
k = sorted(list(map(int, input().split())))
d1 = k[0] - 0
d2 = l - k[-1]
if d1 > d2:
	d = d1
else:
	d = d2
for i in range(len(k) - 1):
	d1 = (k[i + 1] - k[i]) / 2
	if d1 > d:
		d = d1
print(d)


(n, l) = map(int, input().split())
light = list(map(int, input().split()))
light.sort()
d = []
if light[0] != 0:
	d.append(light[0])
d.append(l - light[n - 1])
for i in range(0, n - 1):
	d.append(abs(light[i] - light[i + 1]) / 2)
print('{:.10f}'.format(max(d)))


(n, l) = map(int, input().split())
d = 0
a = sorted([int(x) for x in input().split()])
for i in range(len(a) - 1):
	if abs(a[i] - a[i + 1]) >= d:
		d = abs(a[i] - a[i + 1])
print('%.10f' % max(d / 2, a[0], l - a[-1]))


(fonari, dlina) = map(int, input().split())
places = list(map(int, input().split()))
prev = max_req_range = 0
places.sort()
for i in range(len(places)):
	if i == 0:
		req_range = places[i]
	else:
		req_range = (places[i] - prev) / 2
	prev = places[i]
	if req_range > max_req_range:
		max_req_range = req_range
if dlina - places[-1] > max_req_range:
	print(dlina - places[-1])
else:
	print(max_req_range)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
d = a[0]
for i in range(n - 1):
	di = abs(a[i + 1] - a[i]) / 2
	if di > d:
		d = di
if d < l - a[-1]:
	d = l - a[-1]
print(d)


array = []
(n, l) = map(int, input().split())
mas = list(map(int, input().split()))
if n == 1:
	if l - mas[0] > mas[0]:
		print(l - mas[0])
	else:
		print(mas[0])
else:
	for i in range(0, n):
		array.append(mas[i])
	array.sort()
	r = 0
	for i in range(0, n - 1):
		if array[i + 1] - array[i] > r:
			r = array[i + 1] - array[i]
	r /= 2
	if array[0] - r > 0:
		r = array[0]
	if l - array[n - 1] > r:
		r = l - array[n - 1]
	print(r)


import sys
it = iter(sys.stdin.read().splitlines())
(n, l) = [int(x) for x in next(it).split(' ')]
lanternPositions = [int(x) for x in next(it).split(' ')]
lanternPositions.sort()
maxDistance = 0
for i in range(n - 1):
	distance = lanternPositions[i + 1] - lanternPositions[i]
	if distance > maxDistance:
		maxDistance = distance
radius = maxDistance / 2
beginning = lanternPositions[0]
end = l - lanternPositions[-1]
if beginning > radius:
	radius = beginning
if end > radius:
	radius = end
print(radius)


(n, l) = map(int, input().split())
a = list(map(float, input().split()))
a.sort()
b = a[0]
for i in range(n - 1):
	if a[i + 1] - a[i] > 2 * b:
		b = (a[i + 1] - a[i]) / 2
if l - a[n - 1] > b:
	b = l - a[n - 1]
print('{:.10f}'.format(b))


(n, l) = map(int, input().split())
l_coords = sorted(list(map(int, input().split())))
res = max(l_coords[0] - 0, l - l_coords[-1])
for k in range(n - 1):
	if (l_coords[k + 1] - l_coords[k]) / 2 > res:
		res = (l_coords[k + 1] - l_coords[k]) / 2
print(res)


(n, l) = map(int, input().split())
data = sorted(list(map(int, input().split())))
list_result = []
if 0 not in data:
	list_result.append(min(data))
if l not in data:
	list_result.append(l - max(data))
r = [(data[n + 1] - i) / 2 for (n, i) in enumerate(data[:-1])]
if r:
	list_result.append(max(r))
print(max(list_result))


import sys
import math as mt
input = sys.stdin.buffer.readline
t = 1
for __ in range(t):
	(n, m) = map(int, input().split())
	l = list(map(int, input().split()))
	l1 = []
	d = {}
	for i in range(n):
		d[l[i]] = 1
	for i in d:
		l1.append(i)
	l1.sort()
	maxi = 0
	if l1[0] != 0:
		maxi = l1[0]
	if l1[-1] != m:
		maxi = max(maxi, m - l1[-1])
	for i in range(len(l1) - 1):
		maxi = max(maxi, (l1[i + 1] - l1[i]) / 2)
	print(maxi)


initial = list(map(int, input().split(' ')))
sec = list(map(int, input().split(' ')))
third = sorted(sec)
maxV = -1
for i in range(len(sec)):
	if third[i] == 0 and len(third) != 1:
		pass
	else:
		if len(third) == 1:
			maxV = initial[1] - third[i]
			max2 = third[i]
		elif i == 0:
			max2 = third[i]
		elif i == len(sec) - 1 and third[i] != initial[1]:
			max2 = initial[1] - third[i]
		else:
			max2 = (third[i] - third[i - 1]) / 2
		if max2 > maxV:
			maxV = max2
print(maxV)


(n, k) = map(int, input().rstrip().split())
l = list(map(int, input().split()))
l.sort()
d = l[0] - 0
p = 0
for i in range(n):
	if i == n - 1:
		p = k - l[i]
	else:
		p = (l[i + 1] - l[i]) / 2
	if p > d:
		d = p
print(d)


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
r = -1
for i in range(n - 1):
	r = max(a[i + 1] - a[i], r)
print('%.11f' % max(r / 2, l - a[-1], a[0]))


(n, l) = map(int, input().split())
lanterns = list(map(int, input().split()))
lanterns.sort()
maxDiff = 0
if n == 1:
	print(max(l - lanterns[0], lanterns[0]))
else:
	for i in range(n - 1):
		diff = lanterns[i + 1] - lanterns[i]
		if diff > maxDiff:
			maxDiff = diff
	maxDiff /= 2
	if lanterns[0] != 0 and lanterns[n - 1] != l:
		print(max(lanterns[0], maxDiff, l - lanterns[n - 1]))
	elif lanterns[0] == 0 and lanterns[n - 1] == l:
		print(maxDiff)
	elif lanterns[0] == 0:
		print(max(maxDiff, l - lanterns[n - 1]))
	else:
		print(max(maxDiff, lanterns[0]))


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
import bisect
from heapq import *
from math import *
from collections import deque
from collections import Counter as counter
from itertools import combinations as comb
from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
mod = 1000000007

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def graph(vertex):
	return [[] for i in range(0, vertex + 1)]

def zerolist(n):
	return [0] * n

def nextline():
	out('\n')

def testcase(t):
	for p in range(t):
		solve()

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')

def lcm(a, b):
	return a * b // gcd(a, b)

def power(a, b):
	ans = 1
	while b > 0:
		if b % 2 == 1:
			ans *= a
		a *= a
		b //= 2
	return ans

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def bs(a, l, h, x):
	while l < h:
		print(l, h)
		mid = (l + h) // 2
		if a[mid] == x:
			return mid
		if a[mid] < x:
			l = mid + 1
		else:
			h = mid
	return l

def solve():
	(n, lo) = sep()
	a = lis()
	a = sorted(a)
	maxdiff = 0
	for i in range(1, n):
		maxdiff = max(maxdiff, a[i] - a[i - 1])
	(l, m) = (min(a), max(a))
	f = True
	ans = 0
	if l != 0:
		if a[0] > maxdiff / 2:
			f = False
			ans = a[0]
	if m != lo:
		if lo - a[n - 1] > maxdiff / 2:
			f = False
			ans = max(ans, lo - a[n - 1])
	if f:
		print(maxdiff / 2)
	else:
		print(ans)
testcase(1)


f = [int(i) for i in input().split()]
(n, l) = (f[0], f[1])
a = [int(i) for i in input().split()]
a.sort()

def find_max():
	max = -1
	(s, f) = (0, 0)
	for i in range(len(a) - 1):
		if a[i + 1] - a[i] > max:
			s = a[i]
			f = a[i + 1]
			max = f - s
	return (s, f)
(start, finish) = find_max()
start = finish - start
if start / 2 > a[0] and start / 2 > l - a[len(a) - 1]:
	print(start / 2)
elif a[0] > l - a[len(a) - 1]:
	print(float(a[0]))
else:
	print(float(l - a[len(a) - 1]))


arr = [int(x) for x in input().split()]
n = arr[0]
l = arr[1]
lanterns = [int(x) for x in input().split()]
lanterns.sort()
resp = max(lanterns[0], l - lanterns[-1])
for i in range(n - 1):
	resp = max(resp, (lanterns[i + 1] - lanterns[i]) / 2)
print(resp)


(n, l) = map(int, input().split())
lanterns = sorted(list(map(int, input().split())))
max_sep = 0
for i in range(n - 1):
	sep = lanterns[i + 1] - lanterns[i]
	max_sep = max(max_sep, sep)
print(max(max_sep / 2.0, max(lanterns[0], l - lanterns[n - 1])))


l = int(input().split()[1])
lanternas = [int(i) for i in input().split()]
lanternas.sort()
maxDist = lanternas[0]
if l - lanternas[-1] > maxDist:
	maxDist = l - lanternas[-1]
for i in range(len(lanternas) - 1):
	dist = (lanternas[i + 1] - lanternas[i]) / 2
	if dist > maxDist:
		maxDist = dist
print(maxDist)


(n, dl) = [int(q) for q in input().split()]
l = sorted([int(w) for w in input().split()])
answ = 0
for i in range(n - 1):
	answ = max(answ, (l[i + 1] - l[i]) / 2)
if 0 not in l:
	answ = max(answ, l[0])
if dl not in l:
	answ = max(answ, dl - l[-1])
print('%.10f' % answ)


(n, l) = map(int, input().split())
li = [int(x) for x in input().split()]
li = sorted(li)
ll = []
k = 0
a = li[0]
b = l - li[n - 1]
for i in range(n - 1):
	m = (li[k + 1] - li[k]) / 2
	ll.append(m)
	k += 1
ll.append(a)
ll.append(b)
print(float(max(ll)))


def codeForces():
	t = list(map(int, input().rstrip().split()))
	(n, l) = (t[0], t[1])
	p = list(map(int, input().split()))
	p.sort()
	diff = []
	if p[0] != 0:
		diff.append(p[0] - 0)
	if p[-1] != l:
		diff.append(l - p[-1])
	for i in range(len(p) - 1):
		diff.append((p[i + 1] - p[i]) / 2)
	print(max(diff))
codeForces()


(n, l) = [int(x) for x in input().split()]
ai = input().split()
ai = list(map(int, ai))
ai.sort()
newlist = []
for i in range(1, len(ai)):
	newlist.append(ai[i] - ai[i - 1])
d = [x / 2 for x in newlist]
d.append(ai[0])
d.append(l - ai[-1])
print('{:.10f}'.format(max(d)))


nl = [int(i) for i in input().split()]
n = nl[0]
length = nl[1]
coo = [int(i) for i in input().split()]
coo.sort()
max1 = coo[0]
for i in range(0, n - 1):
	max1 = max(max1, (coo[i + 1] - coo[i]) / 2)
max1 = max(max1, length - coo[-1])
print('%.10f' % max1)


(n, l) = list(map(int, input().split()))
pos = list(map(int, input().split()))
pos.sort()
dist = 0
for i in range(n - 1):
	tmp = pos[i + 1] - pos[i]
	if tmp > dist:
		dist = tmp
new = '%.10f' % (dist / 2.0)
start = '%.10f' % pos[0]
end = '%.10f' % (l - pos[-1])
print(max(float(new), float(start), float(end)))


import sys
(n, l) = map(int, sys.stdin.readline().split())
alist = sorted(list(map(int, sys.stdin.readline().split())))
ans = max(alist[0], l - alist[-1])
for i in range(n - 1):
	tmp = (alist[i + 1] - alist[i]) / 2
	ans = max(ans, tmp)
print('{0:.10f}'.format(ans))


import math
[n, length] = [int(x) for x in input().split(' ')]
lanterns = [int(x) for x in input().split(' ')]
lanterns.sort()
err = math.pow(10, -10)
lower = 0
upper = length
d = (lower + upper) / 2

def Can(radius):
	for i in range(n):
		if i == 0:
			if lanterns[i] > radius:
				return False
		if i == n - 1:
			if length - lanterns[i] > radius:
				return False
		elif radius < (lanterns[i + 1] - lanterns[i]) / 2:
			return False
	return True
while upper > lower:
	if Can(d):
		upper = d
	else:
		lower = d
	if upper - lower <= err or (upper - lower) / upper <= err:
		if Can(lower):
			d = lower
		else:
			d = upper
		break
	else:
		d = (lower + upper) / 2
print('{:0.10f}'.format(d))


(n, length) = tuple(input().split(' '))
(n, length) = (int(n), int(length))
values = [int(val) for val in input().split(' ')]
values.sort()
(l, r) = (0, length)
dist = length
while l < r:
	d = l + (r - l) / 2
	if d == l or d == r:
		dist = d
		break
	range_covered = 0
	for value in values:
		low = value - d
		if low > range_covered:
			break
		range_covered = value + d
	if range_covered < length:
		l = d
	else:
		dist = d
		r = d
print(dist)


(n, m) = map(int, input().split())
a = list(map(int, input().rstrip().split()))
for i in range(n):
	for j in range(n - 1):
		if a[j] < a[i]:
			temp = a[j]
			a[j] = a[i]
			a[i] = temp
dist = 0
for i in range(n - 1):
	dist = max(dist, a[i] - a[i + 1])
dist = dist / 2
dist = max(dist, a[-1], m - a[0])
print('{0:.9f}'.format(dist))


tmp = input().split()
n = int(tmp[0])
l = int(tmp[1])
tmp = input().split()
a = []
for i in tmp:
	a.append(int(i))
a.sort()
d = 2 * max(a[0], l - a[-1])
for i in range(0, len(a) - 1):
	d = max(d, a[i + 1] - a[i])
print(d // 2, end='')
if d % 2 == 0:
	print('.0000000000')
else:
	print('.5000000000')


nl = input().split(' ')
(n, l) = [int(x) for x in nl]
s_lanterns = input().split(' ')
lanterns = [int(x) for x in s_lanterns]
lanterns.sort()
changed = False
max_dif = max(lanterns[0], l - lanterns[n - 1])
for i in range(n - 1):
	if changed == False and max_dif * 2 < lanterns[i + 1] - lanterns[i]:
		max_dif = lanterns[i + 1] - lanterns[i]
		changed = True
	if changed == True and max_dif < lanterns[i + 1] - lanterns[i]:
		max_dif = lanterns[i + 1] - lanterns[i]
if changed == False:
	print(max_dif)
else:
	print(max_dif / 2)


field = {'field': int(input().split(' ')[1]), 'lights': None}
field['lights'] = map(int, input().split(' '))
field['lights'] = sorted(field['lights'])
minVal = field['lights'][0]
maxVal = field['field'] - field['lights'][-1]
maxDist = 0
for i in range(1, len(field['lights'])):
	if maxDist < field['lights'][i] - field['lights'][i - 1]:
		maxDist = field['lights'][i] - field['lights'][i - 1]
print(max(minVal, maxVal, maxDist / 2.0))


inp1 = input()
inp2 = input()
inp1 = inp1.split(' ')
n = int(inp1[0])
l = int(inp1[1])
inp2 = inp2.split(' ')
for x in range(len(inp2)):
	inp2[x] = int(inp2[x])
inp2.append(-1 * min(inp2))
inp2 = sorted(inp2)
inp2.append(2 * l - max(inp2))
max1 = 0
for x in range(n + 1):
	max1 = max(max1, inp2[x + 1] - inp2[x])
print(max1 / 2)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
c = 0
e = 0
if c in a:
	c = 1
if l in a:
	e = 1
a.sort()
b = []
if c == 0:
	b.append(abs(0 - a[0]) / 1)
for i in range(len(a) - 1):
	b.append(abs(a[i] - a[i + 1]) / 2)
if e == 0:
	b.append(abs(l - a[-1]) / 1)
print(max(b))


(n, l) = map(int, input().split())
li = [int(x) for x in input().split()]
li.sort()
a = []
for i in range(n - 1):
	lig = (li[i + 1] - li[i]) / 2
	a.append(lig)
a.append(li[0])
a.append(l - li[n - 1])
print(max(a))


(a, b) = map(int, input().split())
c = sorted(list(map(int, input().split())))
d = max(c[0], b - c[-1])
for i in range(1, a):
	if d < (c[i] - c[i - 1]) / 2:
		d = (c[i] - c[i - 1]) / 2
print(d)


import sys
(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
diff = a[0]
diff = max(diff, l - a[n - 1])
for i in range(1, n):
	k = (a[i] - a[i - 1]) / 2
	diff = max(diff, k)
print(diff)


(n, l) = map(int, input().split())
li = sorted(list(map(int, input().split())))
cha = [2 * li[0], 2 * (l - li[-1])]
for i in range(n - 1):
	a = li[i + 1] - li[i]
	cha.append(a)
print(max(cha) / 2)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
v = 0
for i in range(1, n):
	if a[i] - a[i - 1] > v:
		v = a[i] - a[i - 1]
v = v / 2
if a[0] > v:
	v = a[0]
if l - a[-1] > v:
	v = l - a[-1]
print(v)


foo = [int(i) for i in input().split()]
n = foo[0]
l = foo[1]
foo = [int(i) for i in input().split()]
foo.sort()
ans = max(foo[0] - 0, l - foo[n - 1])
for i in range(n - 1):
	if (foo[i + 1] - foo[i]) / 2 > ans:
		ans = (foo[i + 1] - foo[i]) / 2
print(ans)


(n, l) = [int(i) for i in input().split()]
list = [int(i) for i in input().split()]
list.sort()
max = float(list[0])
for i in range(n - 1):
	k = float(list[i + 1] - list[i])
	k /= 2
	if k > max:
		max = k
if l - list[n - 1] > max:
	max = l - list[n - 1]
print(max)


(n, l) = map(int, input().split())
a = [int(i) for i in input().split()]
a.sort()
b = 2 * max(a[0], l - a[n - 1])
for i in range(n - 1):
	b = max(b, a[i + 1] - a[i])
print('%.10f' % (b / 2))


def I():
	return list(map(int, input().split()))
(n, l) = I()
a = I()
a.sort()
d = 0
for i in range(n - 1):
	d = max(a[i + 1] - a[i], d)
print(max(d / 2, a[0], l - a[-1]))


(n, l) = map(int, input().split())
vetor = list(map(int, input().split(' ')))
vetor.sort()
maior = max(vetor[0], l - vetor[-1]) * 2
for i in range(1, n):
	maior = max(maior, vetor[i] - vetor[i - 1])
print(maior / 2)


(a, b) = map(int, input().split())
l = [int(x) for x in input().split()]
l.sort()
min1 = min(l)
max1 = max(l)
l.append(b)
l.insert(0, 0)
num1 = 0
l1 = []
while num1 < len(l) - 1:
	n1 = l[num1]
	n2 = l[num1 + 1]
	pri = n2 - n1
	l1.append(pri)
	num1 += 1
l2 = []
for i in l1:
	i = i / 2
	l2.append(i)
l2.append(min1)
l2.append(b - max1)
mx = max(l2)
mx = '%.10f' % mx
print(mx)


from sys import stdin, stdout
from collections import Counter

def ai():
	return list(map(int, stdin.readline().split()))

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

def ip():
	return int(stdin.readline().strip())

def op(ans):
	return stdout.write(str(ans) + '\n')
from math import ceil
(n, l) = ei()
li = ai()
li.sort()
x = []
for i in range(n - 1):
	x.append(abs(li[i] - li[i + 1]) / 2.0)
if li[-1] != l:
	x.append(abs(li[-1] - l))
if li[0] != 0:
	x.append(li[0])
print('%.9f' % max(x))


def solve(n, l, a):
	z = 0 in a
	k = l in a
	a.append(0)
	a.append(l)
	a.sort()
	maxi = 0
	for i in range(1, len(a)):
		if i == 1 and (not z) or (i == len(a) - 1 and (not k)):
			maxi = max(maxi, a[i] - a[i - 1])
		else:
			maxi = max(maxi, (a[i] - a[i - 1]) / 2)
	return maxi

def main():
	(n, l) = list(map(int, input().split()))
	a = list(map(int, input().split()))
	print(solve(n, l, a))
main()


(n, l) = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
res = 0
t = 0
for i in range(1, n):
	if a[i] - a[i - 1] > t:
		t = a[i] - a[i - 1]
res = t / 2
if a[0] > res:
	res = a[0]
if l - a[-1] > res:
	res = l - a[-1]
print(res)


(n, m) = map(int, input().split())
a = [int(x) for x in input().split()]
b = []
a.sort()
if n == 1:
	w = [a[0], abs(m - a[0])]
	w.sort()
	print(w[-1])
else:
	for i in range(1, n):
		past = a[i] - a[i - 1]
		b.append(past)
	b.sort()
	c = float(a[0] - 0)
	d = float(m - a[-1])
	e = b[-1] / 2
	t = [c, d, e]
	t.sort()
	print(t[-1])


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
list1 = []
if n == 1:
	if 0 in a or l in a:
		print(l)
	else:
		print(max(l - a[0], a[0]))
else:
	for i in range(n - 1):
		j = a[i + 1] - a[i]
		list1.append(j)
	list1.sort()
	b = max(a[0], l - a[-1])
	if b > max(list1) / 2:
		print(b)
	else:
		print(max(list1) / 2)


s = input()
s = s.split()
n = int(s[0])
l = int(s[1])
s = input().split()
for i in range(0, n):
	s[i] = int(s[i])
list.sort(s)
maxdiff = 0
for i in range(1, n):
	temp = (int(s[i]) - int(s[i - 1])) / 2
	if temp > maxdiff:
		maxdiff = temp
answer = max(maxdiff, int(s[0]) - 0, l - int(s[n - 1]))
answer = format(answer, '.10f')
print(str(answer))


a1 = input().split()
a = int(a1[0])
b = int(a1[1])
q = input().split()
for i in range(a):
	q[i] = int(q[i])
q.sort()
x = 0
for ii in range(1, a):
	if x < abs(q[ii] - q[ii - 1]):
		x = abs(q[ii] - q[ii - 1])
print(max([q[0], x / 2, b - q[a - 1]]))


(n, l) = input().split()
(n, l) = (int(n), int(l))
lis = input().split()
for i in range(len(lis)):
	lis[i] = int(lis[i])
lis1 = sorted(list(set(lis)))
if len(lis1) >= 2:
	m = lis1[1] - lis1[0]
	for k in range(2, len(lis1)):
		if lis1[k] - lis1[k - 1] > m:
			m = lis1[k] - lis1[k - 1]
	print(max(m / 2, lis1[0], l - lis1[len(lis1) - 1]))
else:
	print(max(lis1[0], l - lis1[0]))


import sys
(n, l) = map(int, input().split(' '))
arr = list(map(int, input().split(' ')))
arr.sort()
max1 = 0
max1 = max(max1, arr[0])
start = arr[0]
for i in range(1, n):
	max1 = max(max1, (arr[i] - start) / 2.0)
	start = arr[i]
max1 = max(max1, l - start)
print(max1)


(a, b) = input().split()
a = int(a)
b = int(b)
list = [int(x) for x in input().split()]
list.sort()
diff = []
for i in range(len(list)):
	if i < len(list) - 1:
		d = list[i + 1] - list[i]
		diff.append(d)
d = b - list[len(list) - 1]
diff.append(d)
d = list[0] - 0
diff.insert(0, d)
m = max(diff)
out = m / 2
f = out
if diff[0] > out:
	f = diff[0]
if diff[len(diff) - 1] > out:
	f = diff[len(diff) - 1]
if diff[0] == m or diff[len(diff) - 1] == m:
	f = m
print('{:.9f}'.format(f))


(n, l) = list(map(int, input().split()))
points = list(map(int, input().split()))
points.sort()
d = 0
for i in range(n - 1):
	cord1 = points[i]
	a = i + 1
	cord2 = points[a]
	if cord2 - cord1 > 2 * d:
		d = (cord2 - cord1) / 2
	else:
		pass
d1 = points[0] - 0
d2 = l - points[n - 1]
ans = max(d1, d2, d)
print('%.9f' % ans)


(a, b) = map(int, input().split())
ar = list(map(int, input('').split(' ')))
ar.sort()
l = []
for i in range(a - 1):
	l.append(ar[i + 1] - ar[i])
if len(l) > 0:
	d = float(max(l) / 2)
else:
	d = ar[0]
if ar[0] - 0 <= d and b - ar[-1] <= d:
	print(float(d))
elif ar[0] - 0 > d and ar[0] - 0 > b - ar[-1]:
	print(float(ar[0] - 0))
else:
	print(float(b - ar[-1]))


(ld, rn) = map(int, input().split())
lst = sorted(list(map(int, input().split())))
mx = 0
for i in range(1, ld):
	if lst[i] - lst[i - 1] > mx:
		mx = lst[i] - lst[i - 1]
sm = max(lst[0] - 0, rn - lst[ld - 1])
mx = float(mx / 2)
if mx > sm:
	print('%.10f' % mx)
else:
	print('%.10f' % float(sm))


mishu = input().split()
emon1 = input().split()
emon = []
for i in emon1:
	c = int(i)
	emon.append(c)
emon.sort()
x = int(mishu[1])
desire = []
min = 0
for i in emon:
	a = int(i) - min
	min = int(i)
	desire.append(a)
consider = int(x) - int(emon[-1])
consider1 = int(emon[0])
m = max(desire)
m = m / 2
if m > consider:
	if m > consider1:
		print(m)
	else:
		print(consider1)
elif consider > consider1:
	print(consider)
else:
	print(consider1)


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
md = max(2 * a[0], 2 * (l - a[n - 1]))
u = 0
while u < len(a):
	if u != 0:
		if a[u] - a[u - 1] > md:
			md = a[u] - a[u - 1]
	u += 1
print(md / 2)


(n, l) = map(int, input().strip().split())
a = list(map(int, input().strip().split()))
a.sort()
maxPrev = 2 * max(a[0], l - a[n - 1])
for i in range(0, n - 1):
	c = a[i + 1] - a[i]
	if c > maxPrev:
		maxPrev = c
print('{:.10f}'.format(maxPrev / 2))


(n, l) = map(int, input().split())
numbers = [int(i) for i in input().split()]
numbers.sort()
s = [int(numbers[0]), int(l - int(numbers[n - 1]))]
for i in range(1, n):
	s.append((int(numbers[i]) - int(numbers[i - 1])) / 2)
print(max(s))


x = list(map(int, input().split()))
(n, l, m) = (x[0], x[1], 0)
x = list(map(int, input().split()))
x.sort()
for i in range(n - 1):
	m = max(m, x[i + 1] - x[i])
m2 = max(x[0] - 0, l - x[len(x) - 1])
if m2 > m / 2:
	print(m2)
else:
	print(m / 2)


(n, l) = map(int, input().split())
t = list(map(int, input().split()))
t.sort()
if n == 1:
	print(max(t[0], abs(l - t[0])))
else:
	a = t[0]
	b = l - t[-1]
	u = 0
	for j in range(1, n):
		if t[j] - t[j - 1] > u:
			u = t[j] - t[j - 1]
	print(max(u / 2, a, b))


(n, l) = [int(x) for x in input().split()]
ls = [int(x) for x in input().split()]
d = 0
ls.sort()
for i in range(n - 1):
	a = ls[i + 1] - ls[i]
	d = max(a, d)
d = max(d / 2, ls[0], l - ls[n - 1])
print(d)


(n, l) = input().split()
n = int(n)
l = int(l)
x = input().split()
x = [int(y) for y in x]
x.sort()
z = [x[a] - x[a - 1] for a in range(1, len(x))]
b = [d / 2 for d in z]
b.append(x[0])
b.append(l - x[-1])
print(max(b))


(n, l) = map(int, input().split())
s = list(map(int, input().split()))
z = []
s.sort()
for x in range(len(s) - 1):
	z += [s[x + 1] - s[x]]
if n == 1:
	print(max(l - s[0], s[0] - 0))
	exit()
if s.count(0) == 0:
	if s.count(l) == 0:
		print('%.10f' % max(s[0], l - s[n - 1], max(z) / 2))
	else:
		print('%.10f' % max(s[0], max(z) / 2))
elif s.count(l) == 0 and s.count(0) != 0:
	print('%.10f' % max(l - s[n - 1], max(z) / 2))
else:
	print('%.10f' % (max(z) / 2))


(x, y) = input().split()
s = input().split()
x = int(x)
y = int(y)
for n in range(x):
	s[n] = float(s[n])
value = [min(s), y - max(s)]
s.sort()
for l in range(len(s) - 1):
	v = (s[l + 1] - s[l]) / 2
	value.append(v)
print(max(value))


s = input()
i = 0
while s[i] != ' ':
	i += 1
n = int(s[0:i])
l = int(s[i + 1:len(s)])
t = input()
i = 0
k = -1
j = 1
A = []
for j in range(1, n):
	while t[i] != ' ':
		i += 1
	A.append(int(t[k + 1:i]))
	k = i
	i = i + 1
A.append(int(t[i:len(t)]))
A.sort()
m = 0
for j in range(0, len(A) - 1):
	if A[j + 1] - A[j] > m:
		m = A[j + 1] - A[j]
if m < 2 * A[0]:
	m = 2 * A[0]
if 2 * (l - A[len(A) - 1]) > m:
	m = 2 * (l - A[len(A) - 1])
print(m / 2)


(n, L) = map(int, input().split())
a = sorted(list(map(int, input().split())))
kc = max(a[0], L - a[n - 1])
for i in range(n - 1):
	kc = max(kc, (a[i + 1] - a[i]) / 2.0)
print(kc)


S = input().split()
l = list(map(int, input().split()))
n = int(S[0])
a = int(S[1])
a1 = 0
a2 = 0
S1 = sorted(l)
if S1[0] != 0:
	a1 = int(S1[0])
if S1[n - 1] != a:
	a2 = int(a - S1[n - 1])
ma = 0
S1 = [0] + S1 + [a]
for i in range(n + 1):
	if ma <= S1[i + 1] - S1[i]:
		ma = S1[i + 1] - S1[i]
print('%.9f' % max(a1, a2, ma / 2))


v = list(map(int, input().split()))
lanterns = list(map(int, input().split()))
lanterns.sort()
maxl = max(lanterns[0] * 2, (v[1] - lanterns[len(lanterns) - 1]) * 2)
for i in range(1, len(lanterns)):
	maxl = max(lanterns[i] - lanterns[i - 1], maxl)
if v[1] + 1 > 1:
	print(float(maxl / 2))
else:
	print(maxl)


(n, l) = map(int, input().split())
s = sorted(tuple(map(int, input().split())))
max = 0
i = 0
while i < len(s) - 1:
	if s[i + 1] - s[i] > max:
		max = s[i + 1] - s[i]
	i = i + 1
if max / 2 < s[0]:
	max = 2 * s[0]
if max / 2 < l - s[-1]:
	max = 2 * (l - s[-1])
print('{0:.15f}'.format(max / 2))


(n, end) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
a.append(end)
if a[0] - 0 > a[-1] - a[-2]:
	j = a[0] - 0
else:
	j = a[-1] - a[-2]
arr2 = [0] * (n + 1)
for i in range(n):
	if a[i + 1] - j <= a[i] + j:
		pass
	else:
		j = (a[i + 1] - a[i]) / 2
print(j)


(n, l) = list(map(int, input().split()))
lamps = list(map(int, input().split()))
lamps.sort()
lamps.insert(0, lamps[0] * -1)
lamps.append(l + (l - lamps[-1]))
diff = 0
for i in range(len(lamps) - 1):
	if lamps[i + 1] - lamps[i] > diff:
		diff = lamps[i + 1] - lamps[i]
print(diff / 2)


i = lambda : map(int, input().split())
(n, l) = i()
a = sorted(i())
print(max((r - l for (l, r) in zip([-a[0]] + a, a + [2 * l - a[-1]]))) / 2)


(n, m) = [int(x) for x in input().split()]
k = [int(l) for l in input().split()]
k.sort()
if 0 not in k and m not in k:
	k.append(0)
	k.append(m)
	k.sort()
	s = k[1] - k[0]
	s2 = k[-1] - k[-2]
	if s2 > s:
		s = s2
	for i in range(len(k) - 1):
		d = abs(k[i] - k[i + 1]) / 2
		if d > s:
			s = d
	print(s)
elif m not in k:
	k.append(m)
	k.sort()
	s = k[-1] - k[-2]
	for i in range(len(k) - 1):
		d = abs(k[i] - k[i + 1]) / 2
		if d > s:
			s = d
	print(s)
elif 0 not in k:
	k.append(0)
	k.sort()
	s = k[1] - k[0]
	for i in range(len(k) - 1):
		d = abs(k[i] - k[i + 1]) / 2
		if d > s:
			s = d
	print(s)
else:
	s = 0
	for i in range(len(k) - 1):
		d = abs(k[i] - k[i + 1]) / 2
		if d > s:
			s = d
	print(s)


(n, l) = map(int, input().split())
ns = sorted(map(int, input().split()))
p = ns[0]
maxi = 0
for n in ns[1:]:
	maxi = max(maxi, (n - p) / 2)
	p = n
maxi = max(maxi, ns[0] - 0, l - ns[-1])
print(maxi)


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
d = min(a) if min(a) > l - max(a) else l - max(a)
for i in range(n - 1):
	if (a[i + 1] - a[i]) / 2 > d:
		d = (a[i + 1] - a[i]) / 2
print(d)


def inlt():
	return list(map(int, input().split()))
d = 0
inp = inlt()
n = inp[0] - 1
l = inp[1]
inp = inlt()
inp.sort()
if inp[0] != 0:
	d = inp[0]
if inp[n] != l:
	if l - inp[n] > d:
		d = l - inp[n]
for i in range(1, n + 1):
	if (inp[i] - inp[i - 1]) / 2 > d:
		d = (inp[i] - inp[i - 1]) / 2
print(d)


nl = input().split()
n = int(nl[0])
l = int(nl[1])
arr1 = sorted([int(x) for x in input().split()])
arr2 = []
for x in range(n - 1):
	arr2.append((arr1[x + 1] - arr1[x]) / 2)
arr2.append(arr1[0])
arr2.append(l - arr1[-1])
print(round(float(max(arr2)), 9))


import sys
import bisect
from collections import deque
RI = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

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

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
(n, l) = RI()
a = RI()
a.sort()
maxx = a[0] - 0
maxx = max(maxx, l - a[-1])
for i in range(0, n - 1):
	maxx = max(maxx, (a[i + 1] - a[i]) / 2)
print(maxx)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
x = 0
for i in range(n):
	if n == 1:
		x = max(a[0], l - a[0])
	elif i == 0 and a[i] != 0:
		x = a[i]
	elif i != n - 1:
		x = max((a[i + 1] - a[i]) / 2, x)
	else:
		x = max(l - a[i], x)
print('{0:0.10f}'.format(x))


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
d1 = min(l)
d2 = m - max(l)
l.sort()
d3 = 1
for i in range(n - 1):
	d = l[i + 1] - l[i]
	d3 = max(d, d3)
d3 = d3 / 2
print(max(d1, d2, d3))


(n, l) = map(int, input().split())
m = list(map(int, input().split()))
m.sort(reverse=True)
mx = -float('inf')
for i in range(n - 1):
	mx = max(m[i] - m[i + 1], mx)
mx /= 2
mx = max(mx, m[-1])
mx = max(mx, l - m[0])
print('%.10f' % mx)


(n, l) = map(int, input().split())
s = [int(x) for x in input().split()]
s.sort()
t = [0]
for i in range(len(s) - 1):
	t.append(s[i + 1] - s[i])
print('%.10f' % max(max(t) / 2, s[0], l - s[-1]))


(a, b) = map(int, input().split())
y = list(map(int, input().split()))
y.sort()
l = []
if 0 not in y and 15 in y:
	l.append(y[0])
elif 0 in y and 15 not in y:
	l.append(b - y[-1])
elif 0 not in y and 15 not in y:
	l.append(y[0])
	l.append(b - y[-1])
for i in range(len(y) - 1):
	l.append((y[i + 1] - y[i]) / 2)
print(max(l))


(n, l) = map(int, input().split())
a = sorted([int(x) for x in input().split()])
d = max(a[0], l - a[n - 1])
for i in range(1, n):
	d_cur = a[i] - a[i - 1]
	if d_cur > 2 * d:
		d = d_cur / 2
	else:
		continue
print(format(d, '.9f'))


(n, l) = input().split()
n = int(n)
l = int(l)
x = input().split()
a = list(map(int, x))
a.sort()
sep = 0
for i in range(n - 1):
	temp = a[i + 1] - a[i]
	if temp > sep:
		sep = temp
sep = sep / 2
d = max(a[0], sep, l - a[n - 1])
print(d)


(n, m) = input().split()
n = eval(n)
m = eval(m)
a = input().split()
for i in range(len(a)):
	a[i] = eval(a[i])
a.sort()
maxs = 0
for i in range(1, len(a)):
	maxs = max(maxs, a[i] - a[i - 1])
maxs = max(maxs / 2.0, a[0] - 0, m - a[-1])
print('{:.10f}'.format(maxs))


(n, l) = [int(i) for i in input().split()]
s = [int(i) for i in input().split()]
s.sort()
m = 0
for i in range(len(s) - 1):
	p = s[i + 1] - s[i]
	if p > m:
		m = p
x = [m / 2, max(s[0], l - s[-1])]
print(max(x))


s = input()
s = s.split()
n = int(s[0])
l = int(s[1])
d = []
s = input()
s = s.split()
for i in range(0, n):
	d.append(int(s[i]))
d.sort()
m = 0
if m < d[0]:
	m = d[0]
if m < l - d[-1]:
	m = l - d[-1]
for i in range(0, n - 1):
	if m < (d[i + 1] - d[i]) / 2:
		m = (d[i + 1] - d[i]) / 2
print(m)


(m, n) = input().split()
A = input()
B = []
m = int(m)
n = int(n)
for i in A.split():
	B.append(int(i))
B.sort()
max = B[0]
if len(B) > 1:
	for j in range(0, m - 1):
		if (B[j + 1] - B[j]) / 2 > max:
			max = (B[j + 1] - B[j]) / 2
else:
	max = B[0]
if n - B[-1] > max:
	print(float(n - B[-1]))
else:
	print(float(max))


length = int(input().split()[1])
lamps = [int(lamp) for lamp in input().split()]
lamps.sort()
original_max_distance = max_distance = max(lamps[0], length - lamps[-1])
for i in range(1, len(lamps)):
	max_distance = max(max_distance, lamps[i] - lamps[i - 1])
print(max(original_max_distance, max_distance / 2))


(n, l) = map(int, input().split())
lst = list(map(int, input().split()))
lst.sort()
d = lst[0]
for i in range(n - 1):
	if (lst[i + 1] - lst[i]) / 2 > d:
		d = (lst[i + 1] - lst[i]) / 2
	else:
		pass
if l - lst[n - 1] > d:
	d = l - lst[n - 1]
else:
	pass
print(d)


(n, l) = map(int, input().split())
all = sorted(list(map(int, input().split())))
left = all[0] - 0
right = l - all[-1]
edge = left if left >= right else right
if len(all) == 1:
	print(edge)
else:
	temp = []
	for i in range(len(all) - 1):
		temp.append(all[i + 1] - all[i])
	ans = max(temp) / 2
	ans = ans if ans >= edge else edge
	print(ans)


(n, l) = map(int, input().split())
x = list(sorted(map(int, input().split())))
rahat = []
for i in range(len(x) - 1):
	rahat.append(abs(x[i] - x[i + 1]) / 2)
if 0 not in x:
	rahat.append(x[0])
if l not in x:
	rahat.append(l - max(x))
print(float(max(rahat)))


(n, l) = [int(x) for x in input().split()]
arr = list(map(int, input().split()))
arr.sort()
min = 0
for i in range(0, n):
	if n == 1:
		if arr[0] == 0 or arr[0] == l:
			min = l
		else:
			min = max(arr[0] - 0, l - arr[0])
		break
	if arr[0] != 0 and i == 0:
		min = arr[0]
		continue
	elif (arr[i] - arr[i - 1]) / 2 > min:
		min = (arr[i] - arr[i - 1]) / 2
	if arr[n - 1] != l and i == n - 1:
		if l - arr[n - 1] > min:
			min = l - arr[n - 1]
print(min)


(n, l) = input().split()
n = int(n)
l = int(l)
x = input()
a = x.split()
for i in range(0, len(a)):
	a[i] = int(a[i])
a = sorted(a)
m = []
for k in range(0, len(a)):
	if len(a) == 1 and a[0] < l - a[0]:
		m.append(l - a[0])
	elif len(a) == 1 and a[0] > l - a[0]:
		m.append(a[0])
	elif k == 0:
		m.append(a[k])
	elif k == len(a) - 1:
		m.append(l - a[k])
		m.append((a[k] - a[k - 1]) / 2)
	else:
		m.append((a[k] - a[k - 1]) / 2)
print(max(m))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
cur = 0
maxm = 0
for i in range(n):
	maxm = max(maxm, a[i] - cur)
	cur = a[i]
maxm /= 2
maxm = max(maxm, a[0])
maxm = max(maxm, l - a[n - 1])
print('%.9f' % maxm)


import os
import sys
from io import BytesIO, IOBase
from collections import Counter
from collections import deque
import heapq
import math
import statistics

def sin():
	return input()

def ain():
	return list(map(int, sin().split()))

def sain():
	return input().split()

def iin():
	return int(sin())
MAX = float('inf')
MIN = float('-inf')

def readTree(n):
	adj = [set() for _ in range(n)]
	for _ in range(n - 1):
		(u, v) = ain()
		adj[u - 1].add(v - 1)
		adj[v - 1].add(u - 1)
	return adj

def main():
	(n, x) = ain()
	l = ain()
	l.sort()
	maxi = l[0] - 0
	for i in range(0, n - 1):
		maxi = max(maxi, (l[i + 1] - l[i]) / 2)
	maxi = max(maxi, x - l[-1])
	print('%.9f' % maxi)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		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')
main()


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
m = max(min(a), l - max(a))
for i in range(len(a) - 1):
	m = max(m, (a[i + 1] - a[i]) / 2)
print(m)


(n, l) = map(int, input().split())
ar = list(map(int, input().split()))
ar.sort()
ma = ar[0]
for i in range(1, n):
	a = (ar[i] - ar[i - 1]) / 2
	if a > ma:
		ma = a
print(max(ma, l - ar[n - 1]))


(n, m) = map(int, input('').split(' '))
datalist = list(map(int, input('').split(' ')))[:n]
datalist.sort(reverse=True)
maxdistance = 0
main = []
if 0 not in datalist:
	maxdistance = datalist[len(datalist) - 1]
	main.append(maxdistance)
if m not in datalist:
	maxdistance = 0
	maxdistance = m - datalist[0]
	main.append(maxdistance)
maxdistance = 0
for i in range(len(datalist) - 1):
	if datalist[i] - datalist[i + 1] > maxdistance:
		maxdistance = datalist[i] - datalist[i + 1]
main.append(maxdistance / 2)
print(max(main))


inp = input().split()
length = int(inp[1])
vals = list(map(int, input().split()))
list.sort(vals)
maxi = 0
for i in range(len(vals) - 1):
	if vals[i + 1] - vals[i] > maxi:
		maxi = vals[i + 1] - vals[i]
print(max(vals[0], maxi / 2, length - vals[-1]))


street = int(input().split(' ')[1])
lamp_positions = [int(i) for i in input().split(' ')]
lamp_positions.sort()
dists = [max(lamp_positions[0], street - lamp_positions[len(lamp_positions) - 1])]
for i in range(1, len(lamp_positions)):
	cur = lamp_positions[i] - lamp_positions[i - 1]
	dists.append(cur / 2)
print(max(dists))


(n, l) = map(int, input().split())
li = sorted(list(map(int, input().split())))
a = 0
for i in range(n - 1):
	a = max(a, li[i + 1] - li[i])
if 0 not in li:
	a = max(a, li[0] * 2)
if l not in li:
	a = max(a, (l - li[-1]) * 2)
print('{0:.10f}'.format(a / 2))


(n, l) = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.sort()
diff = []
for i in range(0, n - 1):
	diff.append(arr[i + 1] - arr[i])
diff.append((arr[0] - 0) * 2)
diff.append((l - arr[-1]) * 2)
print(max(diff) / 2)


(n, l) = (int(i) for i in input().split())
a = [int(i) for i in input().split()]
a = sorted(a)
m = max(a[0], l - a[-1])
for i in range(1, n):
	b = a[i] - a[i - 1]
	if b < 0:
		b = -b
	if b / 2 > m:
		m = b / 2
print(m)


(n, l) = map(int, input().split())
points = sorted(list(map(int, input().split())))
answer = 0
for i in range(len(points)):
	if len(points) == 1:
		answer = max(points[0], l - points[0])
	else:
		if i != len(points) - 1:
			mini = (points[i + 1] - points[i]) / 2
		if mini > answer:
			answer = mini
print(max(answer, points[0], l - points[n - 1]))


count = input()
position = input()
count = count.split()
position = position.split()
count = list(map(int, count))
position = list(map(int, position))
position.sort()
difference = 0
for i in range(count[0] - 1):
	if position[i + 1] - position[i] > difference:
		difference = position[i + 1] - position[i]
	else:
		pass
difference = difference / 2
if (position[0] == 0 or difference >= position[0]) and (position[-1] == count[1] or difference >= count[1] - position[-1]):
	print(difference)
else:
	difference = position[0]
	if count[1] - position[-1] > difference:
		difference = count[1] - position[-1]
	print(difference)


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
m = 0
for i in range(2, len(a) + 1):
	if abs(a[i - 2] - a[i - 1]) > m:
		m = abs(a[i - 2] - a[i - 1])
x = a[0]
y = m / 2
z = l - a[len(a) - 1]
r = max(x, y, z)
print('%.10f' % r)


(n, l) = map(int, input().split())
a1 = list(map(int, input().split()))
a1.sort()
x = min(a1)
y = max(a1)
maxi = 0
for i in range(1, len(a1)):
	if (a1[i] - a1[i - 1]) / 2 > maxi:
		maxi = (a1[i] - a1[i - 1]) / 2
z = max(x - 0, l - y, maxi)
print(z)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
m = max(a[0], l - a[-1])
r = m
for x in range(1, n):
	if abs(a[x] - a[x - 1]) > m and abs(a[x] - a[x - 1]) > 2 * r:
		m = abs(a[x] - a[x - 1])
if m != r:
	print(m / 2)
else:
	print(m)


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
min_dist = 0
for i in range(len(a) - 1):
	if abs(a[i] - a[i + 1]) > min_dist:
		min_dist = abs(a[i] - a[i + 1])
r = min_dist / 2
r1 = 0
rl = 0
if a[0] != 0:
	r1 = a[0]
if a[-1] != l:
	rl = l - a[-1]
a1 = [r, r1, rl]
print('%.10f' % max(a1))


def radius(aList, a, b):
	return (aList[b] - aList[a]) / 2

def minLightRadius(aList, L):
	d = aList[0]
	for i in range(len(aList) - 1):
		d = max(d, radius(aList, i, i + 1))
	return max(d, L - aList[-1])

def main():
	n_and_L = input()
	n_and_L = n_and_L.split()
	n = int(n_and_L[0])
	L = int(n_and_L[1])
	lanterns = input()
	lanterns = lanterns.split()
	assert len(lanterns) == n, 'Invalid number of lanterns'
	for i in range(len(lanterns)):
		lanterns[i] = int(lanterns[i])
	lanterns.sort()
	print(minLightRadius(lanterns, L))
main()


(n, l) = map(int, input().split())
ip = list(map(int, input().split()))
ip = sorted(ip)
op = []
for i in range(n - 1):
	op.append(ip[i + 1] - ip[i])
try:
	if 0 in ip:
		if l in ip:
			print(max(op) / 2)
		else:
			print(max(max(op) / 2, l - ip[n - 1]))
	elif l in op:
		print(max(max(op) / 2, ip[0]))
	else:
		print(max(max(op) / 2, l - ip[n - 1], ip[0]))
except:
	print(max(ip[0], l - ip[0]))


(n, l) = map(int, input().split())
list = list(map(int, input().split()))
list.sort()
diff = 0
for j in range(1, n):
	if diff < list[j] - list[j - 1]:
		diff = list[j] - list[j - 1]
ans = max(diff / 2.0, list[0], l - list[n - 1])
print('{0:.10f}'.format(ans))


(a, b) = map(int, input().split())
k = sorted(list(map(int, input().split())))
if a != 1:
	print(max(k[0], b - k[a - 1], max(((k[i + 1] - k[i]) / 2 for i in range(a - 1)))))
else:
	print(max(b - k[0], k[0]))


(p, q) = map(int, input().split())
lst = list(map(int, input().split()))
lst.sort()
min1 = 0
for i in range(p):
	t = (lst[i] - lst[i - 1]) / 2
	if t > min1:
		min1 = t
if lst[0] - 0 > min1:
	min1 = lst[0] - 0
if q - lst[-1] > min1:
	min1 = q - lst[-1]
print(min1)


x = [int(i) for i in input().split()]
(n, l) = (x[0], x[1])
lanternas = [int(i) for i in input().split()]
i = 0
j = 1
dist = 0
lanternas.sort()
lant = []
for i in lanternas:
	if not i in lant:
		lant.append(i)
dist = lant[0]
if l - lant[-1] > dist:
	dist = l - lant[-1]
for i in range(len(lant) - 1):
	if (lant[i + 1] - lant[i]) / 2 > dist:
		dist = (lant[i + 1] - lant[i]) / 2
print(dist)


(n, l) = map(int, input().split())
l1 = list(map(int, input().split()))
l1.sort()
a = l1[0]
b = l - l1[n - 1]
if a > b:
	m = a
else:
	m = b
for i in range(n - 1):
	if (l1[i + 1] - l1[i]) / 2 > m:
		m = (l1[i + 1] - l1[i]) / 2
print(m)


(n, l) = [int(x) for x in input().split()]
lant = [int(x) for x in input().split()]
for i in range(1, n):
	for j in range(i - 1, -1, -1):
		if lant[j] > lant[j + 1]:
			a = lant[j]
			lant[j] = lant[j + 1]
			lant[j + 1] = a
		else:
			break
res = max(lant[0], l - lant[n - 1])
for i in range(n - 1):
	res = max(res, (lant[i + 1] - lant[i]) / 2)
print('%.10f' % res)


(n, k) = map(int, input().split())
x = sorted(list(map(int, input().split())))
mx = x[0]
for i in range(len(x) - 1):
	mx = max(mx, x[i + 1] - x[i])
print(max(mx / 2, max(x[0], k - x[-1])))


(n, l) = map(int, input().split())
num = [int(i) for i in input().split()]
num.sort()
d = max(num[0], l - num[-1])
for i in range(1, len(num)):
	if (num[i] - num[i - 1]) / 2 > d:
		d = (num[i] - num[i - 1]) / 2
print('{:.10f}'.format(d))


io_list = input().split()
[N, L] = [int(x) for x in io_list]
io_list = input().split()
a = [int(x) for x in io_list]
a.sort()
max_dist = -1
for i in range(len(a) - 1):
	max_dist = max(a[i + 1] - a[i], max_dist)
edge_dist = max(a[0], L - a[N - 1])
d = max(max_dist / 2, edge_dist)
print(d)


(n, l) = [int(i) for i in input().split()]
arr = [int(i) for i in input().split()]
arr.sort()
i = 0
dif = 0
while i < len(arr) - 1:
	if arr[i + 1] - arr[i] > dif:
		dif = arr[i + 1] - arr[i]
	i += 1
dif = dif / 2
if arr[0] > dif:
	dif = arr[0]
if l - arr[len(arr) - 1] > dif:
	dif = l - arr[len(arr) - 1]
print(dif)


(n, l) = [int(i) for i in input().split()]
nums = [int(i) for i in input().split()]
nums.sort()
distance = nums[0]
for i in range(1, len(nums)):
	if (nums[i] - nums[i - 1]) / 2 > distance:
		distance = (nums[i] - nums[i - 1]) / 2
if distance < l - nums[-1]:
	distance = l - nums[-1]
print(distance)


(n, p) = map(int, input('').split(' '))
m = sorted(list(map(int, input('').split(' '))))
i = 0
l = [m[0]]
while i + 1 < n:
	l.append((m[i + 1] - m[i]) / 2)
	i += 1
l.append(p - m[-1])
if max(l) != l[0] and max(l) != l[-1]:
	print(float(max(l)))
else:
	print(float(max(l)))


from sys import stdin
max_val = int(10000000000000.0)
min_val = int(-10000000000000.0)

def read_int():
	return int(stdin.readline())

def read_ints():
	return [int(x) for x in stdin.readline().split()]

def read_str():
	return input()

def read_strs():
	return [x for x in stdin.readline().split()]
(nb_points, length) = read_ints()
lanterns = sorted(read_ints())
max_rad = max(lanterns[0], length - lanterns[-1]) * 2
for i in range(1, nb_points):
	max_rad = max(max_rad, lanterns[i] - lanterns[i - 1])
print(max_rad / 2)


(n, k) = [int(j) for j in input().split()]
a = [int(j) for j in input().split()]
a.sort()
sum = 0
t = k
mine = max(a[0] - sum, k - a[n - 1])
for i in range(n - 1):
	if (a[i + 1] - a[i]) / 2 > mine:
		mine = (a[i + 1] - a[i]) / 2
print(mine)


string = input().split(' ')
n = int(string[0])
l = int(string[1])
lanterns = input().split(' ')
for i in range(n):
	lanterns[i] = int(lanterns[i])
lanterns = sorted(lanterns)
maxDistance = 0
for i in range(n - 1):
	current = lanterns[i + 1] - lanterns[i]
	if current > maxDistance:
		maxDistance = current
result = max(maxDistance / 2, lanterns[0], l - lanterns[n - 1])
print(str(result))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
d = 0
for i in range(1, len(a)):
	d = max(d, a[i] - a[i - 1])
radius = max(a[0], l - a[-1], d / 2)
print(radius)


from sys import stdin, stdout

def main():
	(n, l) = [int(i) for i in stdin.readline().split()]
	lanterns = [int(i) for i in stdin.readline().split()]
	lanterns.sort()
	dist = max(lanterns[0], l - lanterns[-1])
	for i in range(1, n):
		dist = max(dist, (lanterns[i] - lanterns[i - 1]) / 2)
	stdout.write(str(dist) + '\n')
main()


(n, l) = [int(i) for i in input().split()]
s = [int(i) for i in input().split()]
s.sort()
max = 0
if s[0] != 0:
	max = s[0]
for i in range(1, n):
	if (s[i] - s[i - 1]) / 2 > max:
		max = (s[i] - s[i - 1]) / 2
if s[n - 1] != l:
	if l - s[n - 1] > max:
		max = l - s[n - 1]
print(max)


h = input().split()
n = int(h[0])
l = int(h[1])
m = input().split()
for i in range(n):
	m[i] = int(m[i])
m.sort()
maxr = 0
for i in range(n - 1):
	if m[i + 1] - m[i] > maxr:
		maxr = m[i + 1] - m[i]
if m[0] > maxr / 2 and l - m[-1] < m[0]:
	print(m[0])
elif l - m[-1] > maxr / 2:
	print(l - m[-1])
else:
	print(maxr / 2)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
x = 0
for i in range(len(a) - 1):
	z = max(a[i + 1] - a[i], x)
	x = z
c = max(x / 2, max(a[0] - 0, l - a[-1]))
print('{:.10f}'.format(c))


def main(n, t, a):
	diff = 0
	for i in range(1, n):
		if a[i] - a[i - 1] > diff:
			diff = a[i] - a[i - 1]
	if diff / 2 >= a[0]:
		if diff / 2 >= t - a[n - 1]:
			print(diff / 2)
		else:
			print(t - a[n - 1])
	elif a[0] >= t - a[n - 1]:
		print(a[0])
	else:
		print(t - a[n - 1])
(n, t) = map(int, input().split())
a = list(map(int, input().split()))
a = list(sorted(a))
main(n, t, a)


(n, l) = input().split()
n = int(n)
l = int(l)
a = [int(i) for i in input().split()]
a.sort()
min_dist = a[0]
for i in range(1, n):
	min_dist = max(min_dist, (a[i] - a[i - 1]) / 2)
min_dist = max(min_dist, l - a[n - 1])
print(min_dist)


le = int(input().split()[1])
s = list(map(int, input().split()))
s.sort()
s.insert(0, -s[0])
s.append(le + le - s[-1])
diff = [s[i + 1] - s[i] for i in range(len(s) - 1)]
d = max(diff) / 2
print(d)


in1 = input().split()
nlan = int(in1[0])
leni = int(in1[1])
in2 = input().split()
locati = []
for i in in2:
	locati.append(int(i))
	locati.sort()
maxi = 0
for i in range(0, len(locati) - 1):
	if maxi < locati[i + 1] - locati[i]:
		maxi = locati[i + 1] - locati[i]
print(max(maxi / 2, locati[0], leni - locati[-1]))


import sys
import math

def main():
	(n, l) = list(map(int, sys.stdin.readline().strip().split(' ')))
	a = list(map(int, sys.stdin.readline().strip().split(' ')))
	sa = list(sorted(a))
	sa.insert(0, -sa[0])
	sa.append(l + (l - sa[-1]))
	n += 2
	max_dis = 0
	for (i, j) in zip(range(n), range(1, n)):
		d = sa[j] - sa[i]
		if d > max_dis:
			max_dis = d
	sys.stdout.write(str(max_dis / 2))
main()


from decimal import *
getcontext().prec = 10
(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
d = 0
for i in range(n - 1):
	if a[i + 1] - a[i] > d:
		d = a[i + 1] - a[i]
d = d / 2
if a[0] > d:
	d = a[0]
if l - a[n - 1] > d:
	d = l - a[n - 1]
print(round(d, 1000000000))


(n, l) = map(int, input().split())
x = [int(i) for i in input().split()]
x.sort()
s = 0
for i in range(n - 1):
	x1 = x[i + 1] - x[i]
	if x1 > s:
		s = x1
s = s / 2
if s < x[0] - 0:
	s = x[0] - 0
if s < l - x[-1]:
	s = l - x[-1]
print(s)


def main():
	(n, l) = list(map(int, input().split()))
	lst = list(map(int, input().split()))
	lst.sort()
	maxx = 0
	if lst[0] != 0:
		maxx = 2 * lst[0]
	if lst[-1] != l:
		maxx = max(maxx, 2 * (l - lst[-1]))
	for i in range(1, n):
		if lst[i] - lst[i - 1] > maxx:
			maxx = lst[i] - lst[i - 1]
	print('%.10f' % float(maxx / 2))
t = 1
while t != 0:
	main()
	t -= 1


(X, L) = (list(map(int, input().split())), sorted(list(map(int, input().split()))))
print(max(L[0], max([L[i] - L[i - 1] for i in range(1, X[0])] + [0]) / 2, X[-1] - L[-1]))


try:
	inp = [int(x) for x in input().split(' ')]
	if len(inp) > 2:
		print('Invalid Input.')
		exit()
	lanterns = [int(x) for x in input().split(' ')]
	if len(lanterns) > inp[0]:
		print('Too many lanterns')
		exit()
	lanterns.sort()
	if lanterns[0] < 0 or lanterns[-1] > inp[1]:
		print('Improper lantern location')
		exit()
	dist = []
	for i in range(len(lanterns) - 1):
		dist.append(abs(lanterns[i] - lanterns[i + 1]) / 2)
	dist.sort()
	dist.append(lanterns[0])
	dist.append(abs(lanterns[-1] - inp[1]))
	print(max(dist))
except ValueError:
	print('Invalid Input')


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
k = len(a)
diff = 0
for i in range(k):
	if i == 0:
		if a[0] == 0:
			pass
		else:
			diff = a[i]
	if i == n - 1:
		if a[n - 1] != l:
			diff = max(diff, l - a[n - 1])
		else:
			diff = max(diff, (a[i] - a[i - 1]) / 2)
	else:
		diff = max(diff, (a[i] - a[i - 1]) / 2)
print('{0:.9f}'.format(diff))


(n, m) = map(int, input().split())
a = sorted(list(map(int, input().split())))
t = max(a[0], m - a[n - 1]) * 2
for i in range(n - 1):
	t = max(t, a[i + 1] - a[i])
print(t / 2)


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
t = [0] * (n + 1)
for i in range(len(a) - 1):
	t[i] = a[i + 1] - a[i]
D1 = a[0]
D2 = l - a[-1]
w = max(D1, D2, max(t) / 2)
print('%.10f' % w)


(n, k) = map(int, input().split())
lst = sorted(list(map(int, input().split())))
mx = max(lst[0] - 0, k - lst[n - 1])
for (i, j) in enumerate(range(n - 1)):
	mx = max((lst[i + 1] - lst[i]) / 2, mx)
print(mx)


inp = input().split()
arr = input().split()
for i in range(len(arr)):
	arr[i] = int(arr[i])
arr.sort()
ans = max(arr[0], int(inp[1]) - arr[int(inp[0]) - 1]) * 2
for i in range(1, len(arr)):
	if arr[i] - arr[i - 1] > ans:
		ans = arr[i] - arr[i - 1]
print(ans / 2)


(pl, ls) = list(map(int, input().split()))
a = list(map(int, input().split()))
if ls == 1:
	print(1)
elif pl == 1:
	lb = a[0] - 0
	rb = ls - a[0]
	print(max(lb, rb))
else:
	a.sort()
	l = []
	for i in range(pl - 1):
		k = a[i + 1] - a[i]
		l.append(k)
	maxo = max(l)
	lb = a[0] - 0
	rb = ls - a[-1]
	print(max(maxo / 2, lb, rb))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
man = 0
for i in range(len(a) - 1):
	if a[i + 1] - a[i] > man:
		man = a[i + 1] - a[i]
print(max(a[0], man / 2, l - a[-1]))


inp = input().split(' ')
n = int(inp[0])
l = int(inp[1])
lanterns = [int(lantern) for lantern in input().split(' ')]
lanterns.sort()
left = lanterns[0]
right = l - lanterns[-1]
mid = 0
for i in range(1, n):
	mid = max(mid, (lanterns[i] - lanterns[i - 1]) / 2)
print(max(left, mid, right))


(n, l) = map(int, input().split())
a_list = list(map(int, input().split()))
a_list.sort()
a_list.insert(0, -a_list[0])
a_list.append(2 * l - a_list[-1])
diffs = [t - s for (s, t) in zip(a_list, a_list[1:])]
print(max(diffs) / 2)


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = []
a.sort()
for i in range(n):
	if i == 0:
		b.append(a[i])
	else:
		b.append((a[i] - a[i - 1]) / 2)
b.append(l - a[-1])
print(max(b))


(n, l) = map(int, input().split())
lst = sorted(list(map(int, input().split())))
ld = [lst[i + 1] - lst[i] for i in range(n - 1)]
if ld == []:
	ld.append(lst[0])
x = float(max(max(ld) / 2, max(lst[0], l - lst[n - 1])))
print(format(x, '.10f'))


[n, l] = [int(x) for x in input().split()]
laterns = [float(x) for x in input().split()]
laterns.sort()
ans = 0
for i in range(n - 1):
	ans = max((laterns[i + 1] - laterns[i]) / 2, ans)
print(max(ans, laterns[0], l - laterns[-1]))


s = input().split()
l = int(s[1])
n = list(map(int, input().split()))
n = sorted(n)
diff = []
if len(n) == 1:
	diff.append(max(l - n[0], n[0] - 0))
else:
	for i in range(0, len(n)):
		if i == 0:
			if n[i] != 0:
				diff.append(n[i])
			else:
				diff.append((n[i + 1] - n[i]) / 2)
		elif i == len(n) - 1:
			if n[i] != l:
				diff.append(l - n[i])
			else:
				diff.append((n[i] - n[i - 1]) / 2)
		else:
			diff.append((n[i] - n[i - 1]) / 2)
print('%0.9f' % max(diff))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
otv = []
if 0 not in a:
	otv.append(a[-1])
if l not in a:
	otv.append(l - a[0])
for i in range(n - 1):
	otv.append((a[i] - a[i + 1]) / 2)
print(max(otv))


(n, l) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort()
p = 0.0
q = 0
for i in range(0, n - 1):
	q = a[i + 1] - a[i]
	q /= 2
	if p < q:
		p = q
if a[0] != 0 and p < a[0]:
	p = a[0]
if a[-1] != l and p < l - a[-1]:
	p = l - a[-1]
print(p)


def fun(x, arr, l):
	if arr[0] > x or l - arr[-1] > x:
		return False
	for i in range(len(arr) - 1):
		if arr[i + 1] - arr[i] > 2 * x:
			return False
	return True

def proB(arr, end):
	l = 0
	h = end
	arr.sort()
	for i in range(100):
		mid = (l + h) / 2
		if fun(mid, arr, end):
			h = mid
		else:
			l = mid
	return h
arr1 = list(map(int, input().split()))
(n, l) = arr1
arr = list(map(int, input().split()))
print(proB(arr, l))


(n, l) = [int(x) for x in input().split()]
s = [int(x) for x in input().split()]
s.sort()
a = max(s[0], l - s[-1])
for i in range(n - 1):
	x = (s[i + 1] - s[i]) / 2
	a = max(a, x)
print('%.10f' % a)


value = input()
(a, b) = value.split()
a = int(a)
b = int(b)
values = input()
values = values.split()
values = [int(i) for i in values]
values.sort()
value = values[-1]
value2 = values[0]
for i in range(a - 1):
	values[i] = values[i + 1] - values[i]
values.pop()
try:
	c = max(values)
except:
	c = 0
print('{0:.9f}'.format(max(c / 2, value2, b - value)))


(n, l) = [int(v) for v in input().split()]
a = [int(u) for u in input().split()]
a = sorted(a)
b = []
c = 0
ans = 0
d = l - a[n - 1]
if n == 1 or l == 1:
	if a[0] == 0:
		print(l)
	elif a[0] == l:
		print(l)
	elif a[0] > l / 2:
		print(a[0])
	else:
		print(l - a[0])
	exit()
for i in range(0, n - 1):
	c = a[i + 1] - a[i]
	b.append(c)
if (0 not in a and l not in a) and (a[0] > max(b) / 2 and d > max(b) / 2):
	if a[0] > d:
		ans = a[0]
	else:
		ans = d
elif 0 not in a or l not in a:
	if 0 not in a and a[0] > max(b) / 2:
		ans = a[0]
	elif l not in a and d > max(b) / 2:
		ans = d
	else:
		ans = max(b) / 2
else:
	ans = max(b) / 2
print('{0:.10f}'.format(ans))


a = input().split()
b = input().split()
n = int(a[0])
l = int(a[1])
b = [int(i) for i in b]
b.sort()
count1 = b.count(0)
count2 = b.count(l)
temp = []
for i in range(0, n - 1):
	x = b[i + 1] - b[i]
	temp.append(x)
temp = [i / 2 for i in temp]
if count1 > 0 and count2 == 0:
	temp.append(l - b[-1])
elif count1 == 0 and count2 > 0:
	temp.append(b[0])
else:
	temp.append(l - b[-1])
	temp.append(b[0])
temp.sort()
print(temp[-1])


(n, l) = map(int, input().split())
x = list(map(int, input().split()))
x = sorted(x)
maxx = max(x[0] - 0, l - x[n - 1]) * 2
for i in range(n - 1, 0, -1):
	t = x[i] - x[i - 1]
	if t > maxx:
		maxx = t
print(maxx / 2)


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
b = list(set(a))
b.sort()
d = max(b[0] - 0, l - b[-1])
for i in range(len(b) - 1):
	c = (b[i + 1] - b[i]) / 2
	d = max(d, c)
print(d)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
a1 = a.copy()
b = []
d = 0
c = [0, l]
e = 0
f = 0
if a[0] != c[0]:
	e = a1[0]
	b.append(e)
for i in range(n):
	if i < n - 1:
		d = a1[i + 1] - a1[i]
		d /= 2
		b.append(d)
if a1[-1] != c[-1]:
	f = l - a[-1]
	b.append(f)
b.sort()
b.reverse()
print(b[0])


(n, l) = map(int, input().split(' '))
lanterns = list(map(int, input().split(' ')))
for i in range(n):
	minimum = i
	for j in range(i + 1, n):
		if lanterns[minimum] > lanterns[j]:
			minimum = j
	temp = lanterns[i]
	lanterns[i] = lanterns[minimum]
	lanterns[minimum] = temp
r1 = lanterns[0] - 0
r2 = l - lanterns[n - 1]
if r1 > r2:
	r = r1
else:
	r = r2
d = 0
for i in range(n - 1):
	if d < lanterns[i + 1] - lanterns[i]:
		d = lanterns[i + 1] - lanterns[i]
if r > d / 2:
	print('%.10f' % r)
else:
	print('%.10f' % float(d / 2))


(n, l) = map(int, input().split())
l1 = list(map(int, input().split()))
l1.sort()
d = max(l1[0], l - l1[-1])
for i in range(1, n):
	if (l1[i] - l1[i - 1]) / 2 > d:
		d = (l1[i] - l1[i - 1]) / 2
print(f'{d:.10f}')


data = str(input()).split()
lantern = str(input()).split()
lantern_new = [int(x) for x in lantern]
lantern = lantern_new
lantern.sort()
n = int(data[0])
l = int(data[1])
i = 0
j = 0
while i < n - 1:
	k = lantern[i + 1] - lantern[i]
	if k > j:
		j = k
		i = i + 1
	else:
		i = i + 1
p = lantern[0]
q = l - lantern[-1]
print(str(max(j / 2, p, q)))


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
maximum = max(l[0] - 0, k - l[-1])
for j in range(1, len(l)):
	diff = l[j] - l[j - 1]
	maximum = max(diff / 2, maximum)
print(maximum)


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
sum = 0
sum = max(sum, a[0])
sum = max(sum, abs(l - a[-1]))
for i in range(1, n):
	sum = max(sum, (a[i] - a[i - 1]) / 2)
print(sum)


(lamp, l) = list(map(int, input().split()))
x = list(map(int, input().split()))
x = list(set(x))
x1 = []
x.sort()
for i in range(len(x) - 1):
	x1.append(x[i + 1] - x[i])
if 0 not in x:
	x1.append(2 * min(x))
if l not in x:
	x1.append(2 * (l - max(x)))
x1.sort()
ans = max(x1) / 2
print(ans)


(n, m) = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
a = A[0]
c = m - A[-1]
b = 0
for i in range(n - 1):
	if A[i + 1] - A[i] > b:
		b = A[i + 1] - A[i]
print(max(a, b / 2, c))


(n, l) = map(int, input().split())
l1 = list(map(int, input().split()))
l1.sort()
r = max(l1[0], abs(l - l1[-1]))
for i in range(1, n):
	if abs(l1[i] - l1[i - 1]) / 2 > r:
		r = abs(l1[i] - l1[i - 1]) / 2
print(r)


(n, l) = map(int, input().split())
lanterns = sorted(map(int, input().split()))
distances = {(v - lanterns[i - 1]) / 2 for (i, v) in enumerate(lanterns[1:], 1)}
distances.add(lanterns[0] - 0)
distances.add(l - lanterns[-1])
print(max(distances))


class TaskA(object):

	def __init__(self):
		self.get_data()
		self.solve()
		self.print_ans()
	pass

	def get_data(self):
		(self.n, self.l) = map(int, input().split())
		self.a = list(map(int, input().split()))
		pass

	def solve(self):
		self.a.sort()
		a = []
		for i in range(1, len(self.a)):
			a.append(self.a[i] - self.a[i - 1])
		if self.a[0] != 0:
			a.append(self.a[0] * 2)
		if self.a[-1] != self.l:
			a.append((self.l - self.a[-1]) * 2)
		self.ans = max(a) / 2
		pass

	def print_ans(self):
		print('%.12f' % self.ans)
		pass

def main():
	TaskA()
	pass
main()


(n, l) = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
arr = []
for i in arr2:
	if i not in arr:
		arr.append(i)
arr.sort()
(diffstart, diffend) = (0, 0)
if 0 not in arr:
	diffstart = arr[0] - 0
if l not in arr:
	diffend = l - arr[len(arr) - 1]
m = max(diffstart, diffend)
for i in range(len(arr) - 1):
	if (arr[i + 1] - arr[i]) / 2 > m:
		m = (arr[i + 1] - arr[i]) / 2
print('%.10f' % m)


(x, y) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
a = []
for i in range(x - 1):
	a.append(l[i + 1] - l[i])
if a != []:
	z = max(max(a) / 2, l[0], y - l[x - 1])
else:
	z = max(max(l) / 2, l[0], y - l[x - 1])
print('%.10f' % z)


(a, l) = map(int, input().split())
mass = sorted([int(i) for i in input().split()], reverse=True)
r1 = 2 * min(mass)
r2 = 2 * (l - max(mass))
m = 0
for i in range(len(mass) - 1):
	dif = mass[i] - mass[i + 1]
	if dif > m:
		m = dif
res = max(r1, r2, m) / 2
print('{0:.10f}'.format(res))


s1 = input()
s = s1.split(' ')
n = int(s[0])
l = int(s[1])
string = input()
k = string.split(' ')
light = [0] * n
for i in range(n):
	light[i] = int(k[i])
light.sort()
mx = light[0] * 1.0
for i in range(n - 1):
	p = (light[i + 1] - light[i]) * 1.0
	p = p / 2
	if p > mx:
		mx = p
p = l - light[n - 1]
if p > mx:
	mx = p
print(mx)


(n, l) = map(int, input().split())
s = list(map(int, input().split()))
s.sort()
list = []
i = 0
while i < n - 1:
	a = (s[i + 1] - s[i]) / 2
	list.append(a)
	i = i + 1
a = min(s) - 0
list.append(a)
b = l - max(s)
list.append(b)
d = max(list)
print(d)


def lanterns(line1, line2):
	positions = [int(P) for P in line2.split(' ')]
	positions = sorted(positions)
	street_length = int(line1.split(' ')[1])
	radius = 0
	radius = max(radius, positions[0])
	radius = max(radius, street_length - positions[-1])
	for i in range(len(positions) - 1):
		dist = positions[i + 1] - positions[i]
		radius = max(radius, dist / 2)
	print(radius)
lanterns(input(), input())


(n, l) = map(int, input().split())
lst = list(map(int, input().split()))
lst.sort()
if lst[0] == 0:
	dif = 0
else:
	dif = lst[0]
if lst[n - 1] != l:
	bd = l - lst[n - 1]
else:
	bd = dif
dif = max(dif, bd)
gap = -1
for i in range(1, n):
	ss = lst[i] - lst[i - 1]
	if ss > gap:
		gap = ss
ff = max(dif, bd)
jj = gap / 2
if jj < ff:
	print('{:.10f}'.format(ff))
else:
	print('{:.10f}'.format(gap / 2))


(n, d) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
m = 0
for i in range(1, n):
	diff = arr[i] - arr[i - 1]
	if diff > m:
		m = diff
if n > d:
	print('{:.10f}'.format(m / 2))
else:
	f1 = arr[0] - 0
	f2 = d - arr[n - 1]
	m = max(f1, f2, m / 2)
	print('{:.10f}'.format(m))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
dist1 = min(a) - 0
dist2 = l - max(a)
diff = 0
maxi = 0
for i in range(1, n):
	diff = (a[i] - a[i - 1]) / 2
	if maxi <= diff:
		maxi = diff
ans = max(dist1, max(dist2, maxi))
print('{0:.10f}'.format(ans))


(n, l) = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
x = A[0]
for i in range(1, n):
	y = (A[i] - A[i - 1]) / 2
	if y > x:
		x = y
if l - A[n - 1] > x:
	x = l - A[n - 1]
print(x)


(size, length) = map(int, input().split())
positions = [int(v) for v in input().split()]
positions.sort()
maxDiff = 0
for i in range(len(positions) - 1):
	maxDiff = max(maxDiff, positions[i + 1] - positions[i])
if positions[0] - maxDiff / 2 > 0 or positions[-1] + maxDiff / 2 < length:
	print(max(positions[0], length - positions[-1]))
else:
	print(maxDiff / 2)


(n, la) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
c = []
c.append(l[0])
for i in range(n - 1):
	c.append((l[i + 1] - l[i]) / 2)
c.append(la - l[-1])
print('%.10f' % max(c))


def street(arr, l):
	arr.sort()
	zeroth = arr[0] * 2
	last = (l - arr[-1]) * 2
	smol = max(zeroth, last)
	for i in range(1, len(arr)):
		val = arr[i] - arr[i - 1]
		smol = max(smol, val)
	return smol / 2
(n, l) = list(map(int, input().rstrip().split()))
x = list(map(int, input().rstrip().split()))
print(street(x, l))


(n, l) = map(int, input().split())
data = sorted(list(map(int, input().split())))
right = data[0]
left = l - data[-1]
between = 0
for num in range(len(data) - 1):
	between = max(data[num + 1] - data[num], between)
print(max(right, left, between / 2))


(n, l) = [int(x) for x in input().split()]
L = [int(x) for x in input().split()]
L.sort()
gap = []
if n > 1:
	for i in range(1, n):
		gap.append(L[i] - L[i - 1])
	if L[0] == 0 and L[n - 1] == l:
		x = max(gap) / 2
	elif L[0] == 0 and L[n - 1] != l:
		x = max(max(gap) / 2, l - max(L))
	elif L[0] != 0 and L[n - 1] == l:
		x = max(max(gap) / 2, min(L))
	elif L[0] != 0 and L[n - 1] != 0:
		x = max(max(gap) / 2, min(L), l - max(L))
	print(round(x, 9))
else:
	print(max(L[0], l - L[0]))


import sys
input = sys.stdin.readline
(n, len_street) = map(int, input().split())
lights = sorted(map(int, input().split()))
mx = abs(0 - lights[0])
for i in range(len(lights) - 1):
	(f, s) = (lights[i], lights[i + 1])
	mx = max(mx, abs(f - s) / 2)
mx = max(mx, abs(len_street - lights[-1]))
print(mx)


(N, L) = input().strip().split()
(N, L) = (int(N), int(L))
lanterns = input().strip().split()
for i in range(N):
	lanterns[i] = int(lanterns[i])
lanterns.sort()
largest = 0
for i in range(N - 1):
	diff = lanterns[i + 1] - lanterns[i]
	if diff > largest:
		largest = diff
print(max(largest / 2, L - lanterns[len(lanterns) - 1], lanterns[0]))


(n, t) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
mx = l[0]
for i in range(1, n):
	mx = max(mx, (l[i] - l[i - 1]) / 2)
mx = max(mx, t - l[-1])
print(mx)


(n, l) = input().split()
(n, l) = (int(n), int(l))
a = []
a = list(map(int, input().split()))
a.sort()
b = []
i = 0
count1 = a.count(0)
count2 = a.count(l)
if count2 != 0 and count1 != 0:
	for i in range(0, n - 1):
		b.append(a[i + 1] - a[i])
	print('%.9f' % float(max(b) / 2))
if count1 == 0 and count2 != 0:
	b.append(a[0])
	for i in range(1, n - 1):
		b.append(float((a[i + 1] - a[i]) / 2))
	print('%.9f' % float(max(b)))
if count1 != 0 and count2 == 0:
	b.append(l - a[-1])
	for i in range(0, n - 2):
		b.append(float((a[i + 1] - a[i]) / 2))
	print('%.9f' % float(max(b)))
if count1 == 0 and count2 == 0:
	b.append(a[0])
	b.append(l - a[-1])
	for i in range(1, n - 2):
		b.append(float((a[i + 1] - a[i]) / 2))
	print('%.9f' % float(max(b)))


(n, l) = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
arr.sort()
maxDiff = 0
for i in range(len(arr) - 1):
	diff = arr[i + 1] - arr[i]
	if diff > maxDiff:
		maxDiff = diff
maxDiff = max(maxDiff, (arr[0] - 0) * 2)
maxDiff = max(maxDiff, (l - arr[-1]) * 2)
print(maxDiff / 2)


(n, l) = map(int, input().strip().split(' '))
beam = [a for a in map(int, input().strip().split(' '))]
beam.sort()
maxspace = 2 * max(beam[0], l - beam[len(beam) - 1])
for i in range(n - 1):
	t = beam[i + 1] - beam[i]
	if t > maxspace:
		maxspace = t
print(maxspace / 2)


(lamps, length) = input().split(' ')
lamps = int(lamps)
length = int(length)
posi = input().split(' ')
for i in range(lamps):
	posi[i] = int(posi[i])
sorted_posi = sorted(posi)
sorted_posi.append(0)
sorted_posi.append(length)
sorted_posi = sorted(sorted_posi)
most_sub = 0
for i in range(len(sorted_posi)):
	try:
		if most_sub < abs(sorted_posi[i] - sorted_posi[i + 1]):
			most_sub = abs(sorted_posi[i] - sorted_posi[i + 1])
	except IndexError:
		break
if most_sub < min(posi) * 2:
	most_sub = min(posi) * 2
if most_sub < (length - max(posi)) * 2:
	most_sub = (length - max(posi)) * 2
print(most_sub / 2)


from collections import deque
from collections import OrderedDict
import math
import sys
import os
from io import BytesIO
(n, l) = map(int, input().split())
alen = input().split()
for i in range(n):
	alen[i] = int(alen[i])
alen.sort()
left = max(alen[0], l - alen[n - 1])
right = l
answer = left
while left <= right:
	c = left + (right - left) / 2
	if c - math.floor(c) == 0.25:
		c += 0.25
	elif c - math.floor(c) == 0.75:
		c -= 0.25
	isMore = False
	for i in range(1, n):
		if alen[i] - alen[i - 1] > c * 2:
			isMore = True
			break
	if isMore == True:
		if math.floor(c) != c:
			left = math.ceil(c)
		else:
			left = c + 0.5
	else:
		if math.floor(c) != c:
			right = math.floor(c)
		else:
			right = c - 0.5
		answer = c
	if left == right + 1:
		break
print(answer)


(a, b) = map(int, input().split())
d = list(map(int, input().split()))
d.sort()
maximumm = 1
for x in range(len(d) - 1):
	if d[x + 1] - d[x] > maximumm:
		maximumm = d[x + 1] - d[x]
maximumm /= 2
print(max(maximumm, d[0] - 0, b - d[a - 1]))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
maxx = 0
if a[0] > 0:
	maxx = a[0]
if a[-1] < l and l - a[-1] > maxx:
	maxx = l - a[-1]
for i in range(n - 1):
	d = (a[i + 1] - a[i]) / 2
	if d > maxx:
		maxx = d
print(maxx)


(n, t) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
if t != 1 and n != 1:
	c = [0] * (n - 1)
elif n == 1 and t != 1:
	c = [a[0]]
else:
	c = [0]
for i in range(n - 1):
	c.append(a[i + 1] - a[i])
print(max(a[0], max(c) / 2, t - a[-1]))


(n, l) = map(int, input().split())
max = 0
lista = list(map(int, input().split()))
lista.sort()
i = 1
if lista[0] != 0:
	max = lista[0]
while i <= len(lista) - 1:
	a = lista[i] - lista[i - 1]
	i += 1
	if a / 2 > max:
		max = a / 2
if lista[-1] != l and l - lista[-1] > max:
	max = l - lista[-1]
print('{:.10f}'.format(max))


input1 = input('')
input2 = input('')
input1 = input1.split(' ')
input2 = input2.split(' ')
for i in range(len(input2)):
	input2[i] = int(input2[i])
input2.sort()
end = int(input1[1])
all = input2
max = 0
for i in range(len(all) - 1):
	dif = int(all[i + 1]) - int(all[i])
	if dif / 2 > max:
		max = dif / 2
BeginDif = all[0]
EndDif = end - all[-1]
if BeginDif > max:
	max = BeginDif
if EndDif > max:
	max = EndDif
print(max)


(n, m) = map(int, input().split())
lanterns = sorted(map(int, input().split()))
dist = []
if 0 not in lanterns:
	dist.append(lanterns[0])
if m not in lanterns:
	dist.append(m - lanterns[-1])
for i in range(len(lanterns) - 1):
	dist.append((lanterns[i + 1] - lanterns[i]) / 2)
print('{:.10f}'.format(sorted(dist)[-1]))


l = int(input().split()[1])
arr = list(map(int, input().split()))
arr.sort()
res = 0
if l not in arr:
	res = abs(arr[-1] - l)
if 0 not in arr:
	if arr[0] > res:
		res = arr[0]
for i in range(0, len(arr) - 1):
	x = abs(arr[i] - arr[i + 1]) / 2
	if x > res:
		res = x
print(res)


a = list(map(int, str(input()).split()))
n = a[0]
l = a[1]
a = list(map(int, str(input()).split()))
a.sort()
answer = float(max(a[0], l - a[n - 1]))
for i in range(1, n):
	answer = float(max(answer, (a[i] - a[i - 1]) / 2.0))
print(answer)


from sys import *
from math import *
from copy import *
from pprint import *
from collections import *
from bisect import *
(n, k) = map(int, stdin.readline().split())
a = list(map(int, stdin.readline().split()))
a.sort()
mx = 1.0
for i in range(1, len(a)):
	mx = max(mx, a[i] - a[i - 1])
if a[0] == 0 and a[len(a) - 1] != k:
	mx = max(mx, 2 * (k - a[len(a) - 1]))
elif a[0] != 0 and a[len(a) - 1] == k:
	mx = max(mx, 2 * a[0])
else:
	mx = max(mx, 2 * a[0], 2 * (k - a[len(a) - 1]))
stdout.write('%.10f' % (mx / 2))


def solve():
	(n, length) = map(int, input().split())
	data = sorted(map(int, input().split()))
	max_dist = -1
	for i in range(len(data) - 1):
		max_dist = max(data[i + 1] - data[i], max_dist)
	max_dist /= 2
	max_dist = max(max_dist, data[0], length - data[-1])
	print(max_dist)
solve()


import sys
(n, l) = map(int, input().split())
l = float(l)
arr = list(map(int, input().split()))
arr = sorted(arr)
(lb, ub, ans, prevlb, prevub) = (0, l, sys.maxsize, 0, 0)
while lb < ub:
	(prevlb, prevub) = (lb, ub)
	(mid, flag) = ((lb + ub) / 2, 0)
	if arr[0] - mid <= 0:
		for i in range(1, n):
			if arr[i - 1] + mid < arr[i] - mid:
				flag = 1
				break
		if flag == 1:
			lb = mid
		elif arr[-1] + mid >= l:
			if round(ans, 10) == round(mid, 10):
				break
			ans = min(ans, mid)
			ub = mid
		else:
			lb = mid
	else:
		lb = mid
	if lb == prevlb and ub == prevub:
		break
print(round(ans, 10))


(z, zz) = (input, lambda : list(map(int, z().split())))
(szz, dgraphs, mod) = (lambda : sorted(zz()), {}, 10 ** 9 + 7)
from string import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
(n, m) = zz()
l = szz()
ans = 0
x = l[0]
for i in l[1:]:
	p = i - x
	if ans < p:
		ans = p
	x = i
print(max(ans / 2, l[0], m - l[-1]))


n = input()
l = input()
x = [int(i) for i in n.split()]
y = [int(i) for i in l.split()]
y.sort()
maxn = y[0]
if x[1] - y[len(y) - 1] > maxn:
	maxn = x[1] - y[len(y) - 1]
for i in range(len(y) - 1, 0, -1):
	if (y[i] - y[i - 1]) / 2 > maxn:
		maxn = (y[i] - y[i - 1]) / 2
print(maxn)


(n, l) = map(int, input().split())
x = list(map(int, input().split()))
x.sort()
d = []
d.append(x[0] - 0)
d.append(l - x[-1])
for i in range(n - 1):
	d.append((x[i + 1] - x[i]) / 2)
print(max(d))


while True:
	try:

		def solution(n, l, lentrns):
			lentrns.sort()
			t = lentrns[0] - 0
			t1 = l - lentrns[n - 1]
			d = max(t, t1)
			for i in range(n - 1):
				d = max(d, (lentrns[i + 1] - lentrns[i]) / 2.0)
			print(d)

		def read():
			(n, l) = map(int, input().split())
			lentrns = list(map(float, input().split()))
			solution(n, l, lentrns)
		if __name__ == '__main__':
			read()
	except EOFError:
		break


y = input().split()
n = int(y[0])
l = int(y[1])
x = input().split()
M = [int(i) for i in x]
M.sort()
max1 = M[0]
max2 = l - M[n - 1]
max3 = 0
for i in range(n - 1):
	if M[i + 1] - M[i] > max3:
		max3 = M[i + 1] - M[i]
print(max(max1, max2, max3 / 2))


l = [int(i) for i in input().split()]
n = l[0]
m = l[1]
l = [int(i) for i in input().split()]
l.sort()
a = l[0]
b = m - l[-1]
d = [0] * (n - 1)
i = 1
while i < n:
	d[i - 1] = (l[i] - l[i - 1]) / 2
	i += 1
d.append(a)
d.append(b)
print(max(d))


from sys import stdin, stdout
import math
input = stdin.readline

def print(x='', y='', end='\n'):
	if y == '':
		stdout.write(str(x) + end)
	else:
		stdout.write(str(x) + ' ' + str(y) + end)

def solve():
	(n, ll) = map(int, input().split())
	l = list(map(int, input().split()))
	l.sort()
	l.insert(0, 0)
	l.append(ll)
	ans = 0
	for i in range(1, n + 2):
		ans = max(ans, (l[i] - l[i - 1]) / 2)
	ans = max(ans, l[1] - l[0])
	ans = max(ans, l[-1] - l[-2])
	print(ans)
tt = 1
for __ in range(tt):
	solve()


(n, l) = [int(i) for i in input().split(' ')]
sequence = sorted([int(i) for i in input().split(' ')])
if n > 1:
	max_diff = max((sequence[i + 1] - sequence[i] for i in range(n - 1)))
else:
	max_diff = 0
print(max(max_diff / 2, sequence[0], l - sequence[n - 1]))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
ans = float(0.0)
for i in range(len(a) - 1):
	ans = max(ans, (a[i + 1] - a[i]) / 2)
ans = max(a[0], ans)
ans = max(l - a[len(a) - 1], ans)
print(ans)


(n, m) = map(int, input().split())
l = sorted(list(map(int, input().split())))
r = [min(l), m - max(l)]
for i in range(1, len(l)):
	r.append((l[i] - l[i - 1]) / 2)
print(max(r))


(n, l) = map(int, input().split())
s = sorted(map(int, input().split()))
lst = [s[i] - s[i - 1] for i in range(1, n)]
ans = 0
if lst != []:
	ans = max(lst) / 2
ans2 = max(s[0], l - s[n - 1])
print(ans if ans > ans2 else ans2)


n_l = input().split()
n = int(n_l[0])
l = int(n_l[1])
lan = input().split()
for i in range(len(lan)):
	lan[i] = int(lan[i])
lan.sort()
if len(lan) > 1:
	start = lan[0]
	finish = l - lan[len(lan) - 1]
	biggest = lan[1] - lan[0]
	for i in range(1, len(lan) - 1):
		da = lan[i] - lan[i - 1]
		dp = lan[i + 1] - lan[i]
		if da > biggest:
			biggest = da
		if dp > biggest:
			biggest = dp
	r = True
	while r == True:
		if start > biggest / 2:
			if start > finish:
				print('{:.9f}'.format(start))
				break
		if finish > biggest / 2:
			if finish >= start:
				print('{:.9f}'.format(finish))
				break
		if start <= biggest / 2 and finish <= biggest / 2:
			print('{:.9f}'.format(biggest / 2))
			break
		else:
			print(0)
			break
if len(lan) == 1:
	start = lan[0]
	finish = l - lan[len(lan) - 1]
	if start >= finish:
		print('{:.9f}'.format(start))
	if finish > start:
		print('{:.9f}'.format(finish))


(num_lanterns, len_street) = map(int, input().split())
pos_lanterns = list(sorted(map(int, input().split())))
max = pos_lanterns[0]
for x in range(num_lanterns - 1):
	dif = (pos_lanterns[x + 1] - pos_lanterns[x]) / 2
	if dif > max:
		max = dif
if len_street - pos_lanterns[num_lanterns - 1] > max:
	max = len_street - pos_lanterns[num_lanterns - 1]
print('%.10f' % max)


(n, m) = input().split()
n = int(n)
m = int(m)
x = list(map(int, input().split()))
x.sort()
aux = 0
if len(x) != 1:
	aux = x[1] - x[0]
	for i in range(2, len(x)):
		aux = max(x[i] - x[i - 1], aux)
aux = aux / 2
aux = max(aux, x[0] - 0)
aux = max(aux, m - x[len(x) - 1])
aux = float(aux)
print(format(aux, '.10f'))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
m = 0
b = False
if a[0] != 0:
	m = a[0]
	b = True
if a[n - 1] != l:
	curr = l - a[n - 1]
	if curr > m:
		m = curr
		b = True
for i in range(1, n):
	curr = a[i] - a[i - 1]
	if curr / 2 > m:
		m = curr / 2
print(m)


(n, l) = map(int, input().split())
lis = list(map(int, input().split()))
lis.sort()
if lis[0] > l - lis[-1]:
	max = lis[0]
else:
	max = l - lis[-1]
for i in range(n - 1):
	j = (lis[i + 1] - lis[i]) / 2
	if j > max:
		max = j
print(max)


def input_split(f):
	return map(f, input().split())

def main():
	(n, l) = input_split(int)
	a = list(input_split(int))
	a.sort()
	res = -1
	for i in range(0, n - 1):
		tmp = (a[i + 1] - a[i]) / 2
		res = max(tmp, res)
	if a[0] != 0:
		res = max(res, a[0])
	if a[-1] != l:
		res = max(res, l - a[-1])
	print('{:.10f}'.format(res))
main()


(u, v) = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
l = sorted(l)
if u == 1:
	print(max(l[0], v - l[0]))
elif l[0] == 0:
	if l[u - 1] == v:
		print(max(((l[i + 1] - l[i]) / 2 for i in range(u - 1))))
	else:
		print(max(v - l[u - 1], max(((l[i + 1] - l[i]) / 2 for i in range(u - 1)))))
elif l[u - 1] == v:
	print(max(l[0], max(((l[i + 1] - l[i]) / 2 for i in range(u - 1)))))
else:
	print(max(l[0], v - l[u - 1], max(((l[i + 1] - l[i]) / 2 for i in range(u - 1)))))


(n, l) = map(int, input().split(' '))
lanterns = list(map(int, input().split(' ')))
lanterns.sort()
radius = 0
for i in range(len(lanterns) - 1):
	temp = (lanterns[i + 1] - lanterns[i]) / 2
	if temp >= radius:
		radius = temp
if lanterns[0] > radius:
	radius = lanterns[0]
if abs(lanterns[n - 1] - l) > radius:
	radius = abs(lanterns[n - 1] - l)
print(radius)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr = sorted(arr)
diff = 0
for i in range(1, len(arr)):
	diff = max(diff, arr[i] - arr[i - 1])
print(max(arr[0] - 0, diff / 2, l - arr[-1]))


max = 0
ln = input().split()
f = input().split()
n = int(ln[0])
l = int(ln[1])
for i in range(len(f)):
	f[i] = int(f[i])
f = sorted(f)
nad = int(f[0]) - 0
nad1 = l - int(f[n - 1])
for i in range(len(f) - 1):
	if f[i + 1] - f[i] > max:
		max = f[i + 1] - f[i]
if nad < nad1:
	nad = nad1
max = max / 2
if max > nad:
	nad = max
print(nad)


(n, l) = map(int, input().split())
laterrns = sorted(list(map(int, input().split())))
maks = 0
for i in range(len(laterrns)):
	if i == 0:
		maks = laterrns[0]
	if i == n - 1:
		if abs(laterrns[i] - l) > maks:
			maks = abs(laterrns[i] - l)
	elif abs(laterrns[i] - laterrns[i + 1]) / 2 > maks:
		maks = abs(laterrns[i] - laterrns[i + 1]) / 2
print(maks)


(n, l) = [int(x) for x in input().split()]
positions = sorted([int(x) for x in input().split()])
positions = [-positions[0]] + positions + [2 * l - positions[-1]]
distance = 0
for i in range(n + 1):
	distance = max(distance, positions[i + 1] - positions[i])
print('%.10f' % (distance / 2))


(n, le) = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
l = -1
r = 10 ** 9 + 10 ** 5
for i in range(1000):
	m = (r + l) / 2
	fail = False
	for i in range(len(a) - 1):
		if not a[i] + 2 * m >= a[i + 1]:
			fail = True
			break
	if not fail:
		r = m
	else:
		l = m
print(max(min(a), le - max(a), (l + r) / 2))


(n, l) = [int(elem) for elem in input().split()]
a = sorted([int(elem) for elem in input().split()])
rad = a[0]
for i in range(1, n):
	if rad < (a[i] - a[i - 1]) / 2:
		rad = (a[i] - a[i - 1]) / 2
print(max(rad, l - a[n - 1]))


(n, d) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
diff = 0
for i in range(1, n):
	diff = max(a[i] - a[i - 1], diff)
left = a[0]
right = abs(d - a[-1])
val = max(left, right)
if val > diff / 2:
	print(val)
else:
	print(diff / 2)


a = (int(x) for x in input().split())
next(a)
l = next(a)
ma = 0
f = sorted([int(x) for x in input().split()])
for i in range(len(f) - 1):
	a = f[i + 1] - f[i]
	if a > ma:
		ma = a
if f[0] * 2 > ma:
	ma = f[0] * 2
if (l - f[-1]) * 2 > ma:
	ma = (l - f[-1]) * 2
print(ma / 2)


(n, l) = [int(x) for x in input().split()]
p = [int(y) for y in input().split()]
p = sorted(p)
q = []
for i in range(n - 1):
	q.append(p[i + 1] - p[i])
q.append(l - p[-1])
q = sorted(q)
if 0 in p:
	print('%.10f' % max(q[-1] / 2, l - p[-1]))
else:
	print('%.10f' % max(q[-1] / 2, p[0], l - p[-1]))


l = [int(x) for x in input().split()][1]
a = [int(x) for x in input().split()]
a = sorted(a)
delt = 0
for i in range(len(a) - 1):
	n = abs(a[i] - a[i + 1])
	if n > delt:
		delt = n
if abs(0 - a[0]) * 2 > delt:
	delt = abs(0 - a[0]) * 2
if abs(a[-1] - l) * 2 > delt:
	delt = abs(a[-1] - l) * 2
print(delt / 2)


(n, l) = [int(i) for i in input().split()]
lan = [int(i) for i in input().split()]
lan.sort()
ra = [lan[0], l - lan[n - 1]]
for i in range(n - 1):
	ra.append(0.5 * (lan[i + 1] - lan[i]))
print('%10f' % max(ra))


(n, l) = (int(x) for x in input().split())
lst = [int(x) for x in input().split()]
lst.sort()
m = 0
for i in range(n - 1):
	if lst[i + 1] - lst[i] > m:
		m = lst[i + 1] - lst[i]
m /= 2
if lst[0] > m or l - lst[-1] > m:
	m = max(lst[0], l - lst[-1])
print(m / 1)


s = input()
s = s.split()
n = int(s[0])
l = int(s[1])
s = input()
max = 0
s = s.split()
a = []
for i in range(0, n):
	a.append(int(s[i]))
a.sort()
for i in range(1, n):
	if a[i] - a[i - 1] > max:
		max = a[i] - a[i - 1]
max = max / 2
if a[0] >= max and a[0] >= l - a[n - 1]:
	print(a[0])
elif l - a[n - 1] >= max and l - a[n - 1] >= a[0]:
	print(l - a[n - 1])
else:
	print(max)


(n, l) = [int(x) for x in input().split()]
arr = list(map(int, input().split()))
radius = 0
arr.sort()
arr.extend([-arr[0], l - arr[-1] + l])
arr.sort()
for i in range(n + 1):
	if arr[i + 1] - arr[i] > radius * 2:
		radius = (arr[i + 1] - arr[i]) / 2
print(radius)


(n, l) = list(map(int, input().split()))
lantern_positions = list(map(int, input().split()))
lantern_positions.sort()
if n == 1:
	print(max(lantern_positions[0], l - lantern_positions[0]))
else:
	largest_dist = max(lantern_positions[0], l - lantern_positions[n - 1])
	for i in range(1, n):
		dist = (lantern_positions[i] - lantern_positions[i - 1]) / 2
		largest_dist = max(largest_dist, dist)
	print(largest_dist)


import sys
f = lambda : map(int, input().split())
(n, l) = f()
s = sorted(f())
print(max([s[0], l - s[n - 1]] + [(number_2 - number_1) / 2 for (number_1, number_2) in zip(s, s[1:])]))


li = list(map(int, input().split(' ')))
n = li[0]
l = li[1]
b = list()
maximum = 0
f = 0
g = 0
f1 = 0
g1 = 0
a = list(map(int, input().split(' ')))
a.sort()
for i in range(0, n):
	if i != n - 1:
		dist = a[i + 1] - a[i]
		if dist > maximum:
			maximum = dist
	if a[i] == 0:
		f = 1
	if a[i] == l:
		g = 1
if f == 0:
	f1 = a[0]
if g == 0:
	g1 = l - a[n - 1]
print(max(maximum / 2, f1, g1))


(n, l) = map(int, input().split())
ls = sorted(list(map(int, input().split())))
a = 0
b = max(ls[0], max(l - ls[-1], 0), max((ls[i] - ls[i - 1] for i in range(1, n))) if n > 1 else 0)
while b - a > 1e-10 * (b + a):
	mid = (a + b) / 2
	st = ls[0] - mid
	end = ls[0] + mid
	valid = True
	mi = st
	ma = end
	if mi > 0:
		valid = False
	if valid:
		for i in range(1, n):
			nst = ls[i] - mid
			nend = ls[i] + mid
			if nst > ma:
				valid = False
				break
			else:
				ma = nend
	if ma < l:
		valid = False
	if valid:
		b = mid
	else:
		a = mid
print((a + b) / 2)


s = input()
s = s.split()
n = int(s[0])
l = int(s[1])
a = input()
a = a.split()
diff = 0
for i in range(0, n):
	a[i] = int(a[i])
a.sort()
for i in range(0, n - 1):
	x = a[i + 1] - a[i]
	if x > diff:
		diff = x
d = diff / 2
if d < a[0]:
	d = a[0]
if d < l - a[n - 1]:
	d = l - a[n - 1]
print(format(d, '.10f'))


import math
s = input()
l1 = s.split(' ')
n1 = int(l1[0])
n2 = int(l1[1])
s1 = input()
l2 = s1.split(' ')
l3 = []
for x in range(len(l2)):
	l2[x] = int(l2[x])
l2.sort()
for x in range(len(l2) - 1):
	l3.append(int(l2[x + 1]) - int(l2[x]))
a = l2[0] - 0
b = n2 - l2[len(l2) - 1]
if len(l3) == 0:
	c = 0
else:
	c = max(l3)
print(max(c / 2, max(a, b)))


(n, l) = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
arr = set(arr)
arr = list(arr)
arr.sort()
m = -1
for x in range(0, len(arr) - 1):
	t = arr[x + 1] - arr[x]
	m = t if m < t else m
m = 2 * arr[0] if m < 2 * arr[0] else m
m = 2 * (l - arr[-1]) if m < 2 * (l - arr[-1]) else m
print('%.10f' % (m / 2))


(n, L) = map(int, input().split())
arr = [int(x) for x in input().split()]
arr.sort()
x = arr[0] - 0
y = L - arr[-1]
r = max(x, y) * 2
for i in range(1, n):
	r = max(r, arr[i] - arr[i - 1])
print(format(r / 2, '.12f'))


(n, m) = map(int, input().split())
lis = sorted(map(int, input().split()))
dif = 0
for i in range(1, n):
	if lis[i] - lis[i - 1] > dif:
		dif = lis[i] - lis[i - 1]
ans = max(dif / 2, lis[0], m - lis[-1])
print(ans)


(n, l) = [int(x) for x in input().split()]
t = list(set([int(x) for x in input().split()]))
t = sorted(t)
d = 0
prev = 0
for i in t:
	if i - prev > d:
		d = i - prev
	prev = i
if t[0] > d / 2:
	if l - t[-1] > t[0]:
		print(l - t[-1])
	else:
		print(t[0])
elif l - t[-1] > d / 2:
	print(l - t[-1])
else:
	print(d / 2)


(n, l) = map(int, input().split())
A = [int(i) for i in input().split()]
A.sort()
L = []
L.append(A[0])
for i in range(len(A) - 1):
	L.append((A[i + 1] - A[i]) / 2)
L.append(l - A[-1])
print(max(L))


(n, l) = map(int, input().split())
L = sorted(map(int, input().split()))
ma = 2 * max(L[0] - 0, l - L[n - 1])
for i in range(1, n):
	ma = max(ma, L[i] - L[i - 1])
print(ma / 2)


(n, l) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort()
maxdif = a[0] * 2
for i in range(1, n):
	if a[i] - a[i - 1] > maxdif:
		maxdif = a[i] - a[i - 1]
if l - a[n - 1] > maxdif / 2:
	print(l - a[n - 1])
else:
	print(maxdif / 2)


def min_lantern_radius(info, locations):
	n = info[0]
	locations.sort()
	min_radius = locations[0]
	for i in range(1, n):
		current_radius = (locations[i] - locations[i - 1]) / 2
		if current_radius > min_radius:
			min_radius = current_radius
	current_radius = info[1] - locations[n - 1]
	if current_radius > min_radius:
		min_radius = current_radius
	return min_radius

def read_input():
	info = [int(x) for x in input().split(' ')]
	locations = [int(x) for x in input().split(' ')]
	return (info, locations)
(test_info, test_locations) = read_input()
print(min_lantern_radius(test_info, test_locations))


def main():
	(n, l) = map(int, input().split(' '))
	lamps = list(set(map(int, input().split(' '))))
	lamps.sort()
	largest_gap = -1
	gap_index = 0
	for i in range(1, len(lamps)):
		curr_gap = lamps[i] - lamps[i - 1]
		if curr_gap > largest_gap:
			largest_gap = curr_gap
			gap_index = i
	left_gap = lamps[0]
	right_gap = l - lamps[-1]
	largest_gap /= 2
	ans = left_gap if left_gap > right_gap else right_gap
	ans = ans if ans > largest_gap else largest_gap
	print(ans)
main()


(n, l) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort()
b = []
if n == 1:
	print('%.10f' % max(l - a[0], a[0]))
	exit()
for i in range(n - 1):
	b.append(a[i + 1] - a[i])
result = max(b) / 2.0
if a[0] > result:
	result = a[0]
if l - a[-1] > result:
	result = l - a[-1]
print('%.10f' % result)


line = input().split()
n = int(line[0])
l = int(line[1])
s = [int(a) for a in input().split()]
s.sort()
first = s[0]
last = l - s[-1]
i = 1
CNT = []
if len(s) > 1:
	while i < len(s):
		cnt = s[i] - s[i - 1]
		CNT.append(cnt)
		i = i + 1
	CNT.sort()
	m = CNT[-1] / 2
	ff = max(m, first, last)
	print(float(ff))
else:
	ff = max(first, last)
	print(ff)


def inlt():
	return list(map(int, input().split()))

def invr():
	return map(int, input().split())
(n, l) = invr()
tab = inlt()
tab.sort()
maks = 0
for i in range(n - 1):
	maks = max(maks, tab[i + 1] - tab[i])
wyn = maks / 2
maks = float(max(wyn, tab[0], l - tab[n - 1]))
maks = format(maks, '.10f')
print(maks)
print()


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
_max = max(a[0] - 0, l - a[n - 1])
for i in range(n - 1):
	temp = abs(a[i] - a[i + 1]) / 2
	_max = max(temp, _max)
print(_max)


(n, k) = map(int, input().split())
l = [*map(int, input().split())]
l.sort()
maxdist = 0
for i in range(n - 1):
	if l[i + 1] - l[i] > maxdist:
		maxdist = l[i + 1] - l[i]
print(max(maxdist / 2, max(l[0] - 0, k - l[n - 1])))


def Vanya():
	(n, l) = list(map(int, input().split()))
	a = list(map(int, input().split()))
	a = sorted(a)
	max_d = 0
	for i in range(len(a) - 1):
		if a[i + 1] - a[i] > max_d:
			max_d = a[i + 1] - a[i]
	print(max(max_d / 2, max(a[0], l - a[-1])))
Vanya()


(n, m) = map(int, input().split())
c = list(map(int, input().split()))
c = sorted(c)
maxim = max(float(c[0]), m - float(c[-1]))
for i in range(1, len(c)):
	r = (c[i] - c[i - 1]) / 2
	if r > maxim:
		maxim = r
print(maxim)


(n, l) = [int(i) for i in input().split(' ')]
ds = [int(i) for i in input().split(' ')]
ds.sort()
longest = -1
for d in range(1, len(ds)):
	longest = max(ds[d] - ds[d - 1], longest)
longest = float(float(round(longest, 9)) / 2)
if ds[0] != 0:
	longest = max(ds[0] - 0, longest)
if ds[len(ds) - 1] != l:
	longest = max(l - ds[len(ds) - 1], longest)
print(longest)


(n, l) = map(int, input().split())
m = list(map(int, input().split()))
m.sort()
k = 2 * m[0]
j = 2 * (l - m[n - 1])
for i in range(1, n):
	if m[i] - m[i - 1] > k:
		k = m[i] - m[i - 1]
if k > j:
	print(k / 2)
else:
	print(j / 2)


(n, k) = map(int, input().split(' '))
a = sorted([int(i) for i in input().split(' ')])
d = a[0]
for x in range(len(a) - 1):
	if d < (a[x + 1] - a[x]) / 2:
		d = (a[x + 1] - a[x]) / 2
if d < k - a[len(a) - 1]:
	d = k - a[len(a) - 1]
print('%.10f' % d)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
m = 0
i = 0
for i in range(len(a) - 1):
	if a[i + 1] - a[i] > m:
		m = a[i + 1] - a[i]
m = max(a[i] - a[-1], m)
x = max(a[0] / 1, m / 2)
y = max((k - a[-1]) / 1, m / 2)
print(max(m / 2, x, y))


(a, b) = input().split()
c = input().split(maxsplit=int(a) - 1)
c = [int(i) for i in c]
c = sorted(c)
d = []
min = c[0]
max = c[-1]
for i in range(len(c) - 1):
	d.append(c[i + 1] - c[i])
if 0 not in c:
	d.append(min * 2)
if int(b) not in c:
	d.append(2 * (int(b) - max))
d = sorted(d)
print('{:.10f}'.format(d[-1] / 2))


a = list(input().split())
n = int(a[0])
l = int(a[1])
b = list(input().split())
c = []
for i in range(n):
	c.append(int(b[i]))
d = []
c = sorted(c)
d.append(c[0] - 0)
d.append(l - c[n - 1])
k = 0
for i in range(n - 1):
	if k < c[i + 1] - c[i]:
		k = c[i + 1] - c[i]
if k / 2 > max(d):
	print(k / 2)
else:
	print(float(max(d)))


import sys

def write_to_stdout(d):
	sys.stdout.write('%f\n' % d)

def read_input():
	(n, l) = input().rstrip().split()
	coordinates = input().rstrip().split()
	return (int(n), int(l), [int(i) for i in coordinates])

def find_d(coordinates, l, n):
	max_dist = max(coordinates[0], l - coordinates[-1])
	for i in range(1, n):
		temp_dist = (coordinates[i] - coordinates[i - 1]) / 2
		if temp_dist > max_dist:
			max_dist = temp_dist
	return max_dist

def main():
	(n, l, coordinates) = read_input()
	coordinates = sorted(coordinates)
	d = find_d(coordinates, l, n)
	write_to_stdout(d)
main()


from decimal import Decimal
(n, l) = [int(i) for i in input().split()]
a = sorted([int(i) for i in input().split()])
ma = 2 * (a[0] - 0)
for i in range(n - 1):
	if a[i + 1] - a[i] > ma:
		ma = a[i + 1] - a[i]
ma = max(ma, 2 * (l - a[-1]))
print(round(Decimal(ma) / Decimal(2), 10))


(n, l) = map(int, input().split())
s = list(map(int, input().split()))
s.sort()
z = list()
if 0 not in s:
	z.append(s[0])
if l not in s:
	z.append(l - s[n - 1])
for i in range(n - 1):
	z.append((s[i + 1] - s[i]) / 2)
print(max(z))


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
m = max(min(a), l - max(a))
for i in range(n - 1):
	r = abs(a[i + 1] - a[i])
	if r / 2 > m:
		m = r / 2
print(m)


from collections import Counter
inp = list(map(int, input().split()))
t = inp[1]
inp = list(map(int, input().split()))
c = Counter(inp)
l = list(c.keys())
l.sort()
ans = l[0] - 0
for i in range(len(l) - 1):
	if l[i] + ans < l[i + 1] - ans:
		ans = (l[i + 1] - l[i]) / 2
if l[-1] + ans < t:
	ans = t - l[-1]
print(ans)


(n, l) = map(int, input().split())
ai = list(map(int, input().split()))
for i in range(n):
	for j in range(0, n - i - 1):
		if ai[j + 1] < ai[j]:
			t = ai[j]
			ai[j] = ai[j + 1]
			ai[j + 1] = t
dif = ai[0] - 0
if l - ai[n - 1] > dif:
	dif = l - ai[n - 1]
for i in range(n - 1):
	d = (ai[i + 1] - ai[i]) / 2
	if d > dif:
		dif = d
r = dif
print(round(r, 10))


(n, l) = map(int, input().split())
loc = list(map(int, input().split()))
loc.sort()
maxd = 0
if loc[0] != 0:
	maxd = max(maxd, 2 * loc[0])
if loc[-1] != l:
	maxd = max(maxd, 2 * (l - loc[-1]))
for i in range(n - 1):
	maxd = max(maxd, loc[i + 1] - loc[i])
print(maxd / 2)


(n, l) = map(int, input().split())
ll = list(map(int, input().split()))
ll = sorted(ll)
javob = []
for i in range(n):
	if i == 0:
		if i == n - 1:
			javob.append(max(ll[0] / 1, (l - ll[0]) / 1))
		else:
			javob.append(max(ll[0] / 1, (ll[1] - ll[0]) / 2))
	elif i == n - 1:
		javob.append((l - ll[i]) / 1)
	else:
		javob.append((ll[i + 1] - ll[i]) / 2)
print(str(max(javob)) + '000000000')


(n, sz) = map(int, input().split())
pos = sorted(map(int, input().split()))
pos = [-pos[0]] + pos + [sz + sz - pos[-1]]
res = 0
for i in range(1, n + 2):
	d = pos[i] - pos[i - 1]
	if d > res:
		res = d
print(res / 2)


def Main():
	(n, l) = map(int, input().split())
	lamps = list(map(int, input().split()))
	lamps.sort()
	min_d = 0.0
	for i in range(n - 1):
		if min_d < (lamps[i + 1] - lamps[i]) / 2:
			min_d = (lamps[i + 1] - lamps[i]) / 2
	if min_d < lamps[0] - 0:
		min_d = lamps[0] - 0
	if min_d < l - lamps[n - 1]:
		min_d = l - lamps[n - 1]
	print(min_d)
Main()


(n, l) = map(int, input().split())
m = []
m = list(map(int, input().split()))
m.sort()
dif = 0
f = 0
g = 0
if m[0] != 0:
	f = m[0] - 0
if m[n - 1] != l:
	g = l - m[n - 1]
if f > g:
	dif = f * 2
else:
	dif = g * 2
for i in range(0, n - 1):
	f = m[i + 1] - m[i]
	if f > dif:
		dif = f
print(dif / 2)


(n, l) = map(int, str(input()).split())
a = list(map(int, str(input()).split()))
diff = []
a.sort()
maxd = 0
maxd1 = 0
maxd2 = 0
for i in range(0, len(a) - 1):
	diff.append(a[i + 1] - a[i])
if len(a) == 1:
	diff.append(a[0])
maxd = float(max(diff) / 2)
if a[0] != 0 and a[0] > maxd:
	maxd1 = a[0]
if a[n - 1] != l and l - a[n - 1] > maxd:
	maxd2 = l - a[n - 1]
print(max(maxd, maxd1, maxd2))


(n, m) = map(int, input().split())
ar = list(map(int, input().split()))
ar.sort()
md = -1
for x in range(n - 1):
	if ar[x + 1] - ar[x] > md:
		md = ar[x + 1] - ar[x]
print('%.10f' % max(ar[0], m - ar[n - 1], md / 2))


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
mx = 0
for i in range(1, n):
	temp = a[i] - a[i - 1]
	mx = max(temp, mx)
print(max(mx / 2, a[0] - 0, l - a[n - 1]))


(ik, dl) = input().split(' ')
lt = [int(l) for l in input().split(' ')]
max_odl = 0
lt = sorted(lt)
max_odl = 0
for i in range(1, len(lt)):
	if lt[i] - lt[i - 1] > max_odl:
		max_odl = lt[i] - lt[i - 1]
max_odl = max_odl / 2
if max_odl < lt[0]:
	max_odl = lt[0]
if max_odl < int(dl) - lt[-1]:
	max_odl = int(dl) - lt[-1]
print('{0:9f}'.format(max_odl))


(n, ls) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
d = a[0]
for i in range(1, n):
	if (a[i] - a[i - 1]) / 2 > d:
		d = (a[i] - a[i - 1]) / 2
if ls - a[-1] > d:
	d = ls - a[-1]
print(d)


(n, l) = map(int, input().split())
lanterns = list(map(int, input().split()))
lantern_at_zero = False
lantern_at_last = False
lanterns.sort()
if lanterns[0] == 0:
	lantern_at_zero = True
else:
	dist_from_zero = float(lanterns[0])
if lanterns[n - 1] == l:
	lantern_at_last = True
else:
	dist_from_last = float(l - lanterns[n - 1])
max_gap = 0
for i in range(0, n - 1):
	gap = lanterns[i + 1] - lanterns[i]
	if gap > max_gap:
		max_gap = float(gap)
if lantern_at_zero and lantern_at_last:
	print(max_gap / 2)
else:
	max_gap = float(max_gap / 2)
	if lantern_at_zero == True and lantern_at_last == False:
		max_gap = max(max_gap, dist_from_last)
		print(max_gap)
	elif lantern_at_zero == False and lantern_at_last == True:
		max_gap = max(max_gap, dist_from_zero)
		print(max_gap)
	else:
		max_gap = max(max_gap, dist_from_zero, dist_from_last)
		print(max_gap)


(n, l) = [int(i) for i in input().split()]
coords = sorted([int(i) for i in input().split()])
max = max(coords[0], l - coords[-1])
for i in range(1, len(coords)):
	if max < (coords[i] - coords[i - 1]) / 2:
		max = (coords[i] - coords[i - 1]) / 2
print(max)


(n, l) = map(int, input().split())
arr = sorted(list(map(int, input().split())))
mx = -1
for i in range(n - 1):
	x = arr[i + 1] - arr[i]
	if x > mx:
		mx = x
mx = mx / 2
mx2 = -1
if arr[0] != 0:
	mx2 = arr[0] - 0
mx3 = -1
if arr[-1] != n:
	mx3 = l - arr[-1]
res = max(mx, mx2, mx3)
print('%.10f' % res)


(n, l) = map(int, input().rstrip().split())
loc = list(map(int, input().rstrip().split()))
loc = sorted(loc)
dist = max(loc[0], l - loc[-1])
for i in range(n - 1):
	temp = (loc[i + 1] - loc[i]) / 2
	dist = max(dist, temp)
print(dist)


(n, l) = map(int, input().split())
lampe = list(map(int, input().split()))
lampe.sort()
piz = max(lampe[0], l - lampe[-1])
najrazlika = 0
for i in range(n - 1):
	razlika = lampe[i + 1] - lampe[i]
	najrazlika = max(razlika, najrazlika)
print(max(float(najrazlika / 2), piz))


(n, l) = map(int, input().split())
DistF = list(map(int, input().split()))
d = -1
SortDistF = sorted(DistF)
SortDistF.append(l)
SortDistF.insert(0, 0)
d = max(abs(SortDistF[0] - SortDistF[1]), abs(SortDistF[-2] - SortDistF[-1]))
for i in range(len(SortDistF) - 1):
	if abs(SortDistF[i] - SortDistF[i + 1]) > 2 * d:
		d = max(abs(SortDistF[i] - SortDistF[i + 1]) / 2, d)
print(d)


(n, l) = map(int, input().split())
a = sorted(map(int, input().split()))
print(max(n - 1 and max((j - i for (i, j) in zip(a, a[1:]))) / 2, a[0], l - a[-1]))


(n, l) = input().split(' ')
lanterns = [int(p) for p in input().split()]
lanterns.sort()
curr = 0
high = 0
temp = 0
temp = lanterns[0]
if temp > high:
	high = temp
for lantern in lanterns:
	temp = abs(lantern - curr) / 2
	if temp > high:
		high = temp
	curr = lantern
temp = int(l) - lanterns[-1]
if temp > high:
	high = temp
print(high)


(n, l) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
a.sort()
distance = -1
for i in range(n):
	if i == n - 1:
		pass
	else:
		distance = max(distance, a[i + 1] - a[i])
distance0 = a[0] - 0
distance1 = l - a[-1]
print(max(distance / 2, distance1, distance0))


(n, m) = map(int, input().split(' '))
pos = list(map(int, input().split(' ')))
pos.sort()
maxdif = pos[0] * 2
for i in range(1, n):
	if pos[i] - pos[i - 1] > maxdif:
		maxdif = pos[i] - pos[i - 1]
if m - pos[n - 1] > maxdif / 2:
	print(m - pos[n - 1])
else:
	print(maxdif / 2)


def check(arr, d, l):
	new = [0] + arr + [l]
	if new[1] - new[0] > d:
		return False
	if new[-1] - new[-2] > d:
		return False
	for i in range(len(new) - 1):
		if new[i + 1] - new[i] > 2 * d:
			return False
	return True
(n, l) = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.sort()
low = 0
high = l
while high - low > 10 ** (-6):
	mid = (high + low) / 2
	if check(arr, mid, l):
		high = mid
	else:
		low = mid
print(round(low, 2))


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
dister = max(a[0], l - a[-1])
tester = max([(a[i + 1] - a[i]) / 2 for i in range(n - 1)], default=dister)
dister = max(dister, tester)
dister = '{:.10f}'.format(dister)
print(dister)


import sys

def main():
	(n, l) = map(int, sys.stdin.readline().split(' '))
	a = sorted(list(map(int, sys.stdin.readline().split(' '))))
	m = a[0] * 2
	m = max(m, (l - a[n - 1]) * 2)
	for i in range(1, n):
		m = max(m, a[i] - a[i - 1])
	sys.stdout.write('{:0.10f}\n'.format(float(m) / 2.0))
main()


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
max = float(a[0])
for i in range(1, n):
	m = (a[i] - a[i - 1]) / 2
	if max < m:
		max = m
m = l - a[-1]
if max < m:
	max = m
print(max)


(l, s) = map(int, input().split())
road = list(map(int, input().split()))
road.sort()
d = 0
for i in range(1, l):
	if d < road[i] - road[i - 1]:
		d = road[i] - road[i - 1]
d = d / 2.0
d = max(road[0] - 0, s - road[-1], d)
print(d)


R = lambda : map(int, input().split())
(n, l) = R()
lights = sorted(list(R()))
lights_2 = [0] + lights + [l]
res = [[lights_2[i], lights_2[i + 1]] for i in range(n + 2 - 1)]
MAX = [[0, 0], 0]
for pair in res:
	if pair[0] not in lights or pair[1] not in lights:
		if abs(pair[0] - pair[1]) > MAX[1]:
			MAX = [pair, abs(pair[0] - pair[1])]
	elif abs(pair[0] - pair[1]) / 2 > MAX[1]:
		MAX = [pair, abs(pair[0] - pair[1]) / 2]
print(MAX[1])


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr = sorted(arr)
mL = (arr[0] - 0) * 2
for i in range(1, n):
	mL = max(mL, arr[i] - arr[i - 1])
mL = max(mL, (l - arr[n - 1]) * 2)
print('%.10f' % (mL / 2))


(n, l) = [int(n) for n in input().split()]
a = [int(n) for n in input().split()]
a.sort()
if 0 in a:
	d = a[0] / 2
else:
	d = a[0]
for i in range(1, n):
	if (a[i] - a[i - 1]) / 2 > d:
		d = float((a[i] - a[i - 1]) / 2)
if l in a and (l - a[n - 1]) / 2 > d:
	d = float((l - a[n - 1]) / 2)
elif l - a[n - 1] > d:
	d = l - a[n - 1]
print('%.8f' % d)


(n, l) = map(int, input().split())
s = list(map(int, input().split()))
s.sort()
maxD = 0
for (i, j) in zip(s, s[1:]):
	maxD = max(maxD, j - i)
maxD = max(float(maxD / 2), float(s[0]), float(l - s[n - 1]))
print(maxD)


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().strip().split())))
result = 0
if a[0] != 0:
	result = a[0]
if a[-1] != l:
	result = max(l - a[-1], result)
for i in range(n - 1):
	result = max(result, (a[i + 1] - a[i]) / 2)
print(result)


A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
B.sort(reverse=False)
C = max(B[0], A[1] - B[-1])
for x in range(1, A[0]):
	d = (B[x] - B[x - 1]) / 2
	if d > C:
		C = d
print(C)


(n, d) = list(map(int, input().split()))
lantern = list(map(int, input().split()))
lantern.sort()
tmp = []
if len(lantern) == 1:
	print(max(lantern[0] - 0, d - lantern[0]))
else:
	for i in range(len(lantern) - 1):
		tmp.append(lantern[i + 1] - lantern[i])
	print(max(max(tmp) / 2, lantern[0] - 0, d - lantern[-1]))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
b = []
if n == 1:
	r = max(a[0], l - a[0])
else:
	for i in range(n - 1):
		b.append(a[i + 1] - a[i])
	m = max(b)
	s = m / 2
	r = max(s, a[0], l - a[-1])
print('%.10f' % r)


from sys import stdin
import math
inp = lambda : stdin.readline().strip()
(n, l) = [int(x) for x in inp().split()]
a = [int(x) for x in inp().split()]
a.sort()
k = max(a[0], l - a[n - 1])
lon = -1
for i in range(1, n):
	lon = max(lon, a[i] - a[i - 1])
lon = max(lon, l - a[n - 1])
if k > lon / 2:
	print(k)
else:
	print(lon / 2)


def main():
	(n, l) = input().split(' ')
	n = int(n)
	l = int(l)
	coords = input().split(' ')
	coords = [float(c) for c in coords]
	coords.sort()
	if len(coords) < 2:
		d = 0
	else:
		d = max([coords[n] - coords[n - 1] for n in range(1, len(coords))]) / 2
	print(max([d, coords[0], l - coords[-1]]))
main()


(n, l) = [int(_) for _ in input().split()]
a = [int(_) for _ in input().split()]
dp = []
if 0 not in a:
	a.append(-min(a))
if l not in a:
	a.append(l - max(a) + l)
a.sort()
for i in range(len(a) - 1):
	dp.append(abs(a[i] - a[i + 1]) / 2)
print(max(dp))


(n, l) = map(int, input(' ').split())
x = list(map(int, input(' ').split()))
x.sort()
dist = 0
for i in range(1, n):
	t = x[i] - x[i - 1]
	if t > dist:
		dist = t
dist = max(dist / 2, x[0], l - x[n - 1])
print(dist)


arr = [int(x) for x in input().split(' ')]
(n, l) = (arr[0], arr[1])
a = [int(x) for x in input().split(' ')]
a.sort()
guess = 2 * max(a[0], l - a[n - 1])
for i in range(n - 1):
	guess = max(guess, a[i + 1] - a[i])
print(guess / 2)


(n, l) = map(int, input().split())
lanterns = list(map(int, input().split()))
lantern = sorted(lanterns)
mx = -9999999999
mx = max(lantern[0], l - lantern[-1])
for i in range(0, n - 1):
	mx = max(mx, (lantern[i + 1] - lantern[i]) / 2)
print('%.10f' % mx)


t = list(map(int, input().split(' ')))
lanterns = list(map(float, input().split(' ')))
length = t[0]
num = t[1]
d = 0.0
x = float('{:.9f}'.format(d))

def BubbleSort(lst):
	is_sorted = True
	while is_sorted:
		is_sorted = False
		for i in range(len(lst) - 1):
			if lst[i] > lst[i + 1]:
				temp = lst[i]
				lst[i] = lst[i + 1]
				lst[i + 1] = temp
				is_sorted = True
	return lst
if length != 1:
	arr = BubbleSort(lanterns)
	if d < arr[0] - 0:
		d = arr[0] - 0
	if d < num - arr[-1]:
		d = num - arr[-1]
	diff = []
	for i in range(1, length):
		diff.append(arr[i] - arr[i - 1])
	diff_sorted = BubbleSort(diff)
	if d < diff_sorted[-1] / 2:
		d = diff_sorted[-1] / 2
else:
	if d < lanterns[0] - 0:
		d = lanterns[0] - 0
	if d < num - lanterns[-1]:
		d = num - lanterns[-1]
print('{:.10f}'.format(d))


g = input()
(N, length) = [int(x) for x in g.split()]
r = input()
listing = []
for x in r.split():
	listing.append(int(x))
listing = sorted(listing)
minimum = max(listing[0] - 0, length - listing[N - 1])
for i in range(N - 1):
	d = listing[i + 1] - listing[i]
	if d / 2 > minimum:
		minimum = d / 2
print(minimum)


(n, l) = map(int, input().split())
ns = list(sorted(set(map(int, input().split()))))
if len(ns) == 1:
	print(max(l - ns[0], ns[0]))
	exit()
fs = []
for x in range(1, len(ns)):
	a = ns[x] - ns[x - 1]
	fs.append(a)
ans = max(ns[0], l - ns[-1], max(fs) / 2)
print('%.9f' % ans)


lightandlen = input()
lightandlen = [int(n) for n in lightandlen.split()]
seq = input()
a = [int(n) for n in seq.split()]
light = lightandlen[0]
leng = lightandlen[1]
a.sort()
b = [None] * (light - 1)
for i in range(light - 1):
	b[i] = a[i + 1] - a[i]
if light == 1:
	ans = leng
else:
	ans = max(b)
realans = round(ans / 2, 10)
if realans < a[0] - 0:
	realans = a[0] - 0
if realans < abs(a[light - 1] - leng):
	realans = abs(a[light - 1] - leng)
print(realans)


(n, l) = list(map(int, input().split()))
lst = list(map(int, input().split()))
lst = sorted(lst)
maxx = -1
for i in range(n - 1):
	maxx = max(maxx, lst[i + 1] - lst[i])
ans = maxx / 2
if lst[0] != 0:
	ans = max(lst[0], ans)
if lst[-1] != l:
	ans = max(ans, l - lst[-1])
print(format(ans, '.10f'))


(n, l) = map(int, input().split())
d = [int(i) for i in input().split()]
d = list(set(d))
d.sort()
dd = [2 * (d[0] - 0), 2 * (l - d[len(d) - 1])]
for i in range(len(d) - 1):
	dd.append(d[i + 1] - d[i])
dd.sort()
print(dd[len(dd) - 1] / 2)


(n, m) = map(int, input().split())
l = list(map(float, input().split()))
l.sort()
l1 = []
l1.append(l[0] - 0)
l1.append(m - l[n - 1])
ma = 0
for i in range(len(l) - 1):
	if ma < l[i + 1] - l[i]:
		ma = l[i + 1] - l[i]
l1.append(ma / 2)
print(max(l1))


(n, l) = map(int, input().split())
f = list(map(int, input().split()))
f.sort()
maxx1 = f[0] * 2
maxx2 = (l - f[-1]) * 2
maxx = 0
last = 0
for i in f:
	if i - last > maxx:
		maxx = i - last
	last = i
print(max(maxx1, maxx2, maxx) / 2)


import math
import sys
from collections import Counter
(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
m = []
ans = 0
for i in range(0, n - 1):
	ans = max((a[i + 1] - a[i]) / 2, ans)
q = a[0] - 0
w = l - a[n - 1]
y = max(ans, a[0], l - a[n - 1])
print(y)


(l, n) = map(int, input().split())
a = [int(i) for i in input().split()]
b = []
a.sort()
d1 = a[0] - 0
d2 = n - a[l - 1]
for i in range(l - 1):
	k = a[i + 1] - a[i]
	b.append(k / 2)
m = -1
if len(b) != 0:
	m = max(b)
ans = max(m, d1, d2)
print(ans)


(n, l) = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
B = [0 for i in range(len(A) + 1)]
B[0] = A[0]
B[-1] = l - A[-1]
for i in range(1, len(B) - 1):
	B[i] = (A[i] - A[i - 1]) / 2
t = str(max(B))
a = [0 for i in range(2)]
r = list(map(str, t.split('.')))
if len(r) == 2:
	a[0] = r[0]
	a[1] = r[1]
	a[1] += '000000000'
else:
	a[0] = r[0]
	a[1] = '0000000000'
print('.'.join(a))


(n, L) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
top = max(L - a[n - 1], a[0])
for i in range(n - 1):
	if (a[i + 1] - a[i]) / 2 > top:
		top = (a[i + 1] - a[i]) / 2
print(top)


(n, l) = map(int, input().split())
lights = sorted(map(int, input().split()))
ans = max(lights[0], l - lights[-1])
if len(lights) > 1:
	ans = max(ans, max(((lights[i + 1] - lights[i]) / 2 for i in range(n - 1))))
print(ans)


def main():
	(n, l) = map(int, input().split())
	a = list(map(int, input().split()))
	a.sort()
	d = 0
	for i in range(0, n - 1):
		if a[i + 1] - a[i] > d:
			d = a[i + 1] - a[i]
	print(round(max(d / 2, max(a[0] - 0, l - a[n - 1])), 10))
main()


(n, l) = map(int, input().split())
case = sorted(list(map(int, input().split())))
minr = max(case[0] - 0, l - case[n - 1])
for i in range(n - 1):
	minr = max(minr, (case[i + 1] - case[i]) / 2)
print(minr)


import bisect

def codeforces():
	(n, l) = map(int, input().split())
	lst = list(map(int, input().split()))
	lst_street = range(l + 1)
	lst.sort()
	res = 0
	if res < bisect.bisect(lst_street, lst[0]) - 1:
		res = bisect.bisect(lst_street, lst[0]) - 1
	for i in range(n - 1):
		index_1 = bisect.bisect(lst_street, lst[i]) - 1
		index_2 = bisect.bisect(lst_street, lst[i + 1]) - 1
		if res < (index_2 - index_1) / 2:
			res = (index_2 - index_1) / 2
	if res < lst_street[-1] - bisect.bisect(lst_street, lst[-1]) + 1:
		res = lst_street[-1] - bisect.bisect(lst_street, lst[-1]) + 1
	return res
print(codeforces())


def main():
	meta = list(map(int, input().split(' ')))
	light_count = meta[0]
	street_length = meta[1]
	light_points = list(map(int, input().split(' ')))
	light_points.sort()
	max = 0
	for i in range(light_count):
		if i == 0 and i == light_count - 1:
			if light_points[i] * 2 > street_length:
				max = light_points[i]
			else:
				max = street_length - light_points[i]
			continue
		if i == 0:
			max = light_points[i]
			continue
		if i == light_count - 1:
			if (light_points[i] - light_points[i - 1]) / 2 > max:
				max = (light_points[i] - light_points[i - 1]) / 2
			elif street_length - light_points[i] > max:
				max = street_length - light_points[i]
			continue
		if (light_points[i] - light_points[i - 1]) / 2 > max:
			max = (light_points[i] - light_points[i - 1]) / 2
			continue
	print(float(max))
main()


def search(llista, valor):
	esq = 0
	dr = len(llista) - 1
	i = (esq + dr) // 2
	while esq <= dr:
		if llista[i] == valor:
			return i
		elif valor > llista[i]:
			esq = i + 1
			i = (esq + dr) // 2
		else:
			dr = i - 1
			i = (esq + dr) // 2
	return None
s = input().split(' ')
(lanterns, length) = (int(s[0]), int(s[1]))
s = sorted([int(n) for n in input().split(' ')])
distances = []
distances.append(s[0] - 0)
for i in range(1, len(s)):
	distances.append((s[i] - s[i - 1]) / 2)
distances.append(length - s[-1])
print(max(distances))


(c, l) = map(int, input().split())
nums = list(map(int, input().split()))
nums.sort()
diff = []
for x in range(c - 1):
	diff.append(nums[x + 1] - nums[x])
ans = 0
if len(diff) > 0:
	ans = max(diff) / 2
ans = max(ans, nums[0], l - nums[-1])
print(ans)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
lower = a[0] - 0
upper = l - a[n - 1]
large = 0
for i in range(1, n):
	if large < a[i] - a[i - 1]:
		large = a[i] - a[i - 1]
d = max(large / 2, lower, upper)
print(d)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
r = 0
for i in range(n - 1):
	if a[i + 1] - a[i] > r:
		r = a[i + 1] - a[i]
print(max(min(a), r / 2, l - max(a)))


(n, l) = map(int, input().split())
lantern_location = [int(i) for i in input().split()]
lantern_location.sort()
highest_gap = 0
for i in range(len(lantern_location) - 1):
	if lantern_location[i + 1] - lantern_location[i] > highest_gap:
		highest_gap = lantern_location[i + 1] - lantern_location[i]
print(max(lantern_location[0], highest_gap / 2, l - lantern_location[len(lantern_location) - 1]))


(n, l) = map(int, input().split())
lanterns = [int(x) for x in input().split()]
lanterns.sort()
last = 0
res = 0
for x in lanterns:
	res = max(res, x - last)
	last = x
res = max(res / 2, lanterns[0])
res = max(res, l - lanterns[-1])
print(res)


(n, l) = map(int, input().split())
pos = list(map(int, input().split()))
pos = sorted(pos)
pos = sorted(pos)
coor = []
for i in range(n - 1):
	coor.append((pos[i + 1] - pos[i]) / 2)
if 0 not in pos:
	coor.append(pos[0])
if l not in pos:
	coor.append(l - pos[n - 1])
print(max(coor))


(n, l) = map(int, input().split())
lights = input().split()
for i in range(n):
	lights[i] = int(lights[i])
lights.sort()
maxi = lights[0]
for i in range(n - 1):
	inter = (lights[i + 1] - lights[i]) / 2
	if inter > maxi:
		maxi = inter
if l - lights[-1] > maxi:
	maxi = l - lights[-1]
print(maxi)


def rearrangement(a):
	out = []
	count = len(a)
	for i in range(0, count):
		d = min(a)
		out.append(d)
		a.remove(d)
	return out
l1 = [int(x) for x in input().split()]
l2 = rearrangement([int(x) for x in input().split()])
m = l2[0] * 2
for i in range(1, l1[0]):
	if l2[i] - l2[i - 1] > m:
		m = l2[i] - l2[i - 1]
if abs(l2[l1[0] - 1] - l1[1]) * 2 > m:
	m = abs(l2[l1[0] - 1] - l1[1]) * 2
print(m / 2)


(n, m) = map(int, input().split())
road = [int(i) for i in input().split()]
road.append(int(0))
road.append(int(m))
road.sort()
t = max(road[1] - road[0], road[n + 1] - road[n])
a = 0
for i in range(1, n + 1):
	t = max(t, float((road[i] - road[i - 1]) / 2))
a = '%.9f' % float(t)
print(a)


(n, l) = list(map(int, input().split()))
p = list(map(int, input().split()))
m = 0
p.sort()
for i in range(n - 1):
	m = max(m, p[i + 1] - p[i])
m = m / 2
if 0 not in p:
	m = max(p[0], m)
if l not in p:
	m = max(l - p[-1], m)
print('%.10f' % m)


line1 = input().split()
(n, l) = (int(line1[0]), int(line1[1]))
a = input().split()
a = sorted(list(map(int, a)))
f1 = 0
f2 = 0
b = []
if a[0] != 0:
	a.insert(0, 0)
	f1 = 1
if a[-1] != l:
	a.append(l)
	f2 = 1
for i in range(len(a) - 1):
	b.append(a[i + 1] - a[i])
l = abs(max(b))
if f1 == 1 and f2 == 1:
	c = max([abs(b[0]), l / 2, abs(b[-1])])
	f = f'{c:.10f}'
	print(f)
elif f1 == 1 and f2 == 0:
	c = max([abs(b[0]), l / 2])
	f = f'{c:.10f}'
	print(f)
elif f1 == 0 and f2 == 1:
	c = max([abs(b[-1]), l / 2])
	f = f'{c:.10f}'
	print(f)
else:
	f = f'{l / 2:.10f}'
	print(f)


def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())

def solve():
	(N, L) = getInts()
	A = getInts()
	A.sort()
	best = max(A[0], L - A[-1])
	for j in range(1, N):
		best = max(best, (A[j] - A[j - 1]) * 0.5)
	return best
ans = solve()
print(ans)


vals1 = input().split()
n = int(vals1[0])
l = int(vals1[1])
arr = input().split()
for i in range(len(arr)):
	arr[i] = int(arr[i])
arr.sort()
maximum = 2 * max(arr[0], l - arr[-1])
for i in range(1, len(arr)):
	if arr[i] - arr[i - 1] > maximum:
		maximum = arr[i] - arr[i - 1]
print(maximum / 2)


(n, l) = map(int, input().split())
mas = list(map(int, input().split()))
mas.sort()
max = mas[0]
for i in range(len(mas) - 1):
	if mas[i + 1] - mas[i] > max:
		max = mas[i + 1] - mas[i]
if max / 2 > mas[0] and max / 2 > l - mas[len(mas) - 1]:
	print(max / 2)
elif mas[0] > l - mas[len(mas) - 1]:
	print(mas[0])
else:
	print(l - mas[len(mas) - 1])


(n, k) = map(int, input().split())
lst = list(map(int, input().split()))
lst.sort()
(a, b, c, d, e) = (0, 0, 0, 0, 0)
maxi = 0
for i in range(n - 1):
	if maxi < lst[i + 1] - lst[i]:
		maxi = lst[i + 1] - lst[i]
d = max(maxi / 2, max(lst[0] - 0, k - lst[n - 1]))
print(d)


(n, l) = [int(o) for o in input().split()]
a = [int(o) for o in input().split()]
list1 = a
a.sort()
d = max(a[0], l - a[len(a) - 1])
dist = [(a[i] - a[i - 1]) / 2.0 for i in range(1, n)]
dist.append(d)
print(max(dist))


(n, l) = input().split()
n = int(n)
l = int(l)
lst = input().split()
lst = [int(i) for i in lst]
lst.sort()
max_d = 0
if l != 0:
	max_d = max(lst[0] - 0, max_d)
	max_d = max(l - lst[-1], max_d)
	last_no = lst[0]
	lst = lst[1:]
	for lamp in lst:
		max_d = max(max_d, (lamp - last_no) / 2)
		last_no = lamp
	print(max_d)
else:
	print(0)


def ans(l, a):
	a.sort()
	m = 0
	if len(a) == 0:
		return 0
	if len(a) == 1:
		if a[0] > l - a[0]:
			return a[0]
		else:
			return l - a[0]
	for i in range(len(a) - 1):
		if a[i + 1] - a[i] > m:
			m = a[i + 1] - a[i]
	if a[0] == 0:
		if a[len(a) - 1] == l:
			return m / 2
		else:
			return max(m / 2, l - a[len(a) - 1])
	elif a[len(a) - 1] == l:
		return max(m / 2, a[0])
	else:
		return max(m / 2, a[0], l - a[len(a) - 1])
(n, k) = map(int, input().split(' '))
arr = list(map(int, input().split(' ')))
print(ans(k, arr))


(n, m) = map(int, input().split())
v = list(map(float, input().split()))
v = sorted(v)
if v[0] != 0:
	maxs = v[0]
	indice = 2
else:
	maxs = -1
	indice = 1
if v[n - 1] != m:
	if m - v[n - 1] > maxs:
		maxs = m - v[n - 1]
while indice <= n - 1:
	if (v[indice] - v[indice - 1]) / 2 > maxs:
		maxs = (v[indice] - v[indice - 1]) / 2
	indice += 1
print('%.10f' % maxs)


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
l = sorted(l)
l = [-l[0]] + l
l.append(l[-1] + 2 * (m - l[-1]))
mini = 0
for i in range(len(l) - 1):
	mini = max(l[i + 1] - l[i], mini)
print(mini / 2)


inp = input().split()
n = int(inp[0])
l = int(inp[1])
arr = input().split()
arr = list(map(int, arr))
arr.sort()
maxdiff = float('-inf')
if n == 1:
	if arr[0] == 0 or arr[0] == l:
		ans = l
	else:
		ans = max(arr[0], l - arr[0])
else:
	for i in range(1, n):
		diff = arr[i] - arr[i - 1]
		if diff > maxdiff:
			maxdiff = diff
	if arr[0] != 0:
		ans = max(arr[0], maxdiff / 2)
	else:
		ans = maxdiff / 2
	if arr[n - 1] != l:
		ans = max(ans, l - arr[n - 1], maxdiff / 2)
print(ans)


(_, l) = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
res = max(A[0], l - A[-1])
for i in range(len(A) - 1):
	res = max(res, (A[i + 1] - A[i]) / 2)
print(res)


(n, l) = map(int, input().split())
q = [int(x) for x in input().split()]
s = sorted(q)
D = 0
d = 0
for i in range(n - 1):
	d = abs(s[i] - s[i + 1])
	D = max(D, d / 2)
c = abs(s[0] - 0)
e = abs(s[-1] - l)
b = max(c, e)
D = max(D, b)
print(D)


(n, l) = [int(s) for s in input().split()]
arr = list(map(int, input().split()))
arr.sort()
minx = arr[0]
for i in range(len(arr) - 1):
	minx = max(minx, (arr[i + 1] - arr[i]) / 2)
minx = max(minx, l - arr[-1])
print(minx)


n = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
highest = max(a[0], n[1] - a[-1])
for i in range(1, len(a)):
	if (a[i] - a[i - 1]) / 2 > highest:
		highest = (a[i] - a[i - 1]) / 2
print(highest)


(n, l) = [int(_) for _ in input().split()]
start = 0
finish = l
lanterns = list(map(int, input().strip().split()))[:n]
lanterns = sorted(lanterns)
min = -99999999
for i in range(n - 1):
	r = lanterns[i + 1] - lanterns[i]
	if r >= min:
		min = r
a = max(lanterns[0] - start, min / 2)
b = max(finish - lanterns[n - 1], min / 2)
c = max(a, b)
print('{0:.10f}'.format(c))


def vanya_and_lanterns(s, r):
	a = sorted(r)
	b = [(a[i + 1] - a[i]) / 2 for i in range(len(a) - 1)]
	b.append(a[0])
	b.append(d - a[-1])
	return max(b)
f = lambda : list(map(int, input().split()))
(n, d) = f()
b = f()
print(vanya_and_lanterns(d, b))


(l, lst) = (int(input().split()[1]), sorted(list(map(int, input().split()))))
print(max([max([y - x for (x, y) in zip(lst[:-1], lst[1:])]) / 2 if len(lst) != 1 else lst[0], lst[0], l - lst[-1]]))


from sys import stdin

def get_user_input():
	return list(map(int, stdin.readline().rstrip().split()))
temp = get_user_input()
(n, l) = (temp[0], temp[1])
lanters = get_user_input()
lanters = sorted(lanters)
res = 2 * max(lanters[0] - 0, l - lanters[len(lanters) - 1])
for i in range(len(lanters) - 1):
	res = max(res, lanters[i + 1] - lanters[i])
print('%.10f' % (res / 2))


(N, L) = map(int, input().split())
pos = [int(x) for x in input().split()]
pos = sorted(pos)
maxd: float = 0
for i in range(len(pos) - 1):
	maxd = max(maxd, (pos[i + 1] - pos[i]) / 2)
if pos[0] != 0:
	maxd = max(maxd, pos[0])
if pos[-1] != L:
	maxd = max(maxd, L - pos[-1])
print(maxd)


[n, l] = [int(x) for x in input().split()]
lantern = [int(x) for x in input().split()]
lantern.sort()
gap = []
for x in range(n):
	y = lantern[x] - lantern[x - 1]
	gap.append(y)
maxx1 = max(gap) / 2
maxx2 = min(lantern)
maxx3 = l - max(lantern)
haha = max(maxx1, maxx2, maxx3)
print('%.10f' % haha)


n = input()
n = n.split(' ')
string = input()
string = string.split(' ')
list1 = []
list2 = []
for item in n:
	list1.append(int(item))
for item in string:
	list2.append(int(item))
list2.sort()
diff = [0]
for i in range(len(list2) - 1):
	diff.append(list2[i + 1] - list2[i])
result = [max(diff) / 2]
result.append(list2[0])
result.append(list1[1] - list2[len(list2) - 1])
print('%.010f' % max(result))


(n, l) = input().split()
n = int(n)
l = int(l)
a = []
s = input().split()
for i in range(len(s)):
	a.append(int(s[i]))
a.sort()
maks = 0
m = 0
if a[0] > l - a[n - 1]:
	m = a[0]
elif a[n - 1] != l:
	m = l - a[n - 1]
else:
	m = (a[n - 1] - a[n - 2]) / 2
for i in range(1, n - 1):
	if a[i] - a[i - 1] > maks:
		maks = a[i] - a[i - 1]
if m > maks / 2:
	print(m)
else:
	print(maks / 2)


import sys
(N, l) = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
a.sort()
for i in range(N - 1):
	ans = max(ans, (a[i + 1] - a[i]) / 2)
print(max(ans, a[0], l - a[-1]))


(n, l) = [int(i) for i in input().split()]
x = [int(i) for i in input().split()]
x.sort()
y1 = min(x) - 0
y2 = l - max(x)
ampl = int()
if y1 > y2:
	ampl = y1
else:
	ampl = y2
for i in range(len(x)):
	if i == len(x) - 1:
		break
	z = abs(x[i] - x[i + 1]) / 2
	if z > ampl:
		ampl = z
print(ampl)


from collections import deque, Counter, OrderedDict
from heapq import nsmallest, nlargest
from math import ceil, floor, log, log2, sqrt, gcd, factorial

def binNumber(n, size=1):
	return bin(n)[2:].zfill(size)

def iar():
	return list(map(int, input().split()))

def ini():
	return int(input())

def isp():
	return map(int, input().split())

def sti():
	return str(input())
(n, l) = isp()
a = iar()
a.sort()
m = -1
if n == 1:
	print(max(a[0], l - a[0]))
	quit()
if a[0] == 0:
	a = a[1:]
	n -= 1
	m = a[0] / 2
else:
	m = a[0]
for i in range(1, n):
	s = (a[i] + a[i - 1]) / 2 - a[i - 1]
	m = max(m, s)
print(max(m, l - a[n - 1]))


q = input().split()
n = int(q[0])
l = int(q[1])
a = input().split()
x = 0
while x < len(a):
	a[x] = int(a[x])
	x = x + 1
a.sort()
x = 0
z = 0
while x < len(a) - 1:
	y = (a[x + 1] - a[x]) / 2
	if y > z:
		z = y
	x = x + 1
y = 0
if a[0] != 0:
	y = a[0]
	if y > z:
		z = y
if a[-1] != l:
	y = l - a[-1]
	if y > z:
		z = y
print(z)


n = list(map(int, input().split()))
x = list(map(int, input().split()))
x.sort()
rez = 2 * max(x[0], n[1] - x[n[0] - 1])
j = []
if n[0] > 1:
	for i in range(len(x)):
		if i == len(x) - 1:
			break
		rez = max(rez, x[i + 1] - x[i])
print(rez / 2)


(n, l) = map(int, input().split())
numbers = list(map(int, input().split()))
numbers.sort()
max_distance = 0
for i in range(len(numbers) - 1):
	d = (numbers[i + 1] - numbers[i]) / 2
	if d > max_distance:
		max_distance = d
if numbers[0] > max_distance:
	max_distance = numbers[0]
if l - numbers[-1] > max_distance:
	max_distance = l - numbers[-1]
print(max_distance)


from typing import List, Tuple

def parse_input() -> Tuple[int, int, List[int]]:
	(n, l) = [int(x) for x in input().split()]
	arr = [int(x) for x in input().split()]
	return (n, l, arr)

def solve(n: int, l: int, arr: List[int]) -> float:
	arr.sort()
	maxDist = 0
	for idx in range(1, n):
		maxDist = max(arr[idx] - arr[idx - 1], maxDist)
	return max(maxDist / 2, arr[0], l - arr[-1])
(n, l, arr) = parse_input()
print(solve(n, l, arr))


(n, l) = map(int, input().split(' '))
s = input().split(' ')
light = []
for i in s:
	light.append(int(i))
for i in range(n):
	element = light[i]
	j = i
	while j > 0 and light[j - 1] > element:
		light[j] = light[j - 1]
		j -= 1
	light[j] = element
ma = -1
for i in range(n - 1):
	if light[i + 1] - light[i] > ma:
		ma = light[i + 1] - light[i]
if light[0] > ma / 2 or l - light[-1] > ma / 2:
	if light[0] > l - light[-1]:
		print(light[0])
	else:
		print(l - light[-1])
else:
	print(ma / 2)


a = list(map(int, input().split()))
b = list(map(int, input().split()))
b.sort()
if b[0] == 0:
	k = []
	if len(b) > 1:
		for i in range(0, a[0] - 1):
			k.append(b[i + 1] - b[i])
		m = max(k)
		c = b[0]
		h = a[1] - b[a[0] - 1]
		l = []
		l.append(m / 2)
		l.append(c)
		l.append(h)
		print('%.10f' % max(l))
	else:
		k.append(0)
		m = max(k)
		c = b[0]
		h = a[1] - b[a[0] - 1]
		l = []
		l.append(m / 2)
		l.append(c)
		l.append(h)
		print('%.10f' % max(l))
else:
	k = []
	if len(b) > 1:
		for i in range(0, a[0] - 1):
			k.append(b[i + 1] - b[i])
		m = max(k)
		c = b[0]
		h = a[1] - b[a[0] - 1]
		l = []
		l.append(m / 2)
		l.append(c)
		l.append(h)
		print('%.10f' % max(l))
	else:
		k.append(0)
		m = max(k)
		c = b[0]
		h = a[1] - b[a[0] - 1]
		l = []
		l.append(m / 2)
		l.append(c)
		l.append(h)
		print('%.10f' % max(l))


(n, x) = map(int, input().split())
arr = [int(x) for x in input().split()]
arr.sort()
res = 0
for i in range(1, len(arr)):
	res = max(res, (arr[i] - arr[i - 1]) / 2)
print(max(res, arr[0], x - arr[-1]))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
(prev, greatest) = (0, 0)
for i in a:
	if (i - prev) / 2 > greatest:
		greatest = (i - prev) / 2
	prev = i
print(max(float(greatest), len(range(0, a[0])), len(range(a[-1], l))))


def qsort(a):
	b = []
	m = []
	r = []
	if len(a) < 2:
		return a
	o = a[len(a) // 2]
	for i in range(len(a)):
		if a[i] > o:
			b += [a[i]]
		elif a[i] < o:
			m += [a[i]]
		else:
			r += [a[i]]
	return qsort(m) + r + qsort(b)
s = input().split(' ')
n = int(s[0])
l = int(s[1])
a = input().split(' ')
for i in range(n):
	a[i] = int(a[i])
m = 0
a = qsort(a)
for i in range(1, n):
	if a[i] - a[i - 1] > m:
		m = a[i] - a[i - 1]
m = max(a[0], max(l - a[n - 1], m / 2))
print(m)


a = list(map(int, input().split()))
b = sorted(list(map(int, input().split())))
l = list()
for i in range(len(b) - 1):
	x = b[i + 1] - b[i]
	l.append(x / 2)
if b.count(0) == 0:
	l.append(b[0] - 0)
if b.count(a[1]) == 0:
	l.append(a[1] - max(b))
print('{0:.10f}'.format(max(l)))


a = input()
lanterns = int(a.split(' ')[0])
length = int(a.split(' ')[1])
locations = input().split(' ')
for (i, e) in enumerate(locations):
	locations[i] = int(e)
locations = sorted(locations)
maxR = 0
for k in range(len(locations)):
	if k == len(locations) - 1:
		radius = float(length - locations[k])
		if k == 0:
			if float(locations[k]) > radius:
				radius = float(locations[k])
	else:
		radius = float((locations[k + 1] - locations[k]) / 2)
		if k == 0:
			if float(locations[k]) > radius:
				radius = float(locations[k])
	if radius > maxR:
		maxR = radius
print(maxR)


data = list(map(int, input().split()))
array = sorted(list(map(int, input().split())))
max = -1
if array[0] != 0:
	max = array[0] - 0
if array[-1] != data[1] and data[1] - array[-1] > max:
	max = data[1] - array[-1]
counter = 0
for i in range(0, len(array) - 1, 1):
	counter = array[i + 1] - array[i]
	if float(counter / 2) > max:
		max = float(counter / 2)
print(f'{max:.{10}f}')


(n, l) = [int(i) for i in input().split()]
s = [int(i) for i in input().split()]
s.sort()
_s = []
if n == 1:
	print('%.10f' % max(s[0], l - s[0]))
	exit()
for i in range(n - 1):
	_s.append(s[i + 1] - s[i])
_d = max(_s) / 2
d = max(_d, min(s), l - max(s))
print('%.10f' % d)


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
left = [0 for i in range(n)]
right = [0 for i in range(n)]
for i in range(n):
	left[i] = a[i]
	right[i] = a[i]
rest = [0 for i in range(n + 1)]
for i in range(n + 1):
	if i == 0:
		rest[i] = left[i]
	elif i == n:
		rest[i] = l - right[i - 1]
	else:
		rest[i] = (left[i] - right[i - 1]) / 2
print(max(rest))


li = [int(i) for i in input().split()]
n = li[0]
l = li[1]
li1 = [int(i) for i in input().split()]
li1.sort()
li2 = []
count = 0
if n == 1:
	li2.append(li1[0])
else:
	for i in range(n - 1):
		k = abs(li1[i] - li1[i + 1])
		li2.append(k)
ma = max(li2) / 2
y = float(li1[0])
co = l - li1[n - 1]
count = max(y, co)
count = max(count, ma)
print('{0:.10f}'.format(count))


import heapq as hp

def unpack(func=int):
	return map(func, input().split())

def range_n():
	return range(int(input()))

def main():
	(n, l) = unpack()
	arr = sorted(unpack())
	diff = max(arr[0], l - arr[-1])
	for i in range(n - 1):
		diff = max(diff, (arr[i + 1] - arr[i]) / 2)
	print(diff)
main()


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
x = 0
ct = 0
if x not in a:
	ct = a[0]
if l not in a:
	ct = max(ct, l - a[-1])
diff = -1
for i in range(1, len(a)):
	diff = a[i] - a[i - 1]
	ct = max(ct, diff / 2)
print('{0:.10f}'.format(ct))


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
ans = 0
for i in range(1, n):
	dist = a[i] - a[i - 1]
	ans = max(ans, dist)
maxdist = ans
z = a[0] - 0
x = l - a[n - 1]
g = max(z, x)
s = maxdist / 2
print(max(s, g))


(n, l) = [int(i) for i in input().split()]
arr = sorted([int(i) for i in input().split()])
d = arr[0]
for i in range(1, n):
	if arr[i] - d > arr[i - 1] + d:
		d = (arr[i] - arr[i - 1]) / 2
print(max(d, l - arr[n - 1]))


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
mx = -1
for i in range(n - 1):
	if a[i + 1] - a[i] > mx:
		mx = a[i + 1] - a[i]
r1 = (a[0] - 0) / 1
r2 = (l - a[n - 1]) / 1
r3 = mx / 2
print(max(r1, r2, r3))


(n, l) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
a = sorted(a)
mx = 0
for i in range(n - 1):
	if a[i + 1] - a[i] > mx:
		mx = a[i + 1] - a[i]
mx = mx / 2
x = a[0]
y = l - a[n - 1]
ans = max(mx, x, y)
print('%.10f' % ans)


def maximo(num1, num2):
	if num1 > num2:
		return num1
	else:
		return num2
datos = list(map(int, input().split()))
linternas = list(map(int, input().split()))
temp = 0
maximoR = 0.0
linternas.sort()
maximoR = maximo(float(linternas[0]), float(datos[1] - linternas[datos[0] - 1]))
for i in range(1, len(linternas)):
	temp = (linternas[i] - linternas[i - 1]) / 2
	if temp > maximoR:
		maximoR = temp
print(float(maximoR))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
dist = []
for i in range(1, n):
	dist.append(a[i] - a[i - 1])
if n == 1:
	print('%.9f' % max(l - a[0], a[0]))
	quit()
print('%.9f' % max(a[0], max(dist) / 2, l - a[-1]))


(n, l) = map(int, input().split())
lst = [int(i) for i in input().split()]
lst = sorted(lst)
maxe = 0
for j in range(n - 1):
	if lst[j + 1] - lst[j] > maxe:
		maxe = lst[j + 1] - lst[j]
print(max(maxe / 2, lst[0], l - lst[n - 1]))


l1 = [int(x) for x in input().split()]
l2 = [int(y) for y in input().split()]
l2.sort()
maxi = 0
if l2[0] == 0 and l2[len(l2) - 1] == l1[1]:
	for i in range(0, len(l2) - 1):
		value = (l2[i + 1] - l2[i]) / 2
		if value >= maxi:
			maxi = value
	print(maxi)
elif l2[0] == 0 and l2[len(l2) - 1] != l1[1]:
	for i in range(0, len(l2) - 1):
		value = (l2[i + 1] - l2[i]) / 2
		if value >= maxi:
			maxi = value
	if l2[len(l2) - 1] + maxi < l1[1]:
		maxi = l1[1] - l2[len(l2) - 1]
	print(maxi)
elif l2[0] != 0 and l2[len(l2) - 1] == l1[1]:
	for i in range(0, len(l2) - 1):
		value = (l2[i + 1] - l2[i]) / 2
		if value >= maxi:
			maxi = value
	if l2[0] - maxi > 0:
		maxi = l2[0]
	print(maxi)
else:
	for i in range(0, len(l2) - 1):
		value = (l2[i + 1] - l2[i]) / 2
		if value >= maxi:
			maxi = value
	if l2[0] - maxi > 0:
		maxi = l2[0]
	if l2[len(l2) - 1] + maxi < l1[1]:
		maxi = l1[1] - l2[len(l2) - 1]
	print(maxi)


(n, l) = map(int, input().split())
lanterns = [int(x) for x in input().split()]
lanterns.sort()
min_distance = abs(lanterns[0] - 0)
for i in range(1, len(lanterns)):
	min_distance = max(min_distance, abs(lanterns[i] - lanterns[i - 1]))
min_distance = max((min_distance / 2, abs(lanterns[0] - 0), abs(lanterns[-1] - l)))
print('{0:.9f}'.format(min_distance))


[n, l] = map(int, input().split(' '))
a = sorted(map(int, input().split(' ')))
a.append(2 * l - a[-1])
max_dist = 0
prev = -a[0]
for i in a:
	max_dist = max(i - prev, max_dist)
	prev = i
print(max_dist / 2)


(n, l) = [int(i) for i in input().split()]
lant = [int(p) for p in input().split()]
lant.sort()
d = lant[0]
for m in range(n - 1):
	if lant[m + 1] - lant[m] > d * 2:
		d = (lant[m + 1] - lant[m]) / 2
if l - lant[-1] > d:
	d = l - lant[-1]
print(d)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
d1 = a[0]
d2 = l - a[-1]
diff = 0
for i in range(1, len(a)):
	if a[i] - a[i - 1] > diff:
		diff = a[i] - a[i - 1]
print(max(diff / 2, d1, d2) * 1.0)


(a, b) = [*map(int, input().split())]
c = [*map(int, input().split())]
d = 0
c.sort()
if c[0] != 0:
	d = c[0]
for i in range(len(c) - 1):
	if (c[i + 1] - c[i]) / 2 > d:
		d = (c[i + 1] - c[i]) / 2
if b - c[-1] > d:
	d = b - c[-1]
print(d)


(n, l) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.append(l)
a.sort()
d = a[0]
for i in range(n):
	if (a[i + 1] - a[i]) / 2 > d:
		d = (a[i + 1] - a[i]) / 2
	if a[n - 1] + d < a[n]:
		d = a[n] - a[n - 1]
d = format(d, '.10f')
print(d)


(n, l) = [int(x) for x in input().split()]
arr = [float(x) for x in input().split()]
arr.sort()
big = 2 * max(arr[0], l - arr[n - 1])
for i in range(n - 1):
	if arr[i + 1] - arr[i] > big:
		big = arr[i + 1] - arr[i]
print(big / 2)


(n, k) = tuple((int(i) for i in input().split()))
a = [int(i) for i in input().split()]
a.sort()
a.append(k)
nr = max(a[0], k - a[n - 1])
for i in range(n):
	nr = max(nr, (a[i + 1] - a[i]) / 2)
print(nr)


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
f = a[0]
m = a[-1]
a.insert(0, -f)
a.append(2 * l - m)
max_d = 0
for i in range(len(a) - 1):
	current_d = float(a[i + 1] - a[i]) / 2.0
	if current_d > max_d:
		max_d = current_d
print(max_d)


import sys
(n, k) = map(int, input().split())
ar = list(map(float, input().split()))
ar.sort()
(ansl, ansr, mx) = (0.0, 0.0, 0.0)
if ar[0] > 1.0 * (k - ar[n - 1]):
	ansl = ar[0]
else:
	ansl = 1.0 * (k - ar[n - 1])
for i in range(1, n):
	add = (ar[i] - ar[i - 1]) / 2
	if add > mx:
		mx = add
ansr = ansl
if mx > ansr:
	ansr = mx
print('%.10f' % ansr)


import sys
(n, l) = [int(x) for x in sys.stdin.readline().split()]
ai = [int(x) for x in sys.stdin.readline().split()]
ai.sort()
vmax = 0
if ai[0] != 0:
	vmax = ai[0] * 2
for i in range(1, n - 1):
	k = ai[i] - ai[i - 1]
	if k > vmax:
		vmax = k
k = 0
if ai[n - 1] != l:
	k = (l - ai[n - 1]) * 2
else:
	k = ai[n - 1] - ai[n - 2]
if k > vmax:
	vmax = k
print('%.10f' % (vmax / 2.0))


x = []
max1 = 0
(n, l) = map(int, input().split())
x = list(map(int, input().split()))
x.sort()
for i in range(0, n - 1):
	if x[i + 1] - x[i] > max1:
		max1 = x[i + 1] - x[i]
print('%.10f' % max(max1 / 2, max(x[0] - 0, l - x[n - 1])))


n = map(int, input().split())
p = map(int, input().split())
n = list(n)
l = n[1]
n = n[0]
p = list(p)
p.sort()
maxId = 0
for i in range(len(p) - 1):
	if p[i + 1] - p[i] > maxId:
		maxId = p[i + 1] - p[i]
maxId = maxId / 2
if p[0] != 0:
	temp = p[0] - 0
	if maxId < temp:
		maxId = temp
if p[n - 1] != l:
	temp = l - p[n - 1]
	if maxId < temp:
		maxId = temp
print(maxId)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
end = l - a[-1]
gap = -a[0]
for t in a:
	end = max(end, (t - gap) / 2)
	gap = t
print(end)


(n, l) = [int(x) for x in input().split()]
point = [int(x) for x in input().split()]
point.sort()
m = point[0]
max = m * 2
for i in range(1, n):
	if point[i] - point[i - 1] > max:
		max = point[i] - point[i - 1]
if 2 * (l - point[n - 1]) > max:
	max = (l - point[n - 1]) * 2
print('%.10f' % (max / 2))


(n, l) = (int(i) for i in input().split())
a = list(map(int, input().split()))
a = sorted(a)
maxim = 0
for i in range(n):
	if i == n - 1:
		break
	r = a[i + 1] - a[i]
	if maxim < r:
		maxim = r
if maxim / 2 < a[0] or maxim / 2 < l - a[n - 1]:
	maxim = max(a[0], l - a[n - 1])
	print(maxim)
else:
	print(maxim / 2)


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
k = 0
for i in range(n - 1):
	m = a[i + 1] - a[i]
	if m > k:
		k = m
t = max(a[0] - 0, l - a[n - 1])
if t > k / 2:
	print(t)
else:
	print(k / 2)


a = list(map(int, input().split()))[1]
b = sorted(list(map(int, input().split())))
maxDist = max(b[0], a - b[-1])
for i in range(1, len(b)):
	maxDist = max((b[i] - b[i - 1]) / 2, maxDist)
print(maxDist)


(n, l) = list(map(int, input().split()))
lights = list(map(int, input().split()))
lights.sort()
params = 0
for i in range(n - 1):
	distance = (lights[i + 1] - lights[i]) / 2
	if distance > params:
		params = distance
if lights[0] > params:
	params = lights[0]
if l - lights[-1] > params:
	params = l - lights[-1]
print('{:.10f}'.format(params))


(n, l) = map(int, input().split())
L = list(map(int, input().split()))
L.sort()
L = [-L[0]] + L + [2 * l - L[n - 1]]
r = 0
for i in range(n + 1):
	if (L[i + 1] - L[i]) / 2 > r:
		r = (L[i + 1] - L[i]) / 2
print(r)


nl = input()
loc = input()
n = int(nl.split()[0])
l = int(nl.split()[1])
loc = [int(item) for item in loc.split()]
loc.sort()
largestGap = 0
for i in range(0, n - 1):
	if (loc[i + 1] - loc[i]) / 2 > largestGap:
		largestGap = (loc[i + 1] - loc[i]) / 2
if loc[0] > largestGap:
	largestGap = loc[0]
if l - loc[-1] > largestGap:
	largestGap = l - loc[-1]
print(largestGap)


(l, n) = input().split()
lanterns = list(map(int, input().split()))
lanterns.sort()
(a, b, d) = (0, 0, 0)
if 0 not in lanterns:
	a = lanterns[0]
if int(n) not in lanterns:
	b = int(n) - lanterns[-1]
for i in range(int(l) - 1):
	if (lanterns[i + 1] - lanterns[i]) / 2 > d:
		d = (lanterns[i + 1] - lanterns[i]) / 2
print(max(a, b, d))


import sys
lines = sys.stdin.read().strip().split('\n')
(n, l) = map(int, lines[0].split(' '))
a = sorted(list(map(int, lines[1].split(' '))))
d1 = abs(a[0] - a[0] * 2)
d2 = abs(a[n - 1] - l)
d3 = 0
lst = [(j - i) / 2 for (i, j) in zip(a, a[1:])]
if len(lst) > 0:
	d3 = max(lst)
r = max(d1, d2, d3)
print(r, end='')


F = int(1000000000.0)
(n, L) = map(int, input().split())
L *= F
arr = [int(x) * F for x in input().split()]
arr.sort()

def f(d):
	(x, y) = (arr[0], arr[-1])
	if x > d or L - y > d:
		return False
	for i in range(n - 1):
		(x, y) = (arr[i], arr[i + 1])
		if y - x > 2 * d:
			return False
	return True
lo = 0
hi = 1 * F
while not f(hi):
	hi *= 2
while hi - lo > 5:
	mid = lo + (hi - lo) // 2
	if f(mid):
		hi = mid
	else:
		lo = mid
while not f(lo):
	lo += 1
print(lo / 1000000000.0)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
d = [(j - i) / 2 for (i, j) in zip(a, a[1:])] + [a[0] - 0, l - a[n - 1]]
print(max(d))


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
a = arr[0]
b = l - arr[n - 1]
maxd = 0
for i in range(n - 1):
	maxd = max(maxd, arr[i + 1] - arr[i])
print(max(maxd / 2, a, b))


i = lambda : map(int, input().split())
(n, l) = i()
s = sorted(i())
print(max((u - d for (u, d) in zip(s + [2 * l - s[-1]], [-s[0]] + s))) / 2)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))[:n]
arr = sorted(arr)
diff = []
firstEdge = arr[0]
lastEdge = l - arr[len(arr) - 1]
diff.append(2 * firstEdge)
diff.append(2 * lastEdge)
for i in range(len(arr) - 1):
	diff.append(arr[i + 1] - arr[i])
diff.sort(reverse=True)
print(diff[0] / 2)


inp1 = input().split()
no_of_laterns = int(inp1[0])
length = int(inp1[1])
positions = [int(i) for i in input().split()]
positions = sorted(positions)
diff = []
if 0 not in positions:
	diff.append(positions[0])
if no_of_laterns not in positions:
	diff.append(length - positions[-1])
for index in range(len(positions) - 1):
	diff.append((positions[index + 1] - positions[index]) / 2.0)
print(float(max(diff)))


(x, y) = map(int, input().split())
a = list(map(int, input().split()))
d = a
d.sort()
if 0 not in d:
	c = d[0]
else:
	c = 0
b = 0
for b in range(1, x):
	avg = (d[b] - d[b - 1]) / 2
	if c < avg:
		c = avg
if y not in d:
	e = y - d[b]
	if e > c:
		c = e
print(float(c))


(n, l) = [int(x) for x in input().split()]
lant = [int(y) for y in input().split()]
lant.sort()
dis = 0
for i in range(n - 1):
	if lant[i + 1] - lant[i] > dis:
		dis = lant[i + 1] - lant[i]
print(max(min(lant), l - max(lant), dis / 2))


t = list(map(int, input().split()))
z = list(map(int, input().split()))
z2 = z.copy()
r = 0
i = 0
while i < t[0] - 1:
	x = min(z2)
	z2.remove(min(z2))
	r = max(r, min(z2) - x)
	i += 1
print(max(min(z), r / 2, t[1] - max(z)))


def get_sorted_numlist():
	list_in = list(input().split())
	list_out = []
	for k in list_in:
		list_out += [int(k)]
	list_out.sort()
	return list_out

def get_numlist():
	list_in = list(input().split())
	list_out = []
	for k in list_in:
		list_out += [int(k)]
	return list_out

def main():
	list0 = get_numlist()
	list1 = get_sorted_numlist()[::-1]
	end = list0[1]
	list_check = []
	for i in range(list0[0]):
		list_check += [end - list1[i]]
		end = list1[i]
	out0 = sorted(list_check)
	out1 = [list0[1] - float(list1[0]), out0[-1] / 2, float(list1[-1])]
	out1 = sorted(out1)
	print(out1[-1])
main()


(n, l) = input().split(' ')
n = int(n)
l = int(l)
positions = list(map(int, input().split(' ')))[:n]
positions.sort(reverse=False)
dist1 = positions[0]
dist = 0
dist2 = l - positions[n - 1]
for i in range(n - 1):
	if positions[i + 1] - positions[i] > dist:
		dist = positions[i + 1] - positions[i]
if dist1 > dist / 2 and dist1 > dist2:
	print(dist1)
elif dist / 2 > dist2:
	print(dist / 2)
else:
	print(dist2)


args = input().split()
n = int(args[0])
l = int(args[1])
args = input().split()
a = []
for arg in args:
	a.append(int(arg))
a.sort()
maxd = -1
for i in range(n - 1):
	curd = a[i + 1] - a[i]
	if curd > maxd:
		maxd = curd
maxd /= 2
curd = a[0]
if curd > maxd:
	maxd = curd
curd = l - a[-1]
if curd > maxd:
	maxd = curd
print(maxd)


(n, l) = map(int, input().split())
l1 = list(map(int, input().split()))
l1.sort()
ans = 0
for i in range(n):
	if i == 0:
		ans = max(ans, l1[i] - 0)
	else:
		ans = max(ans, (l1[i] - l1[i - 1]) / 2)
ans = max(l - l1[-1], ans)
print(ans)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
max_diff = 0
for i in range(n - 1):
	curr_diff = (arr[i + 1] - arr[i]) / 2
	max_diff = max(max_diff, curr_diff)
if arr[0] - max_diff > 0:
	max_diff = arr[0]
if arr[-1] + max_diff < k:
	max_diff = k - arr[-1]
print(max_diff)


(n, l) = map(int, input().split())
lst = list(map(int, input().split()))
lst.sort()
d = max(lst[0], l - lst[-1])
x = 0
for i in range(0, n - 1):
	tmp = (lst[i + 1] - lst[i]) / 2
	if tmp > x:
		x = tmp
print(max(d, x))


(n, l) = map(int, input().split())
a = [int(s) for s in input().split()]
maxi = -1
a = sorted(a)
first = a[0]
last = l - a[n - 1]
for i in range(n - 1):
	if maxi < a[i + 1] - a[i]:
		maxi = a[i + 1] - a[i]
x = [last, first, maxi / 2]
print(max(x))


(_, l) = [int(n) for n in input().split()]
lanterns = [int(n) for n in input().split()]
lanterns = sorted(lanterns)
diffs = [lanterns[i + 1] - lanterns[i] for (i, _) in enumerate(lanterns[:-1])]
diffs = [l] if len(diffs) == 0 else diffs
max_diff = max(diffs)
max_diff = max_diff / 2
max_diff = max(max_diff, lanterns[0], l - lanterns[-1])
print(max_diff)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
max1 = 0
for i in range(1, len(a)):
	temp = a[i] - a[i - 1]
	if max1 <= temp:
		max1 = temp
max2 = min(a) - 0
max3 = l - max(a)
if max1 / 2 >= max(max2, max3):
	print(max1 / 2)
else:
	print(max(max2, max3))


(s, n) = input().split()
ls = list(map(int, input().split()))
ls.sort()
maximum = 0
first = ls[0]
last = ls[-1]
flag = 0
if first != 0:
	flag = 1
if last != n:
	flag = 2
for i in range(int(s) - 1):
	if abs(ls[i] - ls[i + 1]) > maximum:
		maximum = abs(ls[i] - ls[i + 1])
if flag == 0:
	print('{:.10f}'.format(maximum / 2))
elif maximum / 2 > first and maximum / 2 > int(n) - int(last):
	print('{:.10f}'.format(maximum / 2))
elif flag == 1:
	print('{:.10f}'.format(first))
elif flag == 2:
	print('{:.10f}'.format(max(first, int(n) - int(last))))


import sys
(n, l) = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
arr.sort()
maxDist = -1
for i in range(n - 1):
	a = arr[i + 1] - arr[i]
	maxDist = max(a, maxDist)
ans = max(maxDist / 2, max(arr[0] - 0, l - arr[n - 1]))
print('%.10f' % ans)


length = input()
user_input = input()
length = length.split(' ')
user_input = user_input.split(' ')
for i in range(len(user_input)):
	user_input[i] = int(user_input[i])
first_diff = last_diff = 0
user_input.sort()
if 0 not in user_input:
	first_diff = (user_input[0] - 0) * 2
if int(length[1]) not in user_input:
	last_diff = (int(length[1]) - user_input[int(length[0]) - 1]) * 2
max_diff = 0
for i in range(len(user_input) - 1):
	if user_input[i + 1] - user_input[i] > max_diff:
		max_diff = user_input[i + 1] - user_input[i]
if first_diff >= max_diff:
	max_diff = first_diff
if last_diff >= max_diff:
	max_diff = last_diff
print(max_diff / 2)


def merge_arrays(a, b):
	merged = []
	while a and b:
		if a[0] > b[0]:
			m = b.pop(0)
			merged.append(m)
		else:
			p = a.pop(0)
			merged.append(p)
	if a:
		merged.extend(a)
	elif b:
		merged.extend(b)
	return merged

def m_sort(v):
	if len(v) == 1:
		return v
	mid = len(v) // 2
	a = m_sort(v[:mid])
	b = m_sort(v[mid:])
	return merge_arrays(a, b)

def main():
	line = input().split(' ')
	n = int(line[0])
	length = int(line[1])
	lanterns = {}
	m = input().split(' ')
	for i in m:
		lanterns[int(i)] = 1
	lanterns = list(lanterns.keys())
	lanterns = m_sort(lanterns)

	def dist(a, b):
		if a == -1:
			return b
		return (b - a) / 2
	prev = -1
	maxim = -1
	for l in lanterns:
		maxim = max(maxim, dist(prev, l))
		prev = l
	if prev != length:
		maxim = max(maxim, length - prev)
	print(float(maxim))
main()


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
maxi = float(a[0])
two = float(2)
maxi = max(maxi, float(l - a[n - 1]))
for i in range(1, n):
	res = float(a[i] - a[i - 1])
	maxi = max(float(res / two), maxi)
print(maxi)


(n, l) = map(int, input().split())
array = map(int, input().split())
newArray = sorted(array)
maxx = max(newArray[0], l - newArray[n - 1]) * 2
tmp = 0
for i in range(1, n):
	if newArray[i] - newArray[i - 1] > maxx:
		maxx = newArray[i] - newArray[i - 1]
print(maxx / 2)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
max_d = a[0]
cur = a[0]
for i in range(1, n):
	max_d = max(max_d, (a[i] - cur) / 2)
	cur = a[i]
max_d = max(max_d, l - cur)
print('%.10f' % max_d)


(n, l) = map(int, input().strip().split())
a = list(map(int, input().strip().split()))
a.sort()
least = 0
for i in range(0, n - 1):
	least = max(least, abs(a[i] - a[i + 1]) / 2)
least = max(least, a[0])
least = max(least, l - a[-1])
print(least)


(lanterns, street) = map(int, input().split())
points = list(map(int, input().split()))
points.sort()
difference = 0
for i in range(len(points) - 1):
	if points[i + 1] - points[i] > difference:
		difference = points[i + 1] - points[i]
if street - points[-1] > difference / 2 or points[0] > difference / 2:
	if street - points[-1] > points[0]:
		print(street - points[-1])
	else:
		print(points[0])
else:
	print(difference / 2)


def santa(x, y):
	list_1 = [int(i) for i in x.split(' ')]
	list_2 = sorted([int(i) for i in y.split(' ')])
	list_3 = []
	l = list_1[1]
	n = list_1[0]
	int_var = list_2[0]
	for i in list_2:
		list_3.append((i - int_var) / 2)
		int_var = i
	list_3.append(list_2[0])
	list_3.append(l - list_2[-1])
	list_3.sort()
	return list_3[-1]
a = input()
b = input()
print(santa(a, b))


(n, l) = [int(t) for t in input().split()]
pos = [int(t) for t in input().split()]
pos.sort()
maxdistance = max(l - pos[-1], pos[0]) * 2
for i in range(1, n):
	if pos[i] - pos[i - 1] > maxdistance:
		maxdistance = pos[i] - pos[i - 1]
print(maxdistance / 2)


(n, l) = map(int, input().split())
m = sorted(list(map(int, input().split())))
max = 2 * max(m[0] - 0, l - m[n - 1])
for i in range(1, len(m)):
	if m[i] - m[i - 1] > max:
		max = m[i] - m[i - 1]
print('%.10f' % (max / 2))


(n, L) = map(int, input().split())
arr = [int(x) for x in input().split()]
arr.sort()
rez = 2 * max(arr[0], L - arr[n - 1])
for i in range(n - 1):
	rez = max(rez, arr[i + 1] - arr[i])
print(rez / 2)


(n, l) = input().split()
n = int(n)
l = int(l)
x = input().split()
for i in range(0, n):
	x[i] = int(x[i])
x.sort()
maxi = max(x[0], l - x[n - 1])
for i in range(1, n):
	if (x[i] - x[i - 1]) / 2 > maxi:
		maxi = (x[i] - x[i - 1]) / 2
print(format(maxi, '.9f'))


(n, l) = [int(x) for x in input().split()]
w = sorted([int(x) for x in input().split()])
c = 0
for i in range(n - 1):
	s = (w[i + 1] - w[i]) / 2
	a = max(w[0], l - w[-1])
	c = max(c, s, a)
if n == 1:
	c = max(w[0], l - w[0])
print('%.10f' % c)


(n, l) = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
if n == 1:
	ans = max(l - arr[0], arr[0])
	print(ans)
	exit(0)
arr.sort()
maxdist = arr[1] - arr[0]
for i in range(1, n - 1):
	if arr[i + 1] - arr[i] > maxdist:
		maxdist = arr[i + 1] - arr[i]
ans = maxdist / 2
if l - arr[n - 1] > ans:
	ans = l - arr[n - 1]
if arr[0] > ans:
	ans = arr[0]
print(ans)


(n, l) = input().split(' ')
n = int(n)
l = int(l)
list = input().split(' ')
for (ind, j) in enumerate(list):
	list[ind] = int(list[ind])
list.sort()
start = 0
current_max = 0
for (index, i) in enumerate(list):
	x = int(i)
	if index == 0:
		if x - 0 > current_max:
			current_max = x - 0
	elif (x - int(list[index - 1])) / 2 > current_max:
		current_max = (x - int(list[index - 1])) / 2
	else:
		continue
if l - int(list[-1]) > current_max:
	current_max = l - int(list[-1])
print(current_max)


(n, d) = map(int, input().split())
l = set(map(int, input().split()))
l = list(l)
l.sort()
M = 0
for i in range(len(l) - 1):
	if l[i + 1] - l[i] > M:
		M = l[i + 1] - l[i]
M = M / 2
ans = max(M, l[0], d - l[-1])
print('%.10f' % ans)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
left = arr[0]
right = l - arr[-1]
max_dist = 0
for i in range(len(arr) - 1):
	if arr[i + 1] - arr[i] > max_dist:
		max_dist = arr[i + 1] - arr[i]
print('%.10f' % max(max_dist / 2, left, right))


from sys import stdin

def main():
	(n, l) = map(int, stdin.readline().strip().split())
	aa = sorted(map(int, stdin.readline().strip().split()))
	maxgap = max(aa[0], l - aa[-1]) * 2
	a = aa[0]
	for b in aa:
		(gap, a) = (b - a, b)
		if maxgap < gap:
			maxgap = gap
	return maxgap / 2
print(main())


(n, l) = [int(x) for x in input().split()]
lat = [int(x) for x in input().split()]
lat.sort()
diff = 0
for i in range(0, len(lat) - 1):
	if abs(lat[i] - lat[i + 1]) > diff:
		diff = abs(lat[i] - lat[i + 1])
if 0 not in lat and lat[0] > diff / 2:
	diff = 2 * lat[0]
if l not in lat and l - lat[-1] > diff / 2:
	diff = 2 * (l - lat[-1])
print(diff / 2)


import sys
inf = float('inf')
(mod, MOD) = (1000000007, 998244353)

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

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

def input():
	return sys.stdin.readline().strip()
(n, l) = get_ints()
Arr = get_array()
Arr.sort()
maxi = -1
for i in range(1, n):
	maxi = max(maxi, (Arr[i] - Arr[i - 1]) / 2)
if Arr[0] != 0:
	maxi = max(maxi, Arr[0])
if Arr[-1] != l:
	maxi = max(maxi, l - Arr[-1])
print(maxi)


(n, l) = map(int, input().split())
a = [int(i) for i in input().split()]
a.sort()
d0 = dl = 0
if 0 not in a:
	d0 = a[0]
if l not in a:
	dl = l - a[n - 1]
distance = [0]
for i in range(n - 1):
	di = a[i + 1] - a[i]
	if di not in distance:
		distance.append(di)
di = max(distance) / 2
if d0 != 0 or dl != 0:
	print(max(d0, di, dl))
else:
	print(di)


(n, l) = [int(x) for x in input().split(' ')]
A = [int(x) for x in input().split(' ')]
A.sort()
maxd = max(A[0] - 0, l - A[n - 1])
for i in range(n - 1):
	if (A[i + 1] - A[i]) / 2 > maxd:
		maxd = (A[i + 1] - A[i]) / 2
print(maxd)


(n, l) = map(int, input().split())
ai = list(map(int, input().split()))
ai.sort()
d = []
for i in range(n - 1):
	d.append((ai[i + 1] - ai[i]) / 2)
d.extend([ai[0], l - ai[n - 1]])
print('%.9f' % max(d))


(n, m) = map(int, input().split())
l = [int(x) for x in input().split()]
l.sort()
l.append(l[-1])
g = [l[i + 1] - l[i] for i in range(n)]
a = float(max(max(g) / 2, l[0], m - l[-1]))
print('{:.9f}'.format(a))


line = input().split()
n = int(line[0])
l = int(line[1])
a = [0] * n
line = input().split()
for i in range(n):
	a[i] = int(line[i])
a.sort()
max = 0
float(max)
for i in range(1, len(a)):
	if a[i] - a[i - 1] > max:
		max = a[i] - a[i - 1]
max = max / 2
if a[0] != 0 and a[0] > max:
	max = a[0]
if a[n - 1] != l and l - a[n - 1] > max:
	max = l - a[n - 1]
formatted = '{:.10f}'.format(max)
print(formatted)


(n, k) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort()
p = a[0]
for i in range(n - 1):
	t = (a[i + 1] - a[i]) / 2
	p = max(t, p)
t = k - a[n - 1]
p = max(t, p)
print(p)


(n, l) = [int(x) for x in input().split()]
var = [int(x) for x in input().split()]
var = sorted(var)
maxi = max(var[0] - 0, l - var[-1])
for i in range(0, n - 1):
	maxi = max(maxi, (var[i + 1] - var[i]) / 2)
print(maxi)


inp = list(map(int, input().split(' ')))
li = list(map(int, input().split(' ')))
li.sort()
ans = 0
i = 0
while i < len(li) - 1:
	ans = max(ans, (li[i + 1] - li[i]) / 2)
	i = i + 1
ans = max([ans, li[0], inp[1] - li[-1]])
print(ans)


(n, l) = [int(n) for n in input().split()]
position = [int(position) for position in input().split()]
position.sort()
distance = []
distance.append(position[0] * 2)
distance.append((l - position[n - 1]) * 2)
for i in range(n - 1):
	distance.append(position[i + 1] - position[i])
r = format(max(distance) / 2, '.10f')
print(r)


from sys import stdin
i = [[int(y) for y in x.rstrip().split()] for x in stdin.readlines()]
(n, l) = i[0]
lanterns = sorted(i[1])
if n == 1:
	print(max(lanterns[0], l - lanterns[-1]))
else:
	d = [(lanterns[i + 1] - lanterns[i]) / 2.0 for i in range(n - 1)]
	print(max(lanterns[0], l - lanterns[-1], max(d)))


ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(mi())
si = lambda : input()
(n, l) = mi()
a = sorted(li())
print(max(a[0] - 0, l - a[-1], max([0] + list((a[i] - a[i - 1] for i in range(1, n)))) / 2))


(n, d) = map(int, input().split())
a = sorted([int(x) for x in input().split()])
m = a[0]
for (x, y) in zip(a, a[1:]):
	m = max(abs((x - y) / 2), m)
m = max(m, d - a[n - 1])
print(m)


(a, b) = map(int, input().split())
lst = sorted(map(int, input().split()))
small = min(lst)
big = max(lst)
ans = []
xans = []
ans.append(abs(small - 0))
ans.append(abs(big - b))
lst.append(b)
for i in range(a):
	xans.append(abs(lst[i] - lst[i + 1]) / 2)
ans.append(max(xans))
print(max(ans))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
d = l - a[-1]
pa = -a[0]
for t in a:
	d = max(d, (t - pa) / 2)
	pa = t
print(d)


(n, m) = map(int, input().split())
l = [int(i) for i in input().split()]
l.sort()
karma_dist = l[0] - 0
maxi = -1
for i in range(1, n):
	maxi = max(maxi, l[i] - l[i - 1])
print(max(karma_dist, maxi / 2, m - l[-1]))


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
a.append(a[-1])
print(max(max([x - y for (x, y) in zip(a[1:], a[:-1])]) * 0.5, a[0], l - a[-1]))


(n, l) = map(int, input().split())
x = list(map(int, input().split()))
if n > 1:
	x.sort()
	z = []
	i = 0
	while i < len(x) - 1:
		diff = abs(int(x[i]) - int(x[i + 1]))
		z.append(diff)
		i += 1
	a = max(z) / 2.0
	b = x[0] - 0.0
	c = l - x[-1]
	ans = max(b, c)
	ansf = max(ans, a)
	print(ansf)
else:
	b = x[0] - 0.0
	c = l - x[-1]
	print(max(b, c))


ln1 = input().split(' ')
n = int(ln1[0])
l = int(ln1[1])
ln2 = sorted(list(map(int, input().split(' '))))
d = ln2[0] - 0
for i in range(n - 1):
	x = ln2[i + 1] - ln2[i]
	if x > 2 * d:
		d = x / 2
x = l - ln2[n - 1]
if x > d:
	d = x
print(str(d))


def solution(l, a):
	res = max(a[0] - 0, l - a[-1])
	for i in range(len(a) - 1):
		res = max(res, (a[i + 1] - a[i]) / 2)
	return res
f = lambda : map(int, input().split())
(n, l) = f()
a = sorted(f())
print(solution(l, a))


(n, l) = [int(x) for x in input().split()]
lamps = [int(x) for x in input().split()]
lamps.sort()
print(max([abs(x - y) / 2 for (x, y) in zip(lamps[1:], lamps[:-1])] + [lamps[0]] + [l - lamps[-1]]))


(n, d) = map(int, input().split())
ar = list(map(int, input().split()))
sar = sorted(ar)
temp = sar[0]
temp1 = d - sar[-1]
for i in range(n - 1):
	if abs(sar[i] - sar[i + 1]) / 2 > temp:
		temp = abs(sar[i] - sar[i + 1]) / 2
if temp1 > temp:
	print(temp1)
else:
	print(temp)


(num, length) = map(int, input().split())
lis1 = list(map(int, input().split()))
lis1 = sorted(lis1)
left = lis1[0]
right = length - lis1[-1]
max1 = max(left, right)
for i in range(1, len(lis1)):
	distance = (lis1[i] - lis1[i - 1]) / 2
	max1 = max(max1, distance)
print(max1)


import math
st = ''

def func(n, l, l1):
	l1.sort()
	m = 0
	for i in range(n - 1):
		m = max(m, l1[i + 1] - l1[i])
	return max(m, 2 * (l1[0] - 0), 2 * (l - l1[-1])) / 2
for _ in range(1):
	(n, l) = map(int, input().split())
	l1 = list(map(int, input().split()))
	st += str(func(n, l, l1)) + '\n'
print(st)


(n, m) = [int(x) for x in input().split()]
a = sorted([int(x) for x in input().split()])
l = []
if len(a) == 1:
	print(max(a[0], m - a[0]))
else:
	for i in range(n - 1):
		l.append(a[i + 1] - a[i])
	l1 = sorted(l)
	print(max(l1[-1] / 2, m - a[-1], a[0]))


params = list(map(int, input().split()))
pos = list(map(int, input().split()))
pos.sort()
dists = [0]
for r in range(0, len(pos) - 1):
	dists.append(pos[r + 1] - pos[r])
min_range = max(dists) / 2
print(max(pos[0], params[1] - pos[-1], min_range))


(n, l) = input().split()
(n, l) = (int(n), int(l))
list = input().split()
list = [int(i) for i in list]
list.sort()
if l - list[-1] > list[0]:
	max = l - list[-1]
else:
	max = list[0]
for i in range(1, len(list)):
	if max < (list[i] - list[i - 1]) / 2:
		max = (list[i] - list[i - 1]) / 2
print(max)


(N, L) = map(int, input().split())
X = list(map(int, input().split()))
X.sort()
dist = []
for j in range(len(X)):
	if j == 0:
		dist.append(2 * X[0])
	else:
		dist.append(X[j] - X[j - 1])
dist.append(2 * (L - X[len(X) - 1]))
dist.sort()
print(dist[len(dist) - 1] / 2)


(a, b) = map(int, input().split())
diff = 0
d = list(map(int, input().split()))
d.sort()
for j in range(1, a):
	if diff < abs(d[j] - d[j - 1]):
		diff = abs(d[j] - d[j - 1])
if diff / 2 < max(d[0], b - d[-1]):
	diff = max(d[0], b - d[-1]) * 2
print('{0:.10f}'.format(diff / 2))


(n, l) = [int(x) for x in input().split()]
lanterns = [int(x) for x in input().split()]
a = sorted(lanterns)
if a[0] != 0:
	mx = a[0]
else:
	mx = 0
for i in range(n - 1):
	d = (a[i + 1] - a[i]) / 2
	if d > mx:
		mx = d
if a[n - 1] + mx < l:
	mx = l - a[n - 1]
print(mx)


(a, b) = input().split()
a = int(a, 10)
b = int(b, 10)
s = input().split()
s = list(s)
for i in range(len(s)):
	s[i] = int(s[i])
s1 = sorted(s)
if len(s1) == 1:
	m1 = b - s[0]
	m2 = s[0]
	if m1 > m2:
		r = m1
	else:
		r = m2
if s1[0] == 0 and len(s1) != 1:
	r = 0
elif s1[0] > b - s1[len(s1) - 1]:
	r = s1[0]
else:
	r = b - s1[len(s1) - 1]
for i in range(1, len(s1), 1):
	k = s1[i] - s1[i - 1]
	if k / 2 > r:
		r = k / 2
print(r)


(a, b) = map(int, input().split())
c = sorted(map(int, input().split()))
maximum = 0
for i in range(len(c) - 1):
	e = c[i + 1] - c[i]
	if e > maximum:
		maximum = e
print(str.format('{0:.10f}', max(c[0], b - c[-1], maximum / 2)))


import sys
input = sys.stdin.readline
(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
ans = max(a[0], l - a[-1])
for i in range(n - 1):
	ans = max(ans, (a[i + 1] - a[i]) / 2)
print(ans)


TN = 1

def solution():
	(n, l) = map(int, input().split())
	a = sorted(list(map(int, input().split())))
	lst = [0]
	for i in range(n - 1):
		lst.append(a[i + 1] - a[i])
	mxd = max(lst)
	ans = max(mxd / 2, max(a[0], l - a[-1]))
	print(ans)
while TN != 0:
	solution()
	TN -= 1


import math

def na():
	n = int(input())
	b = [int(x) for x in input().split()]
	return (n, b)

def nab():
	n = int(input())
	b = [int(x) for x in input().split()]
	c = [int(x) for x in input().split()]
	return (n, b, c)

def dv():
	(n, m) = map(int, input().split())
	return (n, m)

def dva():
	(n, m) = map(int, input().split())
	b = [int(x) for x in input().split()]
	return (n, m, b)

def nm():
	n = int(input())
	b = [int(x) for x in input().split()]
	m = int(input())
	c = [int(x) for x in input().split()]
	return (n, b, m, c)

def dvs():
	n = int(input())
	m = int(input())
	return (n, m)
(n, l, a) = dva()
a = sorted(a)
mx = 0
mxx = a[0]
mxx1 = l - a[-1]
for i in range(1, n):
	d = a[i] - a[i - 1]
	if d > mx:
		mx = d
mx = mx / 2
if mxx > mx:
	mx = mxx
if mxx1 > mx:
	mx = mxx1
print(mx)


import math
intxt = input()
intxt = intxt.split()
n = int(intxt[0])
length = int(intxt[1])
intxt = input()
lanterns = [int(x) for x in intxt.split()]
for i in range(1, n):
	for j in range(i, 0, -1):
		if lanterns[j] < lanterns[j - 1]:
			(lanterns[j], lanterns[j - 1]) = (lanterns[j - 1], lanterns[j])
		else:
			break
max_diff = lanterns[0]
if length - lanterns[-1] > max_diff:
	max_diff = length - lanterns[-1]
max_diff *= 2
for i in range(1, n):
	tmp = lanterns[i] - lanterns[i - 1]
	if tmp > max_diff:
		max_diff = tmp
print(max_diff / 2)


from collections import defaultdict
from sys import stdin
input = lambda : stdin.readline().strip()
(n, d) = [int(i) for i in input().split()]
lst = [int(i) for i in input().split()]
lst.sort()
max1 = 0
for i in range(0, n - 1):
	max1 = max([max1, lst[i + 1] - lst[i]])
max1 = max([max1 / 2, lst[0]])
max1 = max([max1, d - lst[-1]])
print('%f' % max1)


(numberOfLanterns, roadLength) = map(int, input().split())
lanternPositions = list(map(int, input().split()))
if 0 not in lanternPositions:
	lanternPositions.append(0 - min(lanternPositions))
if roadLength not in lanternPositions:
	lanternPositions.append(roadLength + (roadLength - max(lanternPositions)))
lanternPositions = sorted(lanternPositions)
max = 0
for i in range(len(lanternPositions) - 1):
	if lanternPositions[i + 1] - lanternPositions[i] > max:
		max = lanternPositions[i + 1] - lanternPositions[i]
print('{0:.10f}'.format(max / 2))


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
maxi = -1
for i in range(0, n - 1):
	if maxi < a[i + 1] - a[i]:
		maxi = a[i + 1] - a[i]
maxi = maxi / 2
if maxi < a[0]:
	maxi = a[0]
if maxi < l - a[n - 1]:
	maxi = l - a[n - 1]
if maxi - int(maxi) == 0.5:
	print(str(maxi) + '000000000')
else:
	print(str(int(maxi)) + '.0000000000')


(n, l) = (int(i) for i in input().split())
A = sorted([int(i) for i in input().split()])
d_begin = A[0]
d_end = l - A[-1]
d_max = 0
for i in range(1, len(A)):
	d = A[i] - A[i - 1]
	if d > d_max:
		d_max = d
d_max = max(d_begin, d_max / 2, d_end)
print(d_max)


(n, l) = [int(x) for x in input().split()]
ls = sorted([int(x) for x in input().split()])
diffs = []
maxDiff = 0
for i in range(1, n):
	curDiff = ls[i] - ls[i - 1]
	if curDiff / 2 > maxDiff:
		maxDiff = curDiff / 2
print(max(maxDiff, max(ls[0], l - ls[n - 1])))


(n, l) = tuple(map(int, input().split()))
L = list(map(int, input().split()))
L.sort()
maxv = 0
actv = 0
for x in range(1, len(L)):
	actv = L[x] - L[x - 1]
	if actv > maxv:
		maxv = actv
w = max(maxv / 2, L[0], l - L[-1])
print(w)


(n, li) = map(int, input().split())
l = [int(x) for x in input().split()]
l.sort()
d = 0
if l[0] == 0 and n != 1:
	d = (l[1] - l[0]) / 2
else:
	d = l[0]
i = 1
while i < n - 1:
	d = max(d, (l[i] - l[i - 1]) / 2)
	i += 1
if l[n - 1] == li and n != 1:
	d = max(d, (l[-1] - l[-2]) / 2)
else:
	d = max(d, li - l[-1])
print(d)


(n, l) = map(int, input().split())
a = list(sorted(map(int, input().split())))
try:
	d = max([a[i] - a[i - 1] for i in range(1, n)])
except ValueError:
	d = 0
print(max(a[0], l - a[-1], d / 2))


(n, m) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a = sorted(a)
y = 0
for i in range(n - 1):
	x = a[i + 1] - a[i]
	if x > y:
		y = x
	i += 1
y = y / 2
if y < a[0]:
	y = a[0]
if y < m - a[n - 1]:
	y = m - a[n - 1]
print('%.9f' % y)


(n, m) = map(int, input().split())
l = [int(j) for j in input().split()]
l.sort()
ans = l[0]
for i in range(n):
	if i == n - 1:
		d = m - l[n - 1]
	else:
		d = (l[i + 1] - l[i]) / 2
	ans = max(d, ans)
print(ans)


(n, l) = input().split()
n = int(n)
l = int(l)
max = 0
k = 0
max_l = 0
listt = input().split()
for i in range(n):
	listt[i] = int(listt[i])
listt.sort()
if listt[0] != 0:
	max = listt[0]
	k = 1
if listt[n - 1] != l:
	max_l = l - listt[n - 1]
for i in range(k, n - 1):
	if max < (listt[i + 1] - listt[i]) / 2:
		max = (listt[i + 1] - listt[i]) / 2
if max > max_l:
	print(max)
else:
	print(max_l)


inp = lambda : map(int, input().split())
(n, l) = inp()
a = sorted(list(inp()))
k = mx = 0.0
for i in range(1, n):
	k = a[i] - a[i - 1]
	mx = max(mx, k / 2)
mx = max(mx, a[0] - 0.0)
mx = max(mx, l - a[n - 1])
print(mx)


(n, l) = map(int, input().split())
p = [int(x) for x in input().split()]
p.sort()
r = max(p[0], l - p[n - 1]) * 2
for i in range(n - 1):
	r = max(r, p[i + 1] - p[i])
print(r / 2.0)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
b = []
for i in range(len(a) - 1):
	b.append((a[i + 1] - a[i]) / 2)
if not 0 in a:
	b.append(a[0])
if not m in a:
	b.append(m - a[-1])
print(float(max(b)))


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
if n == 1:
	a1 = l[0] - 0
	a2 = k - l[0]
	print(max(a1, a2))
else:
	l.sort()
	max_diff = 0
	if l[0] != 0:
		max_diff = l[0]
		for i in range(1, len(l)):
			if (l[i] - l[i - 1]) / 2 > max_diff:
				max_diff = (l[i] - l[i - 1]) / 2
	else:
		for i in range(1, len(l)):
			if (l[i] - l[i - 1]) / 2 > max_diff:
				max_diff = (l[i] - l[i - 1]) / 2
	if l[-1] != k:
		if k - l[-1] > max_diff:
			max_diff = k - l[-1]
	print(max_diff)


(n, l) = map(int, input().strip().split())
locations = sorted(map(int, input().strip().split()))
edges = [locations[0] * 2, 2 * (l - locations[-1])]
for i in range(1, n):
	edges.append(locations[i] - locations[i - 1])
print(max(edges) / 2)


(n, m) = map(int, input().split())
array = list(map(int, input().split()))
array.sort()
r = max(array[0], m - array[-1])
for i in range(1, n):
	r = max(r, (array[i] - array[i - 1]) / 2)
print('%.10f' % r)


(n, a) = map(int, input().split())
l = sorted(list(map(int, input().split())))
if l[0] == 0 and l[-1] == a:
	d = 0
	for i in range(n - 1):
		if l[i + 1] - l[i] > d:
			d = l[i + 1] - l[i]
	print(d / 2)
elif l[0] == 0:
	d = 0
	for i in range(n - 1):
		if l[i + 1] - l[i] > d:
			d = l[i + 1] - l[i]
	x = a - l[-1]
	if d / 2 < x:
		d = x
		d *= 2
	print(d / 2)
elif l[-1] == a:
	d = 0
	for i in range(n - 1):
		if l[i + 1] - l[i] > d:
			d = l[i + 1] - l[i]
	x = l[0]
	if d / 2 < x:
		d = x
		d *= 2
	print(d / 2)
else:
	d = 0
	for i in range(n - 1):
		if l[i + 1] - l[i] > d:
			d = l[i + 1] - l[i]
	x = a - l[-1]
	if d / 2 < x:
		d = x
		d *= 2
	y = l[0]
	if d / 2 < y:
		d = y
		d *= 2
	print(d / 2)


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_int = lambda : int(sys.stdin.readline())
(n, k) = get_int_list()
lst = get_int_list()
lst.sort()
d = max(lst[0] - 0, k - lst[-1])
for i in range(n - 1):
	d = max(d, (lst[i + 1] - lst[i]) / 2)
print(d)


(n, l) = [int(i) for i in input().split()]
ls = [int(i) for i in input().split()]
ls.sort()
val = -9999
for i in range(n - 1):
	val = max(val, ls[i + 1] - ls[i])
s = max(ls[0] - 0, l - ls[n - 1])
if s >= val / 2:
	print('%.10f' % s)
else:
	val = val / 2
	print('%.10f' % val)


(n, l) = input().split()
positions = input().split()
n = int(n)
l = int(l)
i = 0
while i < n:
	positions[i] = int(positions[i])
	i += 1
positions.sort()
positions.append(0 - positions[0])
positions.sort()
positions.append(l + (l - positions[len(positions) - 1]))
oldj = positions[0]
rads = []
for j in positions[1:]:
	rads.append(abs(oldj - j))
	oldj = j
rads.sort()
ans = rads[len(rads) - 1] / 2
print(ans)


a = str(input())
a = a.split()
n = int(a[0])
l = int(a[1])
b = str(input())
b = b.split()
for i in range(len(b)):
	b[i] = int(b[i])
b.sort()
maxiDiff = 0
if n > 1:
	for i in range(1, len(b)):
		if b[i] - b[i - 1] > maxiDiff:
			maxiDiff = b[i] - b[i - 1]
ans = maxiDiff / 2
mini = min(b)
maxi = max(b)
if ans < mini:
	ans = mini
if ans < l - maxi:
	ans = l - maxi
print(ans)


n = 1
while n:
	n -= 1
	(t, l) = map(int, input().split(' '))
	a = list(map(int, input().split(' ')))
	a.sort()
	res = 2 * max(a[0], l - a[-1])
	for i in range(1, t):
		res = max(res, a[i] - a[i - 1])
	print('{0:0.9f}'.format(res / 2.0))


(batti, rasta) = map(int, input().split())
talika = sorted(set(list(map(int, input().split()))))
cholok = -1
for i in range(len(talika) - 1):
	cholok = max(cholok, (talika[i + 1] - talika[i]) / 2)
print('%.10f' % max(cholok, talika[0], rasta - talika[-1]))


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
c = [(a[0] - 0) * 2]
for i in range(n - 1):
	c.append(a[i + 1] - a[i])
c.append((l - a[-1]) * 2)
p = max(c)
print('{0:.10f}'.format(p / 2))


(n, l) = map(int, input().split())
li = list(map(int, input().split()))
li.sort()
cou = len(li)
max = li[0]
for i in range(cou - 1):
	if max < (li[i + 1] - li[i]) / 2:
		max = (li[i + 1] - li[i]) / 2
if max < l - li[cou - 1]:
	max = l - li[cou - 1]
print('{0:.10f}'.format(max))


(n, k) = map(int, input().split())
diff = 0
arr = sorted(list(map(int, input().split())))
for i in range(n - 1, 0, -1):
	z = arr[i] - arr[i - 1]
	if z > diff:
		diff = z
answer = max(diff / 2, arr[0] - 0, k - arr[n - 1])
print(float(answer))


n_1 = input()
n_1 = n_1.strip().split()
l = int(n_1[1])
a = input()
a = a.split()
a = list(map(int, a))
a.sort()
b = a[1:]
c = a[:-1]
d = []
for i in range(len(b)):
	d.append((b[i] - c[i]) / 2)
d.append(a[0])
d.append(l - a[-1])
print(max(d))


n = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.sort()
max = arr[0]
for i in range(n[0] - 1):
	x = (arr[i] + arr[i + 1]) / 2 - arr[i]
	max = x if x > max else max
last_mile = n[1] - arr[-1]
max = last_mile if last_mile > max else max
print(max)


(n, l) = map(int, input().split())
x = [int(i) for i in input().split()]
x.sort()
print(max([(x[k + 1] - x[k]) / 2 for k in range(len(x) - 1)] + [min(x)] + [l - max(x)]))


n_l = [int(x) for x in input().split()]
lamps = [int(x) for x in input().split()]
lamps.sort(key=None, reverse=False)
start_d = lamps[0] * 1.0
end_d = (n_l[1] - lamps[-1]) * 1.0
max_dist = 0.0
for x in range(n_l[0] - 1):
	temp = lamps[x + 1] - lamps[x]
	if temp > max_dist:
		max_dist = temp
mid_dist = max_dist * 0.5
if start_d > mid_dist and start_d > end_d:
	print(start_d)
elif mid_dist > end_d:
	print(mid_dist)
else:
	print(end_d)


(x, y) = map(int, input().split())
s = input().split()
s = [int(i) for i in s]
s.sort()
maxb = -1
for z in range(len(s) - 1):
	if s[z + 1] - s[z] > maxb:
		maxb = s[z + 1] - s[z]
l = [maxb / 2, s[0], y - s[-1]]
print(max(l))


def f(n, l, a):
	a.sort()
	(start, end) = (a[0], a[-1])
	for i in range(len(a) - 1):
		a[i] = (a[i + 1] - a[i]) / 2
	a.pop()
	a = [start] + a + [l - end]
	return max(a)
(n, l) = map(int, input().split())
a = list(map(int, input().split()))
print(f(n, l, a))


(n, l) = map(int, input().split(' '))
a = sorted(map(int, input().split(' ')))
cnt = a[0]
for i in range(1, n):
	if (a[i] - a[i - 1]) / 2 > cnt:
		cnt = (a[i] - a[i - 1]) / 2
if l - a[-1] > cnt:
	cnt = l - a[-1]
print(cnt)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
min_radius = 0
if len(arr) > 2:
	for i in range(len(arr) - 1):
		radius = (arr[i + 1] - arr[i]) / 2
		if radius > min_radius:
			min_radius = radius
else:
	min_radius = (arr[len(arr) - 1] - arr[0]) / 2
if arr[0] > min_radius:
	min_radius = arr[0]
if l - arr[len(arr) - 1] > min_radius:
	min_radius = l - arr[len(arr) - 1]
print(min_radius)


(n, l) = map(int, input().split())
x = sorted(map(int, input().split()))
d = max(min(x), l - max(x))
for i in range(n - 1):
	d = max(d, (x[i + 1] - x[i]) / 2)
print(d)


def inpNum():
	return int(input())

def inpNums():
	return map(int, input().split())

def inpList():
	return list(map(int, input().split()))
(n, l) = inpNums()
ai = sorted(inpList())
mx = max(ai[0], l - ai[-1])
for i in range(n):
	if i:
		mx = max(mx, (ai[i] - ai[i - 1]) / 2)
print(mx)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
b = []
b.append(a[0])
for i in range(n - 1):
	b.append(round((a[i + 1] - a[i]) / 2, 11))
b.append(l - a[n - 1])
b.sort()
print(b[n])


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
z = 0
i = 1
l.sort()
while i < len(l):
	x = abs(l[i] - l[i - 1])
	i = i + 1
	d = x / 2
	if d > z:
		z = d
x1 = l[0] - 0
x2 = m - l[-1]
print(max(z, x1, x2))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
minr = 0
if a[0] != 0:
	prev = -1 * a[0]
else:
	prev = 0
for i in a:
	if i - prev > minr * 2:
		minr = (i - prev) / 2
	prev = i
if a[-1] != l:
	if l - a[-1] > minr:
		minr = l - a[-1]
print('%.10f' % minr)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
max_dif = 0.0
for i in range(0, n - 1):
	max_dif = max(max_dif, arr[i + 1] - arr[i])
radius = max_dif / 2
radius = max(radius, arr[0], l - arr[-1])
print('{:.10f}'.format(radius))


(n, l) = map(int, input().split())
list_of_lantern = list(map(int, input().split()))
sort_list = sorted(list_of_lantern)
ans = max(sort_list[0], l - sort_list[n - 1])
for i in range(n - 1):
	ans = max(ans, (sort_list[i + 1] - sort_list[i]) / 2)
print(ans)


def calc_dist(nums):
	dist = list()
	i = 0
	while i < len(nums) - 1:
		dist.append(nums[i + 1] - nums[i])
		i += 1
	if dist:
		return dist
	return dist.append(0)
[n, l] = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
distances = calc_dist(a)
max_distances = list()
max_distances.append(a[0] - 0)
max_distances.append(l - a[len(a) - 1])
if distances:
	max_distances.append(max(distances) / 2)
print('{0:.10f}'.format(max(max_distances)))


(n, l) = [int(x) for x in input().split(' ')]
ls = sorted([int(x) for x in input().split(' ')])
e = max(abs(0 - ls[0]), abs(l - ls[len(ls) - 1]))
for i in range(len(ls) - 1):
	if abs(ls[i] - ls[i + 1]) / 2 > e:
		e = abs(ls[i] - ls[i + 1]) / 2
print(e)


(n, l) = [int(x) for x in input().split()]
x = [int(x) for x in input().split()]
x.sort()
m = 0
if 0 not in x:
	m = x[0]
	if l in x:
		for i in range(len(x) - 1):
			if (x[i + 1] - x[i]) / 2 > m:
				m = (x[i + 1] - x[i]) / 2
	else:
		for i in range(len(x) - 1):
			if (x[i + 1] - x[i]) / 2 > m:
				m = (x[i + 1] - x[i]) / 2
		if l - x[len(x) - 1] > m:
			m = l - x[len(x) - 1]
elif l in x:
	for i in range(len(x) - 1):
		if (x[i + 1] - x[i]) / 2 > m:
			m = (x[i + 1] - x[i]) / 2
else:
	for i in range(len(x) - 1):
		if (x[i + 1] - x[i]) / 2 > m:
			m = (x[i + 1] - x[i]) / 2
	if l - x[len(x) - 1] > m:
		m = l - x[len(x) - 1]
print('%.9f' % m)


(n, l) = map(int, input().split())
arr = [int(i) for i in input().split()]
arr.sort()
res = 2 * max(arr[0], l - arr[n - 1])
for i in range(1, n):
	res = max(res, arr[i] - arr[i - 1])
print('%.10f' % (res / 2.0))


nm = [int(s) for s in input().split()]
n = nm[0]
m = nm[1]
arr = []
l = [int(s) for s in input().split()]
arr.extend(l)
maxi = -100000
arr.sort()
for i in range(1, len(arr)):
	maxi = max(maxi, arr[i] - arr[i - 1])
print(max([maxi / 2, arr[0] - 0, m - arr[-1]]))


(n, l) = map(int, input().split())
lamps = sorted(list(map(int, input().split())))
max_distanse = 0
for i in range(1, n):
	if lamps[i] - lamps[i - 1] > max_distanse:
		max_distanse = lamps[i] - lamps[i - 1]
light = [max_distanse / 2, lamps[0], l - lamps[n - 1]]
print(max(light))


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a = sorted(a)
max_d = 0
for i in range(len(a) - 1):
	if a[i + 1] - a[i] > max_d:
		max_d = a[i + 1] - a[i]
print('%.10f' % max(float(max_d / 2), max(a[0], l - a[n - 1])))


from collections import namedtuple
TaskInputs = namedtuple('TaskInputs', ['road_length', 'lamps_count', 'lamps'])

class TaskConditionsError(Exception):

	def __init__(self, condition):
		assert isinstance(condition, str)
		self.condition = condition

	def __str__(self):
		return 'Violated task condition: {}'.format(self.condition)

def get_task_inputs():
	input_raws = [input().split(), input().split()]
	try:
		lamps_count = int(input_raws[0][0])
	except KeyError:
		raise TaskConditionsError('two values on the first input line')
	except TypeError:
		raise TaskConditionsError('n is an integer')
	if not 1 <= lamps_count <= 1000:
		raise TaskConditionsError('1 <= n <= 1000')
	try:
		road_length = int(input_raws[0][1])
	except KeyError:
		raise TaskConditionsError('two values on the first input line')
	except TypeError:
		raise TaskConditionsError('l is an integer')
	if not 1 <= road_length <= 1000000000:
		raise TaskConditionsError('1 <= l <= 10^9')
	lamps = []
	for i in range(lamps_count):
		try:
			lamp_pos = int(input_raws[1][i])
		except IndexError:
			raise TaskConditionsError('l values on the second input line ({} given, l={})'.format(i, road_length))
		except TypeError:
			raise TaskConditionsError('lamp position is an integer')
		if not 0 <= lamp_pos <= road_length:
			raise TaskConditionsError('0 <= ai <= l')
		lamps.append(lamp_pos)
	return TaskInputs(road_length=road_length, lamps_count=lamps_count, lamps=lamps)
inputs = get_task_inputs()
min_light = None
if inputs.lamps_count == 1:
	min_light = max(inputs.lamps[0], inputs.road_length - inputs.lamps[0])
else:
	max_dist = 0
	sorted_lamps = sorted(inputs.lamps)
	for i in range(inputs.lamps_count):
		is_ever_left = i == 0
		is_ever_right = i == inputs.lamps_count - 1
		left_neighbor = 0 if is_ever_left else sorted_lamps[i - 1]
		right_neighbor = inputs.road_length if is_ever_right else sorted_lamps[i + 1]
		dist_to_left = sorted_lamps[i] - left_neighbor
		dist_to_right = right_neighbor - sorted_lamps[i]
		if is_ever_left:
			dist_to_left *= 2
		if is_ever_right:
			dist_to_right *= 2
		if dist_to_left >= dist_to_right:
			if dist_to_left > max_dist:
				max_dist = dist_to_left
		elif dist_to_right > max_dist:
			max_dist = dist_to_right
	assert max_dist > 0
	min_light = max_dist / 2.0
print(min_light)


nl = list(map(int, input().split()))
n = nl[0]
l = nl[1]
ls = list(map(int, input().split()))
ls.sort()
d = ls[0]
for i in range(1, n):
	cur_dist = ls[i] - ls[i - 1]
	d = max(d, cur_dist / 2)
d = max(d, l - ls[-1])
print(d)


(m, n) = map(int, input().split())
l = sorted(list(map(int, input().split())))
if m == 1:
	a = max(l[0], n - l[0])
else:
	k = [(l[x] - l[x - 1]) / 2 for x in range(1, m)]
	a = max(max(k), l[0], n - l[-1])
print('{0:.10f}'.format(a))


def main(n, l, a):
	a = sorted(a)
	mx = max([a[0], l - a[-1]] + [(y - x) / 2 for (x, y) in zip(a[:-1], a[1:])])
	print(mx)

def main_input():
	(n, l) = [int(i) for i in input().split()]
	a = [int(i) for i in input().split()]
	main(n, l, a)
main_input()


(n, l) = [int(x) for x in input().split()]
a = list(map(int, input().split(' ')))
a.sort()
adiff = 0
if a[0] != 0:
	adiff = a[0]
if a[len(a) - 1] != l:
	adiff = max(adiff, l - a[len(a) - 1])
diff = 0
for i in range(1, len(a)):
	diff = max(diff, a[i] - a[i - 1])
print(float(max(diff / 2, adiff)))


(n, l) = map(int, input().split())
a = input().split()
b = len(a)
a.sort()
ab = 0
bc = b
rez = 0
rez2 = float(0)
a = list(map(int, a))
a.sort()
if n > 1:
	rez = max((abs(x - y) for (x, y) in zip(a[1:], a[:-1])))
maxas = float(max(a))
minas = float(min(a))
rez2 = rez / 2
if minas > rez2 and minas != 0:
	rez2 = minas
if l - maxas > rez2:
	rez2 = l - maxas
print(rez2)


(n, a) = map(int, input().split())
if n == 1:
	t = int(input())
	print(max(a - t, t - 0))
else:
	l = list(map(int, input().split()))
	l.sort(reverse=True)
	if 0 in l and a in l:
		t = []
		for i in range(n - 1):
			t.append((l[i] - l[i + 1]) / 2)
		print(max(t))
	else:
		t = []
		for i in range(n - 1):
			t.append((l[i] - l[i + 1]) / 2)
		t.append(l[-1] - 0)
		t.append(a - l[0])
		print(max(t))


a = input().split()
n = int(a[0])
l = int(a[1])
a = input().split()
for i in range(n):
	a[i] = int(a[i])
a = sorted(a)
max_dist = 0
for i in range(n - 1):
	max_dist = max(max_dist, a[i + 1] - a[i])
max_dist = max(a[0], max_dist / 2, l - a[n - 1])
print(max_dist)


a = input()
f = a.split()
b = int(f[1])
e = input()
c = e.split()
g = []
for i in range(len(c)):
	c[i] = int(c[i])
c.sort(reverse=False)
if len(c) > 1:
	for i in range(len(c) - 1):
		g.append(c[i + 1] - c[i])
	g.sort(reverse=True)
	if g[0] / 2 > c[0]:
		d = g[0] / 2
	else:
		d = c[0]
else:
	d = c[0]
if d > b - c[len(c) - 1]:
	d = d
else:
	d = b - c[len(c) - 1]
print(d)


(n, length) = map(int, input().split())
locations = [int(a) for a in input().split()]
locations = sorted(locations)
radius = []
for (i, loc) in enumerate(locations):
	if i >= 1:
		radius.append(abs(loc - locations[i - 1]))
radius.append(2 * locations[0] - 0)
radius.append(2 * (length - locations[-1]))
print(max(radius) / 2)


(n, l) = map(int, input().split())
lanterns = sorted(list(map(int, input().split())))
max_d = 0
for i in range(1, n):
	d = lanterns[i] - lanterns[i - 1]
	if d > max_d:
		max_d = d
max_d = max_d / 2
left_dist = lanterns[0] - 0.0
right_dist = l - lanterns[n - 1]
needed_dist = max(left_dist, right_dist)
if max_d < needed_dist:
	max_d = needed_dist
print(max_d)


(n, l) = map(int, input().split())
a = [int(i) for i in input().split()]
d = []
a.sort()
for i in range(len(a) - 1):
	d.append(a[i + 1] - a[i])
if n == 1:
	if a[0] == l or a[0] == 0:
		print(l)
	elif a[0] < l / 2:
		print(l - a[0])
	elif a[0] > l / 2:
		print(a[0])
else:
	p = [l - max(a), min(a), max(d) / 2]
	print(max(p))


(n, l) = [int(x) for x in input().split()]
k = [int(x) for x in input().split()]
k.sort()
p = []
sf = 0
if n != 1:
	for i in range(n - 1):
		p.append(abs(k[i] - k[i + 1]))
	sf = max(p) / 2
m = max([sf, l - k[-1], k[0] - 0])
print('{:.10f}'.format(m))


nl = [int(i) for i in input().split()]
l = nl[1]
lan = [int(i) for i in input().split()]
lans = sorted(lan)
list = []
if lans[0] == 0 and lans[len(lans) - 1] == l:
	for i in range(len(lans)):
		if i == len(lans) - 1:
			break
		list.append((lans[i + 1] - lans[i]) / 2)
elif lans[0] != 0 and lans[len(lans) - 1] != l:
	for i in range(len(lans)):
		if i == len(lans) - 1:
			break
		list.append((lans[i + 1] - lans[i]) / 2)
	list.append(lans[0] - 0)
	list.append(l - lans[len(lans) - 1])
elif lans[0] != 0 and lans[len(lans) - 1] == l:
	for i in range(len(lans)):
		if i == len(lans) - 1:
			break
		list.append((lans[i + 1] - lans[i]) / 2)
	list.append(lans[0] - 0)
else:
	for i in range(len(lans)):
		if i == len(lans) - 1:
			break
		list.append((lans[i + 1] - lans[i]) / 2)
	list.append(l - lans[len(lans) - 1])
max = list[0]
for i in list:
	if i > max:
		max = i
print(max)


(n, l) = input().split(' ')
l = int(l)
listOfLaterns = list(map(int, input().split(' ')))
listOfLaterns.sort()
min = listOfLaterns[0]
for i in range(len(listOfLaterns) - 1):
	distance = (listOfLaterns[i + 1] - listOfLaterns[i]) / 2
	if distance > min:
		min = distance
if l - listOfLaterns[-1] > min:
	min = l - listOfLaterns[-1]
print(min)


import sys
data = sys.stdin.readline()
(n_lan, street_len) = data.split(' ')
n_lan = int(n_lan)
street_len = int(street_len)
data = sys.stdin.readline()
lan_locs = [int(i) for i in data.split(' ')]
lan_locs.sort()
i = 0
max_len = 0
while i < n_lan - 1:
	if lan_locs[i + 1] - lan_locs[i] > max_len:
		max_len = abs(lan_locs[i + 1] - lan_locs[i])
	i += 1
max_len /= 2
if lan_locs[0] - 0 > max_len:
	max_len = lan_locs[0]
if street_len - lan_locs[n_lan - 1] > max_len:
	max_len = street_len - lan_locs[n_lan - 1]
sys.stdout.write(str(max_len))


(n, l) = map(int, input().split())
cords = list(map(int, input().split()))
cords = sorted(cords)
diffs = cords.copy()
for i in range(len(cords)):
	if i == 0:
		diffs[i] = 0
	else:
		diffs[i] = cords[i] - cords[i - 1]
nearSolution = max(diffs) / 2
farSolution = max(cords[0], l - cords[-1])
print(max(nearSolution, farSolution))


def min_d(coordinates, l):
	minimum_d = max(coordinates[0] - 0, l - coordinates[-1])
	for i in range(len(coordinates) - 1):
		if minimum_d < (coordinates[i + 1] - coordinates[i]) / 2:
			minimum_d = (coordinates[i + 1] - coordinates[i]) / 2
	return float(minimum_d)
(n, l) = map(int, input().split())
coordinates = list(map(int, input().split()))
coordinates.sort()
print('{:.9f}'.format(min_d(coordinates, l)))


mas_1 = input().split()
(n, l) = (int(mas_1[0]), int(mas_1[1]))
num = input().split()
lanterns = sorted([int(n) for n in num if n.isdigit()])
min_r = 0
for i in range(1, len(lanterns)):
	dif = (lanterns[i] - lanterns[i - 1]) / 2
	if dif > min_r:
		min_r = dif
dif = lanterns[0]
if dif > min_r:
	min_r = dif
dif = l - lanterns[len(lanterns) - 1]
if dif > min_r:
	min_r = dif
print(min_r)


from sys import stdin, stdout
from math import ceil, floor, sqrt
from collections import deque, Counter
inp = stdin.readline
out = stdout.write
(n, l) = map(int, inp().strip().split())
a = list(map(int, inp().strip().split()))
a.sort()
md = 0
for i in range(1, n):
	d = a[i] - a[i - 1]
	if d > md:
		md = d
md /= 2
(m1, m2) = (a[0] - 0, l - a[-1])
s = max(md, m1, m2)
out(str(s))


(_, l) = map(int, input().split())
lanterns = sorted(set(map(int, input().split())))
print(max(lanterns[0], l - lanterns[-1], *((j - i) / 2 for (i, j) in zip(lanterns, lanterns[1:]))))


(n, l) = list(map(int, input().split(' ')))
pos = list(map(int, input().split(' ')))
checkS = 0
checkD = 0
if 0 in pos:
	checkS = 1
if l in pos:
	checkD = 1
pos.sort()
maxD = 0
for i in range(n - 1):
	s = pos[i + 1] - pos[i]
	maxD = max(maxD, s)
r = maxD / 2
if checkS == 0 or checkD == 0:
	test1 = pos[0]
	test2 = l - pos[n - 1]
	r = max(r, test1, test2)
print('{0:0.9f}'.format(r))


from typing import List
from decimal import Decimal, getcontext

class Solution:

	@classmethod
	def solve(cls, n: int, l: int, positions: List[int]) -> int:
		getcontext().prec = 10
		rev_positions = sorted(positions, reverse=True)
		max_dist = Decimal(0)
		for i in range(n - 1):
			diff = Decimal(abs(rev_positions[i + 1] - rev_positions[i]))
			if diff > max_dist:
				max_dist = diff
		lower_bound = l - rev_positions[0]
		upper_bound = rev_positions[n - 1] - 0
		result = max(max_dist / Decimal(2.0), Decimal(max(lower_bound, upper_bound)))
		print(result)
[n, l] = list(map(lambda x: int(x), input().split(' ')))
positions = list(map(lambda x: int(x), input().split(' ')))
Solution.solve(n, l, positions)


def radix_sort(A):
	rad = 1
	while rad <= max(A):
		radix = [[] for i in range(10)]
		for i in range(len(A)):
			radix[A[i] // rad % 10] += [A[i]]
		A = []
		for i in range(len(radix)):
			A += radix[i]
		rad *= 10
	return A
(n, l) = input().split()
n = int(n)
l = int(l)
A = [int(i) for i in input().split()]
A = radix_sort(A)
dis = []
if A[0] != 0:
	dis += [A[0]]
if A[len(A) - 1] != l:
	dis += [l - A[len(A) - 1]]
for i in range(len(A) - 1):
	dis += [(A[i + 1] - A[i]) / 2.0]
print(max(dis))


(n, m) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
z = len(a)
a.sort()
min = 0
for i in range(0, z - 1):
	if min < a[i + 1] - a[i]:
		min = a[i + 1] - a[i]
if a[0] > float(min / 2):
	min = a[0]
else:
	min = float(min / 2)
if min < m - a[n - 1]:
	min = m - a[n - 1]
print(min)


(n, l) = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
arr.sort()
maximum = 0
for j in range(n - 1):
	if arr[j + 1] - arr[j] > maximum:
		maximum = arr[j + 1] - arr[j]
print(max(maximum / 2, arr[0], l - arr[-1]))


(n, l) = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
c = max(A[0] - 0, l - A[-1])
d = 0
for i in range(len(A) - 1):
	d = max(A[i + 1] - A[i], d)
print(max(c, d / 2))


l1 = input()
res = [int(i) for i in l1.split() if i.isdigit()]
n = res[0]
l = res[1]
l2 = input()
lt = [int(i) for i in l2.split() if i.isdigit()]
lt = sorted(lt)
if 0 in lt and l in lt:
	max_diff = -1
	for i in range(len(lt) - 1):
		if lt[i + 1] - lt[i] > max_diff:
			max_diff = lt[i + 1] - lt[i]
	print(max_diff / 2)
if 0 in lt and l not in lt:
	max_diff = 2 * (l - lt[-1])
	lt.append(l)
	lt = sorted(lt)
	for i in range(len(lt) - 1):
		if lt[i + 1] - lt[i] > max_diff:
			max_diff = lt[i + 1] - lt[i]
	print(max_diff / 2)
if 0 not in lt and l in lt:
	max_diff = 2 * lt[0]
	lt.append(0)
	lt = sorted(lt)
	for i in range(len(lt) - 1):
		if lt[i + 1] - lt[i] > max_diff:
			max_diff = lt[i + 1] - lt[i]
	print(max_diff / 2)
if 0 not in lt and l not in lt:
	max_diff = 2 * max(lt[0], l - lt[-1])
	lt.append(0)
	lt.append(l)
	lt = sorted(lt)
	for i in range(len(lt) - 1):
		if lt[i + 1] - lt[i] > max_diff:
			max_diff = lt[i + 1] - lt[i]
	print(max_diff / 2)


import math
s = input().split()
(n, l) = (int(s[0]), int(s[1]))
a = input().split()
a = [int(a) for a in a]
a.sort()
ans = max(a[0], l - a[n - 1])
for i in range(n - 1):
	ans = max(ans, (a[i + 1] - a[i]) / 2)
print('%.9f' % ans)


(n, l) = map(int, input().split())
lamps = list(map(int, input().split()))
lamps = sorted(lamps)
diff = []
if n == 1:
	print(max(lamps[0], l - lamps[0]))
else:
	for i in range(n - 1):
		diff.append(lamps[i + 1] - lamps[i])
	print(max(lamps[0], l - lamps[-1], max(diff) / 2))


__author__ = 'PrimuS'
(n, l) = (int(x) for x in input().split())
a = [int(x) for x in input().split()]
a.sort()
k = len(a)
d = max(a[0], l - a[len(a) - 1])
for i in range(k - 1):
	dd = (a[i + 1] - a[i]) / 2
	d = max(d, dd)
print(d)


(lights, street_length) = list(map(int, input().split()))
pos = sorted(list(map(int, input().split())))
dist = [y - x for (x, y) in zip(pos[:-1], pos[1:])]
if len(dist) > 0:
	print(max(pos[0], max(dist) / 2, street_length - pos[-1]))
else:
	print(max(pos[0], street_length - pos[-1]))


l1 = input().split()
k = int(l1[0])
n = int(l1[1])
l = input().split()
l_new = []
for i in range(len(l)):
	l_new.append(int(l[i]))
l_new.sort()
l_new.insert(0, 0)
l_new.insert(len(l_new), n)
l2 = []
for i in range(1, len(l_new) - 2):
	m = int(l_new[i + 1]) - int(l_new[i])
	l2.append(m / 2)
l2.append(int(l_new[1]) - int(l_new[0]))
l2.append(int(l_new[-1]) - int(l_new[-2]))
l2.sort()
a = l2[-1]
print('%.10f' % a)


[n, l] = [int(i) for i in input().split()]
a = [int(j) for j in input().split()]
a.sort()
x = a[0] - 0
y = l - a[len(a) - 1]
maxi = -2
for p in range(n - 1):
	maxi = max((a[p + 1] - a[p]) / 2, maxi)
print(max(maxi, x, y))


first = input()
second = input()
n_and_l = first.split()
position = second.split()
n = int(n_and_l[0])
l = int(n_and_l[1])
for i in range(len(position)):
	position[i] = int(position[i])
position.sort()
r = position[0] - 0
if l - position[-1] > r:
	r = l - position[-1]
for i in range(len(position) - 1):
	if (position[i + 1] - position[i]) / 2 > r:
		r = (position[i + 1] - position[i]) / 2
print(r)


(n, l) = map(int, input().split())
a = sorted(map(int, input().split()))
d = 0
for i in range(n - 1):
	d = max(d, a[i + 1] - a[i])
d *= 0.5
print('%.10f' % max(d, a[0], l - a[-1]))


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
d = 0
if n == 1 and a[0] <= l / 2:
	d = abs(l - a[0])
elif n == 1 and a[0] > l / 2:
	d = a[0]
elif n == 1 and a[0] == l:
	d = l
else:
	for i in range(n):
		if i == 0:
			akhir = (a[i + 1] - a[i]) / 2
			for j in range(3):
				if a[i] - 0 > akhir and a[i] - 0 > d:
					d = a[i] - 0
				elif akhir > a[i] - 0 and akhir > d:
					d = akhir
		elif i == n - 1:
			awal = (a[i] - a[i - 1]) / 2
			for j in range(3):
				if awal > l - a[i] and awal > d:
					d = awal
				elif l - a[i] > awal and l - a[i] > d:
					d = l - a[i]
		elif i < n - 1 and i > 0:
			awal = (a[i] - a[i - 1]) / 2
			akhir = (a[i + 1] - a[i]) / 2
			for j in range(3):
				if awal > akhir and awal > d:
					d = awal
				elif akhir > awal and akhir > d:
					d = akhir
print('%.10f' % d)


(n, l) = list(map(int, input().split()))
lanters = list(sorted(list(map(int, input().split()))))
max_distance = max(lanters[0] - 0, l - lanters[n - 1])
for k in range(1, n):
	max_distance = max(max_distance, (lanters[k] - lanters[k - 1]) / 2)
print(max_distance)


a = list(map(int, input('').split(' ')))
List = list(map(int, input('').split(' ')))
List.sort()
Max = 0
for i in range(len(List) - 1):
	Diff = (List[i + 1] - List[i]) / 2
	Max = max(Diff, Max)
Begin = List[0]
End = a[1] - List[-1]
Max = max(Max, Begin, End)
print(Max)


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
temp = []
if len(a) != 1:
	for i in range(n - 1):
		temp.append((a[i + 1] - a[i]) / 2)
	temp2 = max([max(temp), a[0] - 0, l - a[n - 1]])
else:
	temp2 = max([a[0] - 0, l - a[0]])
print('{0:.9f}'.format(temp2))


def solve(li, m, n):
	li.sort()
	x = li[0] - 0
	y = m - li[n - 1]
	max_dist = 0
	for i in range(1, n):
		a = li[i] - li[i - 1]
		if max_dist < a:
			max_dist = a
	return max(max_dist / 2, max(x, y))
(n, m) = map(int, input().split())
li = list(map(int, input().split()))
result = solve(li, m, n)
print(result)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
d = []
d.append(a[0])
d.append(l - a[n - 1])
for i in range(1, n):
	d.append(a[i] - a[i - 1])
if max(d) / 2 >= a[0] and max(d) / 2 >= l - a[n - 1]:
	print(max(d) / 2)
else:
	print(max(a[0], l - a[n - 1]))


(n, length) = map(int, input().split())
lights = list(map(int, input().split()))
lights.sort()
d = max(lights[0], length - lights[n - 1])
for i in range(1, n):
	d = max(d, (lights[i] - lights[i - 1]) / 2)
print(d)


(n, l) = map(int, input().split())
points = list(map(int, input().split()))
points = sorted([-min(points)] + points + [2 * l - max(points)])
print(max((points[i + 1] - points[i] for i in range(len(points) - 1))) / 2)


(n, l) = map(int, input().split())
a = sorted(map(int, input().split()))
dist = [0]
dist.extend([a[i + 1] - a[i] for i in range(n - 1)])
m = max(dist)
n = max(a[0] - 0, l - a[-1])
if m / 2 < n:
	print(format(n, '.10f'))
else:
	print(format(max(dist) / 2, '.10f'))


(l, td) = map(int, input().split())
lp = list(map(int, input().split()))
lp = sorted(lp)
d = []
if l == 1:
	if td == lp[0]:
		print(lp[0])
	else:
		print(max(lp[0], td - lp[0]))
else:
	for i in range(0, len(lp) - 1):
		d.append(lp[i + 1] - lp[i])
	tr = max(d)
	if lp[0] != 0 and lp[-1] != td:
		print(max(lp[0], td - lp[-1], tr / 2))
	elif lp[0] != 0:
		print(max(lp[0], tr / 2))
	elif lp[-1] != 0:
		print(max(td - lp[-1], tr / 2))
	else:
		print(tr / 2)


(n, l) = map(int, input().split())
list_of_latterns = sorted(list(map(int, input().split())))
if l - list_of_latterns[-1] > list_of_latterns[0]:
	biggest_dif = (l - list_of_latterns[-1]) * 2
else:
	biggest_dif = 2 * list_of_latterns[0]
for i in range(1, n):
	if list_of_latterns[i] - list_of_latterns[i - 1] > biggest_dif:
		biggest_dif = list_of_latterns[i] - list_of_latterns[i - 1]
print(biggest_dif / 2)


aux = input()
aux = list(aux.split())
aux = [int(x) for x in aux]
n = aux[0]
l = aux[1]
lanterne = input()
lanterne = list(lanterne.split())
lanterne = [int(x) for x in lanterne]
lanterne.sort()
d = lanterne[0]
for i in range(1, len(lanterne)):
	daux = (lanterne[i] - lanterne[i - 1]) / 2
	if daux > d:
		d = daux
daux = l - lanterne[-1]
if daux > d:
	d = daux
print(d)


(n, l) = input().split()
n = int(n)
l = int(l)
arr = [int(x) for x in input().split()]
arr.sort()
m = -1
for i in range(1, n):
	if arr[i] - arr[i - 1] > m:
		m = arr[i] - arr[i - 1]
if m / 2.0 > arr[0] and m / 2.0 > l - arr[n - 1]:
	print(m / 2.0)
else:
	print(max(arr[0], l - arr[n - 1]))


isDebug = False
(n, l) = input().split(' ')
n = int(n)
l = int(l)
print(f'n={n}, l={l}') if isDebug else ''
a = input().split(' ')
a = [float(i) for i in a]
print(f'a={a}') if isDebug else ''
a = sorted(a)
print(f'a={a}') if isDebug else ''
m1 = a[0] - 0
m2 = -1
m3 = l - a[n - 1]
for i in range(0, len(a) - 1):
	r = abs(a[i] - a[i + 1])
	m2 = m2 if m2 > r else r
m2 = m2 / 2
print(f'm1={m1}, m2={m2}, m3={m3}') if isDebug else ''
m = m1
m = m if m > m2 else m2
m = m if m > m3 else m3
print(f'm={m}') if isDebug else ''
print(f'{m:.10f}')


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort(reverse=True)
max_distance = []
max_distance.append((l - a[0]) * 2)
max_distance.append(a[-1] * 2)
for i in range(n - 1):
	max_distance.append(a[i] - a[i + 1])
print(float(max(max_distance) / 2))


(n, l) = map(int, input().split(' '))
a = map(int, input().split(' '))
a = sorted(list(set(a)))
b = []
left = a[0] - 0
right = l - a[-1]
for i in reversed(range(len(a))):
	if i != 0:
		b.append(a[i] - a[i - 1])
if b:
	ans = max(b) / 2
else:
	ans = -1
print(max([ans, left, right]))


import math

def input_values(f):
	return map(f, input().split())

def main():
	(n, l) = input_values(int)
	a = list(input_values(int))
	a.sort()
	maxDist = max(2 * (a[0] - 0), 2 * (l - a[-1]))
	for i in range(1, n):
		maxDist = max(maxDist, a[i] - a[i - 1])
	print(maxDist / 2)
main()


entrada = input().split()
n = int(entrada[0])
l = int(entrada[1])
entrada = input().split()
a = [int(i) for i in entrada]
a.sort()
raio = a[0]
aux = l - a[n - 1]
if aux > raio:
	raio = aux
if n > 1:
	while n > 0:
		aux = (a[n - 1] - a[n - 2]) / 2
		if aux > raio:
			raio = aux
		n -= 1
print(raio)


(t, l) = map(int, input().rstrip().split())
lanterns = list(map(int, input().rstrip().split()))
lanterns.sort()
if len(lanterns) == 1:
	print(max(lanterns[0] - 0, l - lanterns[t - 1]))
else:
	maxDistance = lanterns[1] - lanterns[0]
	for i in range(1, len(lanterns)):
		if maxDistance < lanterns[i] - lanterns[i - 1]:
			maxDistance = lanterns[i] - lanterns[i - 1]
	print(max(maxDistance / 2, max(lanterns[0] - 0, l - lanterns[t - 1])))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
if a[0] == 0:
	mx = -1
	for i in range(1, n):
		m = (a[i] - a[i - 1]) / 2
		if m > mx:
			mx = m
if a[0] != 0:
	mx = a[0]
	for i in range(1, n):
		m = (a[i] - a[i - 1]) / 2
		if m > mx:
			mx = m
if a[-1] != l:
	k = l - a[-1]
	if k > mx:
		mx = k
print(mx)


(n, l) = map(int, input().split())
s = sorted(list(map(int, input().split())))
d = 0
for i in range(len(s) - 1):
	if d < s[i + 1] - s[i]:
		d = s[i + 1] - s[i]
print(d / 2 if d / 2 >= max([s[0], l - s[-1]]) else max([s[0], l - s[-1]]))


(n, l) = input().split()
n = int(n)
l = int(l)
lantern_position = list(map(int, input().split()))
lantern_position.sort()
delta = [lantern_position[i] - lantern_position[i - 1] for i in range(1, n)]
last = l - lantern_position[-1]
first = lantern_position[0]
if len(delta) != 0:
	delta_max = max(delta)
else:
	delta_max = 0
print(max(delta_max / 2, first, last))


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
r = max(a[0], l - a[-1])
for i in range(1, n):
	d = a[i] - a[i - 1]
	r = max(r, d / 2)
print('{:.10f}'.format(r))


import math

def inp():
	return int(input())

def inlist():
	return list(map(int, input().split()))

def instr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())
(n, l) = invr()
a = inlist()
a = sorted(a)
d = 0
if 0 not in a:
	d = a[0]
if l not in a:
	d = max(l - a[n - 1], d)
sz = len(a)
for i in range(sz - 1):
	d = max(d, (a[i + 1] - a[i]) / 2)
print(float(d))


(n, l) = map(int, input().split())
lantern = [int(x) for x in input().split()]
lantern.sort()
l1 = lantern[0]
l2 = l - lantern[-1]
try:
	s = lantern[1] - lantern[0]
	for i in range(1, n):
		si = lantern[i] - lantern[i - 1]
		s = max(s, si)
except:
	s = lantern[0]
print(max(l1, l2, s / 2))


n = list(map(int, input().split()))
lamp = list(map(int, input().split()))
lamp.sort()
maximum = 0
result = 0
check = max(lamp[0], n[1] - lamp[len(lamp) - 1])
for i in range(len(lamp) - 1):
	maximum = max(maximum, lamp[i + 1] - lamp[i])
result = maximum / 2
print(max(check, result))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
result = 0
m = [0]
for i in range(n - 1):
	j = a[i + 1] - a[i]
	m.append(j)
m = max(m)
n = max(a[0], l - a[n - 1])
print(format(max(m / 2, n), '.10f'))


import sys
f = sys.stdin
(n, m) = map(int, f.readline().rstrip().split())
coods = list(map(int, f.readline().rstrip().split()))
coods = sorted(coods)
dis = list()
for i in range(n):
	if i == 0:
		dis.append(coods[0])
	dis.append((coods[i] - coods[i - 1]) / 2.0)
dis.append(m - coods[-1])
dis = sorted(dis, reverse=True)
print(dis[0])


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
p = arr[0]
q = l - arr[n - 1]
r = max(p, q)
m = 0
for i in range(n - 1):
	if arr[i + 1] - arr[i] > m:
		m = arr[i + 1] - arr[i]
if r > m // 2:
	print(round(r, 10))
else:
	print(round(m / 2, 10))


(n, l) = map(int, input().split(' '))
L = list(map(int, input().split(' ')))
L.sort()
ans = max(L[0], l - L[-1])
for i in range(1, len(L)):
	d = L[i] - L[i - 1]
	ans = max(ans, d / 2)
print(ans)


(n, l) = map(int, input().split())
line = map(int, input().split())
line = sorted(line)
r1 = line[0]
r2 = l - line[-1]
if n == 1:
	output = max(r1, r2)
else:
	ds = []
	for i in range(1, n):
		d = (line[i] - line[i - 1]) / 2
		ds.append(d)
	r3 = max(ds)
	output = max(r1, r2, r3)
print('%.10f' % output)


import math
(n, l) = input().split()
n = int(n)
l = int(l)
lights = input().split()
dist = []
for i in range(0, n):
	lights[i] = int(lights[i])
if n == 1:
	print(max(l - lights[n - 1], lights[0]))
else:
	lights.sort()
	for i in range(0, n - 1):
		dist.append(math.fabs(lights[i] - lights[i + 1]))
	print(max(max(dist) / 2, l - lights[n - 1], lights[0]))


(n, l) = map(int, input().split())
a = [int(i) for i in input().split()]
a = sorted(set(a))
radius = 0
for i in range(len(a) - 1):
	if (a[i + 1] - a[i]) / 2 > radius:
		radius = (a[i + 1] - a[i]) / 2
if a[0] > radius:
	radius = a[0]
if l - a[-1] > radius:
	radius = l - a[-1]
print(radius)


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
M = -1
for i in range(n - 1):
	x = abs(a[i] - a[i + 1])
	if x > M:
		M = x
print(max(abs(a[0] - 0), abs(l - a[-1]), M / 2))


(a, b) = [int(i) for i in input().split(' ')]
l = sorted([int(i) for i in input().split(' ')])
l1 = []
l1 = [(l[j + 1] - l[j]) / 2 for j in range(0, len(l) - 1)]
l1.append(l[0] - 0)
l1.append(b - l[-1])
print(float(max(l1)))


(n, l) = map(int, input().split())
s = sorted(list(map(int, input().split())))
s2 = max([s[i + 1] - s[i] for i in range(n - 1)]) if n > 1 else 0
r = max(s2 / 2, s[0], l - s[-1])
print(r)


(n, k) = map(int, input().split())
(z, p) = (0, 0)
l = sorted(list(map(int, input().split())))
for i in range(n - 1):
	p = abs(l[i] - l[i + 1])
	z = max(p, z)
z /= 2
lower = abs(l[0] - 0)
upper = abs(k - l[-1])
print(max(lower, upper, z))


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
first = min(a)
last = max(a)
d1 = first
d2 = l - last
m = max(d1, d2)
for i in range(n - 1):
	l1 = a[i]
	l2 = a[i + 1]
	r = abs(l2 - l1)
	if r / 2 > m:
		m = r / 2
print(m)


import sys
it = iter(sys.stdin.read().splitlines())
(n, l) = [int(x) for x in next(it).split()]
numbers = [int(x) for x in next(it).split()]
numbers.sort()
dif = 0
tempDif = 0
for i in range(len(numbers) - 1):
	subs = numbers[i + 1] - numbers[i]
	if subs > dif:
		dif = subs
dif = dif / 2.0
if numbers[0] > dif:
	dif = numbers[0]
if numbers[n - 1] + dif < l:
	dif = l - numbers[n - 1]
print(dif)


(n, l) = map(int, input().split())
li = list(map(int, input().split()))
li.sort()
maxx = 0
d = 0
x = li[0] - 0
y = l - li[-1]
i = 1
while i < n:
	diff = li[i] - li[i - 1]
	if diff > maxx:
		maxx = diff
	i += 1
d = max(maxx / 2, max(x, y))
print(d)


(n, l) = list(map(int, input().split(' ')))
locations = list(map(int, input().split(' ')))
locations.sort()
diff = []
for i in range(1, len(locations)):
	diff.append(locations[i] - locations[i - 1])
between_lights = 0
if diff:
	between_lights = max(diff) / 2
max_end_gap = max(locations[0], l - locations[-1])
if max_end_gap < between_lights:
	print('{0:.10f}'.format(between_lights))
else:
	print('{0:.10f}'.format(max_end_gap))


(n, m) = map(int, input().split())
l = sorted(list(map(int, input().split())))
z = 1
for x in range(1, len(l)):
	z = max(z, l[x] - l[x - 1])
if min(l) > z / 2 and m - max(l) < min(l):
	print(min(l))
elif m - max(l) > z / 2:
	print(m - max(l))
else:
	print(z / 2)


(n, m) = [int(i) for i in input().split()]
nums = sorted([int(i) for i in input().split()])
distance = max(nums[0], m - nums[-1]) * 2
for i in range(1, n):
	if nums[i] - nums[i - 1] > distance:
		distance = nums[i] - nums[i - 1]
print(distance / 2)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
maxdist = 0
for i in range(len(a) - 1):
	maxdist = max(abs(a[i + 1] - a[i]), maxdist)
print(max(maxdist / 2, a[0], l - a[n - 1]))


(a, b) = list((int(x) for x in input().split()))
c = list((int(x) for x in input().split()))
c.sort()
d = [c[0], b - c[-1]]
for i in range(1, a):
	d.append((c[i] - c[i - 1]) / 2)
print(format(max(d), '.10f'))


(n, l) = list(map(int, input().split(' ')))
posis = list(map(int, input().split(' ')))
posis = list(set(posis))
posis.sort()
to_left = posis[0] - 0
to_right = l - posis[-1]
delta = 0
for i in range(1, len(posis)):
	if delta < posis[i] - posis[i - 1]:
		delta = posis[i] - posis[i - 1]
delta /= 2
result = max(to_left, to_right)
result = max(result, delta)
print(result)


(n, l) = map(int, input().strip().split())
v = list(map(int, input().strip().split()))
v.sort()
maxi = v[0] * 2
for i in range(1, n):
	d = v[i] - v[i - 1]
	if d > maxi:
		maxi = d
d = (l - v[n - 1]) * 2
if d > maxi:
	maxi = d
print(maxi / 2)


a = list(map(int, input().split()))
b = list(map(int, input().split()))
b.sort()
ma = 0
for i in range(len(b) - 1):
	c = b[i + 1] - b[i]
	if c > ma:
		ma = c
d = max(min(b) - 0, a[1] - max(b))
print(max(d, ma / 2))


(n, l) = map(int, input().split())
x = list(map(int, input().split()))
x.sort(reverse=False)
ans = x[0]
for i in range(len(x)):
	ans = max(ans, 0.5 * (x[i] - x[i - 1]))
ans = max(ans, max(x[0] * 2, (l - x[n - 1]) * 2) / 2)
print('%.11f' % ans)


(n, l) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
for i in range(n):
	for j in range(n - 1):
		if a[j] > a[j + 1]:
			m = a[j]
			a[j] = a[j + 1]
			a[j + 1] = m
s = max(a[0] - 0, l - a[n - 1])
for i in range(n - 1):
	s = max(s, (a[i + 1] - a[i]) / 2)
print(format(s, '.10f'))


z = str(input()).split()
n = int(z[0])
l = int(z[1])
arr = []
s = str(input()).split()
for i in range(n):
	arr.append(int(s[i]))
hasil = []
arr.sort()
if arr[0] != 0:
	hasil.append(abs(0 - arr[0]))
if arr[len(arr) - 1] != l:
	hasil.append(abs(l - arr[len(arr) - 1]))
for i in range(len(arr) - 1):
	temp = (arr[i + 1] - arr[i]) / 2 + arr[i]
	hasil.append(abs(temp - arr[i]))
	hasil.append(abs(temp - arr[i + 1]))
hasil.sort()
print('%.10f' % hasil[len(hasil) - 1])


(n, l) = [int(i) for i in input().split()]
location = [int(i) for i in input().split()]
location.sort()
max_dis = max(location[0], l - location[-1])
for i in range(len(location) - 1):
	max_dis = max(max_dis, (location[i + 1] - location[i]) / 2)
print(max_dis)


nl = list(map(int, input().split()))
n = nl[0]
l = nl[1]
a = list(map(int, input().split()))
a.sort()
last = 0
max_dist = max(a[0], l - a[-1])
for elem in a:
	if (elem - last) / 2 > max_dist:
		max_dist = (elem - last) / 2
	last = elem
print(max_dist)


inp = input()
inp = inp.split()
n = int(inp[0])
l = int(inp[1])
lamps = []
inp = input()
inp = inp.split()
for i in inp:
	lamps.append(int(i))
lamps.sort()
intervals = []
intervals.append(min(lamps))
intervals.append(l - max(lamps))
for i in range(len(lamps) - 1):
	intervals.append((lamps[i + 1] - lamps[i]) / 2)
print(max(intervals))


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
d = 0
for i in range(1, n):
	if arr[i] - arr[i - 1] > d:
		d = arr[i] - arr[i - 1]
r = d / 2
ans = max(r, arr[0], l - arr[-1])
print(format(ans, '.10f'))


import math
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
a.append(0)
a.append(k)
a.sort()
res = 0.0
if a[1] != 0:
	res = a[1]
if a[len(a) - 2] != k:
	res = max(res, k - a[len(a) - 2])
for i in range(2, len(a)):
	res = max(res, (a[i] - a[i - 1]) / 2)
print(res)


(n, l) = (int(x) for x in input().rsplit())
lantern = [int(x) for x in input().rsplit()]
lantern.sort()
dis = 0
for x in range(1, n):
	if lantern[x] - lantern[x - 1] > dis:
		dis = lantern[x] - lantern[x - 1]
if dis / 2 > lantern[0] and dis / 2 > l - lantern[-1]:
	print('{:.10f}'.format(dis / 2))
elif lantern[0] > l - lantern[-1]:
	print('{:.10f}'.format(lantern[0]))
else:
	print('{:.10f}'.format(l - lantern[-1]))


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
l = sorted(l)
diff = -1
for i in range(1, n):
	if l[i] - l[i - 1] > diff:
		diff = l[i] - l[i - 1]
ans = max(diff / 2, l[0], m - l[-1])
print(ans)


def bubbleSort(arr):
	n = len(arr)
	for i in range(n):
		for j in range(0, n - i - 1):
			if arr[j] > arr[j + 1]:
				(arr[j], arr[j + 1]) = (arr[j + 1], arr[j])
(n, l) = map(int, input().split())
p = [int(x) for x in input().split()]
p.append(0)
p.append(l)
bubbleSort(p)
s = [p[1] - p[0], p[n + 1] - p[n]]
for i in range(2, n + 1):
	s.append((p[i] - p[i - 1]) / 2)
print(max(s) / 1.0)


n = [int(i) for i in input().split()]
s1 = [int(i) for i in input().split()]
l = n[1]
a = []
s = sorted(s1)
z = min(s)
x = l - max(s)
if len(set(s)) > 1:
	for i in range(1, len(s)):
		a.append(s[i] - s[i - 1])
else:
	a.append(s[0])
if x > z:
	(z, x) = (x, z)
if z < max(a) / 2:
	print(max(a) / 2)
else:
	print(z / 1)


(m, n) = map(float, input().split())
lanterns = [float(x) for x in input().split()]
lanterns.sort()
diff = []
for i in range(0, len(lanterns) - 1):
	diff.append((lanterns[i + 1] - lanterns[i]) / 2)
diff.insert(0, lanterns[0])
diff.append(n - lanterns[-1])
result = max(diff)
print('{:.10f}'.format(result))


def ok(x):
	if a[0] - m > 0 or a[n - 1] + m < long:
		return 0
	else:
		for i in range(n - 1):
			if a[i] + m < a[i + 1] - m:
				return 0
		return 1
(n, long) = map(int, input().split())
a = [int(i) for i in input().split()]
a.sort()
l = 0
r = long
for _ in range(100):
	m = (l + r) / 2
	if ok(m) == 1:
		r = m
	else:
		l = m
print(m)


def solve(n, l, a):
	a.sort()
	maxi = max([a[i] - a[i - 1] for i in range(1, len(a))], default=0)
	return max(maxi / 2, a[0] - 0, l - a[n - 1])

def main():
	(n, l) = list(map(int, input().split()))
	a = list(map(int, input().split()))
	print(solve(n, l, a))
main()


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
max_ = -1
h = abs(a[0]) - 0
e = abs(l - a[len(a) - 1])
for i in range(len(a) - 1):
	if abs(a[i + 1] - a[i]) / 2 > max_:
		max_ = abs(a[i + 1] - a[i]) / 2
if h > max_:
	max_ = h
if e > max_:
	max_ = e
print(round(max_, 9))


num = list(map(int, input().split()))
(n, l) = (num[0], num[1])
pts = []
pts = list(map(int, input().split()))
pts.sort()
diff = []
if pts[0] != 0:
	diff.append(2 * pts[0])
if pts[len(pts) - 1] != l:
	diff.append(2 * (l - pts[len(pts) - 1]))
for i in range(len(pts) - 1):
	diff.append(float(pts[i + 1] - pts[i]))
diff.sort(reverse=True)
print(diff[0] / 2)


A = [int(x) for x in input().split()]
(n, l) = (A[0], A[1])
light = [int(x) for x in input().split()]
light.sort()
delta = []
if 0 not in light:
	delta.append(light[0])
if l not in light:
	delta.append(l - light[-1])
for i in range(n - 1):
	delta.append((light[i + 1] - light[i]) / 2)
print('%.9f' % max(delta))


(n, k) = list(map(int, input().split()))
w = list(map(int, input().split()))
w.sort()
i = 0
mx = 0
while i < n - 1:
	if w[i + 1] - w[i] > mx:
		mx = w[i + 1] - w[i]
	i += 1
mx = max(w[0], k - w[n - 1], mx / 2)
print(mx)


(n, l) = list(map(int, input().split()))
s = list(map(int, input().split()))
s.sort()
ans = max(float(s[0] - 0), float(l - s[-1]))
for x in range(n - 1):
	ans = max(ans, (s[x + 1] - s[x]) / 2)
print(ans)


def ii():
	return int(input())

def fi():
	return float(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
import math
(n, k) = mi()
a = li()
a.sort()
l = []
for i in range(n):
	if i == 0:
		l.append(a[i] - 0)
	l.append((a[i] - a[i - 1]) / 2)
l.append(k - a[n - 1])
print(max(l))


s = input()
l = s.split()
l = list(map(int, l))
ss = input()
ll = ss.split()
ll = list(map(int, ll))
ll.sort()
max = -1
for i in range(0, l[0] + 1):
	if i == 0:
		if ll[i] > max:
			max = ll[i]
	elif i == l[0]:
		if l[1] - ll[i - 1] > max:
			max = l[1] - ll[i - 1]
	else:
		z = ll[i] - ll[i - 1]
		z /= 2
		if z > max:
			max = z
print('%0.10f' % max)


def LanternProb(totalLanterns, length, listofpoints):
	sortedList = sorted(listofpoints)
	maxDist = 0
	for index in range(totalLanterns):
		if index < totalLanterns - 1:
			dist = sortedList[index + 1] - sortedList[index]
			if dist > maxDist:
				maxDist = dist
	print(max(maxDist / 2, max(sortedList[0] - 0, length - sortedList[totalLanterns - 1])))

def main():
	lanternInput = input().split()
	totalLanterns = int(lanternInput[0])
	length = int(lanternInput[1])
	listofpoints = list(map(int, input().split()))
	LanternProb(totalLanterns, length, listofpoints)
main()


(x, y) = map(int, input().split())
l = list(map(int, input().split()))
l = sorted(l)
m = 0
for i in range(0, x - 1):
	o = l[i + 1] - l[i]
	k = o / 2
	if m < k:
		m = k
if l[0] - 0 > m:
	m = l[0] - 0
if y - l[-1] > m:
	m = y - l[-1]
print('{:.9f}'.format(m))


import sys
INT_MAX = sys.maxsize
INT_MIN = -sys.maxsize - 1
sys.setrecursionlimit(10 ** 7)
mod = 1000000007

def IOE():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def main():
	(n, l) = map(int, sys.stdin.readline().split())
	a = list(map(int, sys.stdin.readline().split()))
	max_diff = 0
	a.sort()
	try:
		for i in range(n):
			max_diff = max(max_diff, a[i + 1] - a[i], a[i] - a[i + 1])
	except:
		pass
	if 0 not in a or l not in a:
		max_diff = max(min(a) - 0, max_diff / 2, l - max(a))
		print(float(max_diff))
	else:
		print(max_diff / 2)
try:
	IOE()
except:
	pass
main()


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
i = 0
r = -1
while i < n - 1:
	r = max(r, abs(l[i] - l[i + 1]))
	i += 1
print(max(r / 2, max(l[0], abs(l[n - 1] - m))))


def main():
	(n, l) = [int(s) for s in input().split()]
	a = [int(s) for s in input().split()]
	a.sort()
	max_dif = 0
	if a[0] != 0:
		max_dif = a[0]
	if a[n - 1] != l and abs(l - a[n - 1]) > max_dif:
		max_dif = abs(l - a[n - 1])
	for i in range(n - 1):
		if abs(a[i] - a[i + 1]) / 2 > max_dif:
			max_dif = abs(a[i] - a[i + 1]) / 2
	print(max_dif)
main()


i = int
cin = input
le = len
s = str
(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
mmax = float('-inf')
for idx in range(n - 1):
	mmax = max(abs(arr[idx] - arr[idx + 1]) / 2, mmax)
print(max(arr[0], mmax, l - arr[-1]))


(n, l) = [int(s) for s in input().split()]
a = sorted([int(s) for s in input().split()])
b = []
for i in range(n - 1):
	b.append(a[i + 1] - a[i])
b = sorted(b)
if b != []:
	print(max(a[0], l - a[n - 1], b[n - 2] / 2))
else:
	print(max(a[0], l - a[0]))


(n, l) = map(int, input().split())
data = [int(i) for i in input().split()]
data.sort()
dist = 0
for i in range(n - 1):
	dist = max(dist, data[i + 1] - data[i])
print(max(dist / 2, data[0], l - data[-1]))


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
m = -1
for ind in range(1, len(a)):
	v = a[ind] - a[ind - 1]
	if v > m:
		m = v
mm = max(m / 2, max(a[0] - 0, l - a[-1]))
print(mm)


(n, l) = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
mx = 0
mx1 = 0
for i in range(len(A) - 1):
	if abs(A[i] - A[i + 1]) > mx:
		mx = abs(A[i] - A[i + 1])
if mx1 < abs(0 - A[0]):
	mx1 = abs(0 - A[0])
if mx1 < abs(l - A[-1]):
	mx1 = abs(l - A[-1])
low = 0
r = l
while r - low > 1e-12:
	mid = (low + r) / 2
	m2 = (low + r) / 2
	if mid * 2 >= mx and mx1 <= mid:
		r = mid
	else:
		low = mid
	if m2 == (low + r) / 2 and r - low <= 0.01:
		break
print(r)


(n, l) = map(int, input().split())
lats = sorted(list(map(int, input().split())))
d = 2 * lats[0]
for i in range(len(lats) - 1):
	if lats[i + 1] - lats[i] > d:
		d = lats[i + 1] - lats[i]
if (l - lats[len(lats) - 1]) * 2 > d:
	d = (l - lats[len(lats) - 1]) * 2
print('{:.10f}'.format(d / 2))


(x, y) = map(int, input().split())
a = input().split()
s = [int(num) for num in a]
q = []
s.append(0)
s.append(y)
w = x + 2
e = 0
while not w == 0:
	a = min(s)
	b = s.count(a)
	for i in range(0, b):
		q.append(a)
		s.remove(a)
		w -= 1
for i in range(0, x + 1):
	if i == 0 or i == len(q) - 2:
		if q[i + 1] - q[i] > e:
			e = q[i + 1] - q[i]
	if (q[i + 1] - q[i]) / 2 > e:
		e = (q[i + 1] - q[i]) / 2
print(e)


(n, d) = [int(x) for x in input().split()]
liste = [int(x) for x in input().split()]
liste.sort()
maxi = 0
for i in range(n - 1):
	rayon = liste[i + 1] - liste[i]
	if rayon > maxi:
		maxi = rayon
if liste[0] > maxi / 2 or d - liste[-1] > maxi / 2:
	if liste[0] > d - liste[-1]:
		print(float(liste[0]))
	else:
		print(float(d - liste[-1]))
else:
	print(float(maxi / 2))


(n, l) = map(int, input().split())
a = sorted([int(k) for k in input().split()])
m = a[0]
rast = l - a[n - 1]
for i in range(1, n):
	m = max(m, (a[i] - a[i - 1]) / 2)
print(max(m, rast))


(n, l) = map(int, input().split())
s = list(map(int, input().split()))
maxd = 0
s.sort()
if not 0 in s:
	maxd = s[0]
if not l in s and l - s[n - 1] > maxd:
	maxd = l - s[n - 1]
for i in range(n - 1):
	if (s[i + 1] - s[i]) / 2 > maxd:
		maxd = (s[i + 1] - s[i]) / 2
print(maxd)


def main():
	(n, l) = list(map(int, input().split()))
	positions = list(map(int, input().split()))
	positions.sort()
	if len(positions) == 1:
		print(max(positions[0], l - positions[0]))
		return
	if positions[0] == 0:
		maxi = positions[1] / 2
	else:
		maxi = max(positions[0], l - positions[-1])
	for i in range(1, n):
		answer = (positions[i] - positions[i - 1]) / 2
		maxi = max(maxi, answer)
	print(maxi)
main()


(n, l) = [int(x) for x in input().split()]
li_ = sorted([int(x) for x in input().split()])
print('%.10f' % max([(li_[i + 1] - li_[i]) / 2 for i in range(len(li_) - 1)] + li_[:1] + [l - li_[-1]]))


_inputs = ['2 5', '2 5']
_inputs = [input(), input()]
(_, streetLength) = [int(x) for x in _inputs[0].split()]
positions = [int(x) for x in _inputs[1].split()]
positions.sort()
if positions[0] != 0:
	positions.insert(0, -positions[0])
if positions[-1] != streetLength:
	positions.append(2 * streetLength - positions[-1])

def searchForLongestPart(positions):
	return max([positions[i] - positions[i - 1] for i in range(1, len(positions))])
print(searchForLongestPart(positions) / 2)


(n, l) = map(int, input().split())
list1 = sorted(set(list(map(int, input().split()))))
list2 = []
if len(list1) == 1:
	if list1[0] < l - list1[0]:
		print(l - list1[0])
	else:
		print(list1[0])
else:
	a = list1[0]
	b = l - list1[len(list1) - 1]
	for i in range(len(list1) - 1):
		list2.append((list1[i + 1] - list1[i]) / 2)
	m = max(list2)
	if 0 in list1 and l in list1:
		print('%.10f' % m)
	elif l in list1:
		print('%.10f' % m) if m > a else print(a)
	elif 0 in list1:
		print('%.10f' % m) if m > b else print(b)
	elif m >= a and m >= b:
		print('%.10f' % m)
	elif a >= m and a >= b:
		print('%.10f' % a)
	elif b >= m and b >= a:
		print('%.10f' % b)


(n, l) = (int(x) for x in input().split())
lamp = [int(x) for x in input().split()]
lamp = sorted(lamp)
d = lamp[0] - 0
for i in range(len(lamp) - 1):
	dist = (lamp[i + 1] - lamp[i]) / 2
	if d < dist:
		d = dist
end = float(l - lamp[-1])
if end > d:
	d = end
print(d)


(n, l) = map(int, input().split())
num_list = sorted(list(map(int, input().split())))
k = num_list[0]
if k < l - num_list[len(num_list) - 1]:
	k = l - num_list[len(num_list) - 1]
for i in range(n - 1):
	if k < abs(num_list[i] - num_list[i + 1]) / 2:
		k = abs(num_list[i] - num_list[i + 1]) / 2
print(k)


(n, d) = map(int, input().split(' '))
l = list(map(int, input().split(' ')))
l = sorted(l)
l1 = [0]
l1.extend(l)
l1.append(d)
m = 0
for k in range(n + 1):
	if k == 0:
		m = l1[k + 1] - l1[k]
	elif k == n:
		if m < l1[k + 1] - l1[k]:
			m = l1[k + 1] - l1[k]
	elif m < (l1[k + 1] - l1[k]) / 2:
		m = (l1[k + 1] - l1[k]) / 2
print('%.10f' % m)


num1 = list(map(int, input().strip().split()))
num2 = sorted(list(map(int, input().strip().split())))
if num1[0] == 1:
	print('%.10f' % max(num1[1] - num2[0], num2[0]))
else:
	dis = []
	for i in range(1, num1[0]):
		dis.append(num2[i] - num2[i - 1])
	compare = []
	compare.append(num2[0])
	compare.append(num1[1] - num2[-1])
	compare.append(max(dis) / 2)
	print('%.10f' % max(compare))


import sys
import os
import math
import copy
from math import gcd
from bisect import bisect
from io import BytesIO, IOBase
from math import sqrt, floor, factorial, gcd, log, ceil
from collections import deque, Counter, defaultdict
from itertools import permutations, combinations
import itertools

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

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

def Lstr():
	return list(sys.stdin.readline().strip())

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

def Mstr():
	return map(str, sys.stdin.readline().strip().split())

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

def Hash():
	return dict()

def Mod():
	return 1000000007

def Ncr(n, r, p):
	return fact[n] * (ifact[r] * ifact[n - r] % p) % p

def Most_frequent(list):
	return max(set(list), key=list.count)

def Mat2x2(n):
	return [List() for _ in range(n)]

def Lcm(x, y):
	return x * y // gcd(x, y)

def dtob(n):
	return bin(n).replace('0b', '')

def btod(n):
	return int(n, 2)

def common(l1, l2):
	return set(l1).intersection(l2)

def solution():
	(n, l) = Mint()
	a = List()
	a.sort()
	b = 0
	for i in range(1, n):
		b = max(b, (a[i] - a[i - 1]) / 2)
	ans = max(b, a[0], l - a[-1])
	print(ans)
solution()


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
max_razn = 0
for i in range(n):
	if i == 0:
		razn = a[i] - 0
		max_razn = max(razn, max_razn)
		if i == n - 1:
			razn = l - a[i]
			max_razn = max(razn, max_razn)
	elif i <= n - 1:
		razn = (a[i] - a[i - 1]) / 2
		max_razn = max(razn, max_razn)
		if i == n - 1:
			razn = l - a[i]
			max_razn = max(razn, max_razn)
print(max_razn)


(n, l) = map(int, input().split())
d = sorted([int(x) for x in input().split()])
m = 0
for i in range(0, n - 1):
	m = d[i + 1] - d[i] if d[i + 1] - d[i] > m else m
m = m / 2
if d[0] > m:
	m = d[0]
if l - d[n - 1] > m:
	m = l - d[n - 1]
print('{0:.10f}'.format(m))


i = input()
(n, l) = i.split()
n = int(n)
l = int(l)
a = []
i = input()
i = i.split()
a = list(map(int, i))
a.sort()
c = 0
if a[0] != 0:
	p = -a[0]
	a.insert(0, p)
	c = 1
if (a[n - 1] != l) & (c == 0):
	p = l - a[n - 1]
	a.insert(n, l + p)
elif c == 1:
	if a[n] != l:
		p = l - a[n]
		a.insert(n + 1, l + p)
s = len(a)
diff = []
for i in range(1, s):
	d2 = a[i] - a[i - 1]
	diff.append(d2)
d = max(diff)
d = d / 2
print(d)


dat = list(map(int, input().split()))
n = dat[0]
k = dat[1]
light = list(map(int, input().split()))
light.sort()
max_rad = 0
if n == 1:
	max_rad = max(k - light[0], light[0])
else:
	for i in range(n):
		if i == 0:
			max_rad = light[i]
		elif i == n - 1:
			if k - light[i] > max_rad:
				max_rad = k - light[i]
			elif (light[i] - light[i - 1]) / 2 > max_rad:
				max_rad = (light[i] - light[i - 1]) / 2
		elif (light[i] - light[i - 1]) / 2 > max_rad:
			max_rad = (light[i] - light[i - 1]) / 2
print(max_rad)


import sys
input = sys.stdin.readline
(n, l) = map(int, input().strip().split())
a = list(map(int, input().strip().split()))
a.sort()
ans = max(a[0], l - a[n - 1])
for i in range(n - 1):
	ans = max(ans, (a[i + 1] - a[i]) / 2)
print('%.18f' % ans)


import sys
streetlen = [int(x) for x in sys.stdin.readline().split()][1]
lanterns = [int(x) for x in sys.stdin.readline().split()]
lanterns.sort()
diff = [lanterns[i + 1] - lanterns[i] for i in range(len(lanterns) - 1)]
diff = max(diff) / 2 if len(diff) > 0 else 0
diff = max(diff, lanterns[0], streetlen - lanterns[-1])
print(diff)


(n, l) = [int(i) for i in input().split()]
m = sorted([int(i) for i in input().split()])
x = float(m[0])
for i in range(len(m) - 1):
	x = x if x > (m[i + 1] - m[i]) / 2 else (m[i + 1] - m[i]) / 2
print(x if x > l - m[len(m) - 1] else float(l - m[len(m) - 1]))


(n, l) = map(int, input().split())
li = []
li.extend(list(map(int, input().split())))
li.sort()
j = 1
m = []
while j < len(li):
	m.append(li[j] - li[j - 1])
	j += 1
x = []
if len(m) != 0:
	x.append(max(m) / 2)
x.append(li[0])
x.append(l - li[n - 1])
print('%.9f' % max(x))


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
c = max(l[0], m - l[-1])
for i in range(n - 1):
	c = max(c, (l[i + 1] - l[i]) / 2)
print(c)


(n, m) = map(int, input().split())
lant = list(map(int, input().split()))
lant.sort()
maxi = 0
for i in range(n - 1):
	dist = abs(lant[i] - lant[i + 1])
	maxi = max(maxi, dist)
print(max(maxi / 2, max(lant[0], m - lant[n - 1])))


(n, lngth) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()

def osv(d):
	if a[0] - d > 0:
		return 666
	for i in range(n - 1):
		if a[i] + 2 * d < a[i + 1]:
			return 666
	if a[n - 1] + d < lngth:
		return 666
	else:
		return 0
r = lngth
l = 0
for i in range(50):
	c = (l + r) / 2
	if osv(c) != 666:
		r = c
	else:
		l = c
print('%.9f' % c)


(n, length) = map(int, input().split())
l = list(map(int, input().split()))
l = sorted(l)
cr = 0
cc = 0
if len(l) == 1:
	print(max(l[0], length - l[0]))
else:
	if l[0] == 0:
		cr = (l[1] - 0) / 2
		cc = cr
	else:
		cr = l[0]
		cc = l[0] + cr
	l = l[1:]
	for (j, i) in enumerate(l):
		if i - cc > cr:
			cr = (i - l[j - 1]) / 2
		cc = i + cr
	if length - cc > 0:
		cr = cr + (length - cc)
	print(cr)


a = input().split()
n = int(a[0])
l = int(a[1])
a = input().split()
for i in range(n):
	a[i] = float(a[i])
for i in range(n):
	for j in range(i):
		if a[i] < a[j]:
			sw = a[i]
			a[i] = a[j]
			a[j] = sw
s1 = a[0]
s = -1
for i in range(1, n):
	if s < a[i] - a[i - 1]:
		s = a[i] - a[i - 1]
s2 = l - a[n - 1]
print(max(s / 2, s1, s2))


(n, e) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
m = []
for i in range(1, len(l)):
	m.append(l[i] - l[i - 1])
s = 0
for i in l:
	if 0 not in l and i != 0:
		s += i
		break
d = 0
for i in l:
	if e not in l:
		d += e - l[len(l) - 1]
		break
if len(l) != 1:
	z = max(m)
	g = z / 2
	a = max(g, float(s), float(d))
	k = '{:.10f}'.format(a)
	print(k)
q = float(0)
if len(l) == 1:
	if l[0] == 0:
		q += float(e)
	else:
		q += max(float(l[0]), e - l[0])
	print('{:.10f}'.format(q))


a = list(map(int, input().split()))
a1 = a[0] - 1
a2 = a[1]
b = list(map(int, input().split()))
b.sort()
c = max(b[0] * 2, (a2 - b[-1]) * 2)
for i in range(a1):
	if b[i + 1] - b[i] > c:
		c = b[i + 1] - b[i]
print(c / 2)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
max_d = max(min(a), l - max(a))
for (x1, x2) in zip(sorted(a), sorted(a)[1:]):
	max_d = max(max_d, (x2 - x1) / 2)
print(max_d)


(number, length) = input().split()
(number, length) = (int(number), int(length))
distances = [int(n) for n in input().split()]
distances = sorted(distances)
ans = 0
for i in range(1, len(distances)):
	ans = max(ans, distances[i] - distances[i - 1])
if max(ans / float(2), min(distances) - 0, length - max(distances)) == ans / float(2):
	print(ans / float(2))
else:
	print(max(min(distances) - 0, length - max(distances)))


(n, l) = input().split(' ')
(n, l) = (int(n), int(l))
a = input().split()
a = [int(i) for i in a]
a = sorted(a)
d = 0
if a[0] - 0 > l - a[len(a) - 1]:
	d = a[0] - 0
else:
	d = l - a[len(a) - 1]
for i in range(len(a) - 1):
	if (a[i + 1] - a[i]) / 2 > d:
		d = (a[i + 1] - a[i]) / 2
if d == 1 and l + 1 == n:
	d = d / 2
print(d)


(n, l1) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
maxdiff = 0
prev = -1
i = 1
d = 0
while i < len(l):
	if l[i] - l[i - 1] > maxdiff:
		maxdiff = l[i] - l[i - 1]
	i = i + 1
d = maxdiff / 2
if l[0] != 0:
	x = l[0]
	if d < x:
		d = x
if l[len(l) - 1] != l1:
	x = l1 - l[len(l) - 1]
	if d < x:
		d = x
print(d)


(n, l) = map(int, input().split())
lis = list(map(int, input().split()))
lis.sort()
mi = min(lis)
y = mi
u = l - max(lis)
dd = [mi, u]
for x in lis:
	d = (x - y) / 2
	y = x
	dd.append(d)
m = max(dd)
print('%.10f' % m)


l1 = input().split()
n = int(l1[0])
l = int(l1[1])
a = input().split()
if n == 1:
	print(max(int(a[0]), l - int(a[0])))
elif a.count('0') != 0 and a.count(l) != 0:
	h = []
	for i in range(n):
		h.append(int(a[i]))
	h1 = []
	h.sort()
	for i in range(n - 1):
		h1.append(h[i + 1] - h[i])
	print(max(h1) / 2)
else:
	h = []
	for i in range(n):
		h.append(float(a[i]))
	h1 = []
	h.sort()
	for i in range(n - 1):
		h1.append(h[i + 1] - h[i])
	if max(h1) / 2 > max(h[0], l - h[n - 1]):
		print(max(h1) / 2)
	else:
		print(max(h[0], l - h[n - 1]))


(n, l) = map(int, input().split())
n = [int(x) for x in input().split()]
distance = 0
n.sort()
for i in range(len(n) - 1):
	distance = max(distance, (n[i + 1] - n[i]) / 2)
print(max(distance, n[0], l - n[-1]))


(n, l) = map(int, input().split())
L = list(map(int, input().split()))
L.sort()
if len(L) == 1:
	result = max(L[0], l - L[0])
	print(result)
	from sys import exit
	exit(0)
if len(L) == 2:
	result = max(L[0], l - L[-1])
	result = max(result, (L[1] - L[0]) / 2)
	print(result)
	from sys import exit
	exit(0)
result = max(L[0], l - L[-1])
max_distance = 0
for i in range(len(L[0:-1])):
	max_distance = max(max_distance, L[i + 1] - L[i])
max_distance /= 2
result = max(result, max_distance)
print(result)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

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

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	(n, l) = LI()
	a = sorted(LI())
	r = max(a[0], l - a[-1])
	for i in range(n - 1):
		t = (a[i + 1] - a[i]) / 2
		if r < t:
			r = t
	return '{:0.5f}'.format(r)
print(main())


a1 = input().split()
(n, l) = (int(a1[0]), int(a1[1]))
a2 = input().split()
a2 = [int(x) for x in a2]
a2.sort()
d3 = 0
if n > 1:
	a3 = [a2[i + 1] - a2[i] for i in range(n - 1)]
	a3.sort()
	d3 = a3[-1] / 2
d1 = a2[0]
d2 = l - a2[-1]
d = max(d1, d2, d3)
print(d)


l = list(map(int, input().split()))
(n, p) = (l[0], l[1])
a = list(map(int, input().split()))
a.sort()
q = 0
for i in range(1, n):
	if a[i] - a[i - 1] > q:
		q = a[i] - a[i - 1]
if a[0] - 0 > q / 2:
	q = 2 * a[0]
if p - a[n - 1] > q / 2:
	q = 2 * (p - a[n - 1])
print('%.9f' % (q / 2))


(x, y) = input().split()
n = int(x)
l = int(y)
li = list(map(int, input().split()))
li.sort()
m = 0
for i in range(1, n):
	if li[i] - li[i - 1] > m:
		m = li[i] - li[i - 1]
x = m / 2.0
ans = li[0] - 0.0
a1 = li[n - 1]
a1 = float(l) - a1
a2 = max(ans, x, a1)
print(a2)


(n, l) = map(int, input().split())

def avgg(location, l):
	if location[0] == 0:
		m = 0
	else:
		m = 2 * location[0]
	for i in range(len(location) - 1):
		if location[i + 1] - location[i] >= m:
			m = location[i + 1] - location[i]
	if location[-1] == l:
		return m
	else:
		n = 2 * (l - location[-1])
		return max(m, n)
location = list(map(int, input().split()))[:n]
location.sort()
x = avgg(location, l)
print(x / 2)


(l, n) = [int(x) for x in input().split()]
spot = [int(x) for x in input().split()]
spot.sort()
p = 0
for i in range(l - 1):
	a = (spot[i + 1] - spot[i]) / 2
	if a > p:
		p = a
c = spot[0]
b = n - spot[-1]
d = max(b, c, p)
print('%.10f' % d)


(n, m) = map(int, input().split())
s = list((i for i in map(int, input().split())))
s.sort()
print(max([s[0], m - s[n - 1]] + [(b - a) / 2 for (a, b) in zip(s, s[1:])]))


(n, l) = [int(s) for s in input().split(' ')]
a = sorted([int(s) for s in input().split(' ')])
gaps = [a[ii + 1] - a[ii] for ii in range(n - 1)]
m = 0
if len(gaps) > 0:
	m = max(gaps)
print(max(a[0], l - a[-1], m / 2))


(n, l) = map(int, input().split())
laterns = sorted(list(map(int, input().split())))
maxIt = 0
maxDst = 0
maxGr = max(laterns[0], l - laterns[-1])
for i in range(len(laterns) - 1):
	maxIt = laterns[i + 1] - laterns[i]
	maxDst = max(maxDst, maxIt)
print('{0:.9f}'.format(max(maxGr, maxDst / 2)))


def solve_bruteforce(xs, n, l):
	if n == 1:
		return max(xs[0], l - xs[0])
	xs.sort()
	most = max((b - a for (a, b) in zip(xs, xs[1:]))) / 2
	return max(most, xs[0] - 0, l - xs[-1])

def main():
	[n, l] = [int(i) for i in input().strip().split()]
	xs = [int(i) for i in input().strip().split()]
	assert len(xs) == n
	result = solve_bruteforce(xs, n, l)
	print(result)
main()


(n, l) = [int(x) for x in input().split()]
x = [int(x) for x in input().split()]
x.sort(reverse=True)
d = max(l - x[0], x[n - 1])
for i in range(n - 1):
	d = max(d, (x[i] - x[i + 1]) / 2)
print(d)


s = input().split()
n = int(s[0])
l = int(s[1])
a = input().split()
a = [int(i) for i in a]
a.sort()
ans = 2 * max(a[0], l - a[n - 1])
for num in range(len(a) - 1):
	ans = max(ans, a[num + 1] - a[num])
print(ans / 2)


string = input()
first = []
a_list = []
b_list = []
max = 0
first = string.split()
n = int(first[0])
l = int(first[1])
value = input()
a_list = value.split()
map_obj = map(int, a_list)
newList = list(map_obj)
newList.sort()
for i in range(0, n - 1, 1):
	if newList[i + 1] - newList[i] > max:
		max = newList[i + 1] - newList[i]
result = float(max / 2)
b_list.append(result)
left = float(newList[0] - 0)
b_list.append(left)
right = float(l - newList[n - 1])
b_list.append(right)
b_list.sort()
print(b_list[2])


(n, l) = map(int, input().split())
x = list(map(int, input().split()))
maximum = 0
x.sort()
for i in range(n - 1):
	if x[i + 1] - x[i] > maximum:
		maximum = x[i + 1] - x[i]
print(max(float(min(x)), float(l - max(x)), maximum / 2))


(n, l) = input().split()
(n, l) = (int(n), int(l))
a = [int(_) for _ in input().split()]
a.sort()
c = 2 * max(a[0], l - a[-1])
for i in range(n - 1):
	x1 = a[i]
	x2 = a[i + 1]
	c = max(x2 - x1, c)
print(c / 2)


(n, l) = map(int, input().split())
lan = list(map(int, input().split()))
lan.sort()
dis = max(lan[0] - 0, l - lan[-1])
x = 0
for i in range(1, len(lan)):
	x = max(x, lan[i] - lan[i - 1])
print(max(dis, x / 2))


def solve(n, l, pos):
	pos.sort()
	max_d = 0
	for i in range(1, n):
		max_d = max(max_d, (pos[i] - pos[i - 1]) / 2)
	max_d = max(max_d, pos[0] - 0, l - pos[n - 1])
	return max_d
parse = lambda st: list(map(int, st.split()))
res = solve(*parse(input()), parse(input()))
print(res)


import sys
(n, l) = map(int, sys.stdin.readline().split(' '))
line = sys.stdin.readline().strip().split(' ')
A = []
for x in line:
	A.append(int(x))
A.sort()
diff = 0
for x in range(n - 1):
	nextDiff = A[x + 1] - A[x]
	if nextDiff > diff:
		diff = nextDiff
diff /= 2
diffS = A[0]
diffF = l - A[n - 1]
print(max(diff, diffS, diffF))


(n, l) = input().split(' ')
n = int(n)
l = int(l)
t = 0
p = list(map(int, input().split(' ')))
p.sort()
for i in range(len(p) - 1):
	if p[i + 1] - p[i] > t:
		t = p[i + 1] - p[i]
r = t / 2
if l - p[n - 1] > t / 2:
	r = l - p[n - 1]
if p[0] > r:
	r = p[0]
print(r)


a = input().split()
b = sorted([int(x) for x in input().split()])
m_val = 0
for i in range(1, len(b)):
	if b[i] - b[i - 1] > m_val:
		m_val = b[i] - b[i - 1]
	else:
		continue
m_val = max(b[0], m_val / 2, int(a[1]) - b[len(b) - 1])
print(float(m_val))


(n, l) = map(int, input().split(' '))
lights = sorted(map(int, input().split(' ')))
if not len(lights):
	print(l)
(res, i) = (0, 0)
while i < n - 1:
	res = max(res, (lights[i + 1] - lights[i]) / float(2))
	i += 1
print(max(res, float(lights[0]), l - float(lights[-1])))


(n, l) = input().split()
(n, l) = (int(n), int(l))
s = input().split()
a = []
for i in s:
	a.append(int(i))
a.sort()
p = max(a[0] - 0, l - a[n - 1])
for i in range(1, n):
	p = max(p, (a[i] - a[i - 1]) / 2)
print(p)


(num1, num2) = map(int, input().split())
n = sorted(list(map(int, input().split())))
per1 = [2 * n[0], 2 * (num2 - n[-1])]
for i in range(num1 - 1):
	p = n[i + 1] - n[i]
	per1.append(p)
print(max(per1) / 2)


def minimum_radius(num, length, a):
	if len(a) == 1:
		return max(a[0], length - a[0])
	d = 0
	for i in range(1, num):
		if (a[i] - a[i - 1]) / 2 > d:
			d = (a[i] - a[i - 1]) / 2
	if a[0] != 0:
		d = max(d, a[0])
	if a[-1] != length:
		d = max(d, length - a[-1])
	return d
[n, l] = list(map(int, input().split()))
a_i = list(map(int, input().split()))
a_i.sort()
print('{0:.9f}'.format(minimum_radius(n, l, a_i)))


def main():
	(n, l) = map(int, input().split())
	a = list(map(int, input().strip().split()))[:n]
	a.sort()
	max_distance = -1
	for i in range(n - 1):
		max_distance = max(max_distance, a[i + 1] - a[i])
	res = max(max_distance / 2, a[0], l - a[n - 1])
	print(res)
main()


(l, n) = map(int, input().split())
b = []
a = input().split()
for i in range(len(a)):
	a[i] = int(a[i])
a.sort()
if 0 not in a:
	b.append(a[0])
if n not in a:
	b.append(n - a[l - 1])
for i in range(l - 1):
	b.append((a[i + 1] - a[i]) / 2)
print(max(b))


(n, l) = map(int, input().split())
mylist = list(map(int, input().split()))
mylist.sort()
if len(mylist) == 1:
	if mylist[0] - 0 > l - mylist[0]:
		print(mylist[0] - 0)
	else:
		print(l - mylist[0])
else:
	largest = mylist[0] - 0
	for i in range(0, len(mylist) - 1):
		if mylist[i + 1] - mylist[i] > largest:
			largest = mylist[i + 1] - mylist[i]
	ans1 = largest / 2
	ans2 = l - mylist[len(mylist) - 1]
	ans3 = mylist[0] - 0
	mylist2 = [ans1, ans2, ans3]
	if (0 and l) in mylist:
		print(ans1)
	elif 0 in mylist:
		if ans2 > ans1:
			print(ans2)
		else:
			print(ans1)
	elif l in mylist:
		if ans3 > ans1:
			print(ans3)
		else:
			print(ans1)
	else:
		print(max(mylist2))


(n, l) = map(int, input().split())
x = list(map(int, input().split()))
x.sort()
count = 0
for i in range(len(x) - 1):
	if count < (x[i + 1] - x[i]) / 2:
		count = (x[i + 1] - x[i]) / 2
if x[0] != 0:
	if count < x[0] - 0:
		count = x[0] - 0
if x[n - 1] != l:
	if count < l - x[n - 1]:
		count = l - x[n - 1]
print('{:.10f}'.format(count))


(n, l) = map(int, input().split())
sortedList = sorted(map(int, input().split()))
distance = 0
prev = -sortedList[0]
for n in range(len(sortedList)):
	distance = max(distance, int(sortedList[n]) - prev)
	prev = int(sortedList[n])
distance = max(distance, (int(l) - prev) * 2)
result = distance / 2
print(result)


(n, l) = map(int, input().split())
lis = list(map(int, input().split()))
lis = sorted(lis)
m2 = lis[0] - 0
m3 = l - lis[-1]
m = max(m2, m3)
for i in range(len(lis) - 1):
	if (lis[i + 1] - lis[i]) / 2 > m:
		m = (lis[i + 1] - lis[i]) / 2
print(m)


(a, b) = map(int, input().split())
l = [int(x) for x in input().split()]
l.sort()
t = []
if a == 1:
	r1 = l[0] - 0
	r2 = b - l[-1]
	result = max(r1, r2)
else:
	for i in range(a - 1):
		step = l[i + 1] - l[i]
		t.append(step)
	r0 = max(t) / 2
	r1 = l[0] - 0
	r2 = b - l[-1]
	result = max(r0, r1, r2)
print(result)


(n, l) = map(int, input().split())
arr = sorted([int(x) for x in input().split()])
diff = [(arr[i] - arr[i - 1]) / 2 for i in range(1, n)]
diff.append(arr[0] - 0)
diff.append(l - arr[-1])
print('{:.10f}'.format(max(diff)))


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(list(set(a)))
n = len(a)
l = 0
r = 10 ** 9 + 1
m = 0
for surokpro in range(100):
	m = (r + l) / 2
	f = 1
	for i in range(0, n - 1):
		if a[i + 1] - a[i] > m * 2:
			f = 0
			break
	if a[0] > m:
		f = 0
	if k - a[n - 1] > m:
		f = 0
	if f:
		r = m
	else:
		l = m
print(m)


(n, d) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
b = []
b.append(0)
b.append(a[0])
b.append(d - max(a))
for i in range(n - 1):
	if max(b) < a[i + 1] - a[i]:
		b.append((a[i + 1] - a[i]) / 2)
if a[0] > max(b) / 2:
	print(max(b))
elif d - max(a) > max(b) / 2:
	print(max(b))
else:
	print(float(max(b)))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
max1 = max(a[0], l - a[-1])
for i in range(n - 1):
	k = (a[i + 1] - a[i]) / 2
	if max1 < k:
		max1 = k
print(max1)


arr = list(map(int, input().split()))
n = arr[0]
l = arr[1]
lights = list(map(int, input().split()))
lights.sort()
if len(lights) > 1:
	dist = lights[1] - lights[0]
else:
	dist = lights[0]
i = 1
while i < len(lights) - 1:
	if dist < lights[i + 1] - lights[i]:
		dist = lights[i + 1] - lights[i]
	i = i + 1
dist = dist / 2
if 0 not in lights:
	dist = max(dist, lights[0])
if l not in lights:
	temp = l - lights[-1]
	dist = max(temp, dist)
print(dist)


k = list(map(int, input().split()))
n = k[0]
m = k[1]
a = list(map(int, input().split()))
a.sort()
if 0 not in a:
	a.insert(0, -a[0])
if m not in a:
	a.append(m + m - a[-1])
max = -10000000
for i in range(len(a) - 1):
	if a[i + 1] - a[i] > max:
		max = a[i + 1] - a[i]
print(max / 2)


_input = list(map(int, input().split()))
n = _input[0]
l = _input[1]
positions = list(map(int, input().split()))
positions.sort()
min_radius = 0
if positions[0] > 0:
	min_radius = positions[0]
if positions[-1] < l:
	if l - positions[-1] > min_radius:
		min_radius = l - positions[-1]
for idx in range(len(positions) - 1):
	radius_required = (positions[idx + 1] - positions[idx]) / 2
	if radius_required > min_radius:
		min_radius = radius_required
print(min_radius)


(u, v) = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
l = sorted(l)
l.insert(0, -l[0])
l.append(2 * v - l[u])
print(max(((l[i + 1] - l[i]) / 2 for i in range(u + 1))))


(n, l) = map(int, input().split())
Line = [int(i) for i in input().split()]
Line.sort()
k = max(Line[0], l - Line[n - 1])
for i in range(1, n):
	p = Line[i] - Line[i - 1]
	k = max(k, p / 2)
print(k)


(i_lat, dlug) = map(int, input().split())
latarnie = sorted([int(x) for x in input().split()])
max_odl = 0
for x in range(i_lat - 1):
	max_odl = max(max_odl, (latarnie[x + 1] - latarnie[x]) / 2)
print(max(max_odl, latarnie[0], dlug - latarnie[-1]))


q = []
q = input().split()
for i in range(2):
	q[i] = int(q[i])
a = []
a = input().split()
for i in range(q[0]):
	a[i] = int(a[i])
a.sort()
end = q[1] - a[-1]
ma = 0
for i in range(q[0] - 1):
	diff = abs(a[i] - a[i + 1])
	ma = max(diff, ma)
ma = max(a[0], ma / 2, end)
print(ma)


inp1 = str(input())
inp = inp1.split()
n = int(inp[0])
l = int(inp[1])
arr = list(map(int, input().split()))
arr.append(0)
arr.append(l)
arr.sort()
a = []
for i in range(len(arr) - 1):
	a.append(arr[i + 1] - arr[i])
d = max(a)
ans = float(d / 2)
if ans < a[0] or ans < a[-1]:
	print(max(a[0], a[-1]))
else:
	print(ans)


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
lista = sorted(a)
d = 0
d1 = lista[0]
d2 = l - lista[-1]
c_max = max(d1, d2)
c_max2 = 0
i = 0
while i < n - 1:
	if lista[i + 1] - lista[i] > c_max2:
		c_max2 = lista[i + 1] - lista[i]
	i += 1
if c_max > c_max2 / 2:
	print('%.9f' % int(c_max))
else:
	print('%.9f' % (int(c_max2) / 2))


def sol(n, l, a):
	a.sort()
	r = max(a[0], l - a[-1])
	for i in range(n - 1):
		r = max(r, float(a[i + 1] - a[i]) / 2.0)
	return r
(n, l) = map(int, input().split())
a = list(map(int, input().strip().split()))
print('%.9f' % sol(n, l, a))


(n, h) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
ma = 0
for i in range(n - 1):
	if l[i + 1] - l[i] > ma:
		ma = l[i + 1] - l[i]
d = max(ma / 2, l[0], h - l[n - 1])
print('%.9f' % d)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[0] != 0:
	d1 = arr[0]
else:
	d1 = 0
if arr[-1] != l:
	d2 = l - arr[-1]
else:
	d2 = 0
maxx = 0
for i in range(n - 1):
	if arr[i + 1] - arr[i] > maxx:
		maxx = arr[i + 1] - arr[i]
if maxx / 2 > d1 and maxx / 2 > d2:
	print('{0:.10f}'.format(maxx / 2))
elif maxx / 2 > d1 and maxx / 2 < d2:
	print('{0:.10f}'.format(d2))
elif maxx / 2 < d1 and maxx / 2 > d2:
	print('{0:.10f}'.format(d1))
elif d1 > d2:
	print('{0:.10f}'.format(d1))
else:
	print('{0:.10f}'.format(d2))


(n, l) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort()
z = max(a[0], l - a[n - 1])
for i in range(1, n):
	m = a[i] - a[i - 1]
	if m / 2 > z:
		z = m / 2
print(format(z, '.10f'))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
b = [a[i + 1] - a[i] for i in range(len(a) - 1)]
if b:
	print(max(min(a), max(b) / 2, l - max(a)))
else:
	print(max(min(a), l - max(a)))


n = 2
arr = input()
l = list(map(int, arr.split(' ')))
n = l[0]
arr2 = input()
l2 = list(map(int, arr2.split(' ')))
flag0 = 0
flagN = 0
firstDiff = 0
lastDiff = 0
gap = 0
l2.sort()
maxDiff = 0
for i in range(l[0] - 1):
	if l2[i] == 0:
		flag0 = 1
	elif l2[i] == l[1]:
		flagN = 1
if flag0 == 0:
	firstDiff = l2[0]
if flagN == 0:
	lastDiff = l[1] - l2[l[0] - 1]
if lastDiff >= firstDiff:
	gap = lastDiff
if firstDiff > lastDiff:
	gap = firstDiff
for i in range(l[0] - 1):
	if l2[i + 1] - l2[i] > maxDiff:
		maxDiff = l2[i + 1] - l2[i]
if gap >= maxDiff / 2:
	print(float(gap), '000000000', sep='')
else:
	print(float(maxDiff / 2), '000000000', sep='')


(n, l) = map(int, input().split())
a = set(list(map(int, input().split())))
a = sorted(a)
res = 0
pre = 0
cnt = 0
for i in a:
	if cnt == 0 and i != 0:
		res = max(res, i)
	else:
		res = max(res, (i - pre) / 2)
	pre = i
	cnt += 1
if l not in a:
	res = max(res, l - pre)
print(res)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr = sorted(arr)
d = 0
for i in range(1, n):
	d = max(d, arr[i] - arr[i - 1])
print('%.2f' % max(d / 2, max(arr[0], l - arr[n - 1])))


length = int(input().split(' ')[1])
lanterns = list((int(x) for x in input().split(' ')))
lanterns.sort()
maximum = 0
for i in range(1, len(lanterns)):
	diff = lanterns[i] - lanterns[i - 1]
	if diff > maximum:
		maximum = diff
maximum /= 2
if lanterns[0] > maximum:
	maximum = lanterns[0]
if length - lanterns[-1] > maximum:
	maximum = length - lanterns[-1]
print(maximum)


(n, l) = map(int, input().strip().split())
L = list(map(int, input().strip().split()))
L.sort()
F = True
a = L[0] - 0
k = 0
for i in range(n - 1):
	d = L[i + 1] - L[i]
	if d >= a:
		F = False
		a = d
		k = i
if F:
	a = 2 * a
if l - L[-1] >= a / 2 and l != 1:
	k = n - 1
	a = l - L[k]
	print(a)
elif k == 0:
	a = max(L[k] - 0, a / 2)
	if l == 1:
		print(1)
	else:
		print(a)
else:
	print(a / 2)


(n, l) = map(int, input().split())
pl = input().split()
p = [int(i) for i in pl]
p.sort()
ans = p[0] - 0
for i in range(1, n):
	ans = max(ans, (p[i] - p[i - 1]) / 2)
ans = max(ans, l - p[n - 1])
print(ans)


import math

def solve():
	(n, l) = map(int, input().split())
	a = list(map(int, input().split()))
	a = list(set(a))
	a.sort()
	ans = 0
	for i in range(len(a) - 1):
		ans = max(ans, a[i + 1] - a[i])
	ans = ans / 2
	ans = max(ans, a[0], l - a[len(a) - 1])
	print(ans)
solve()


(n, l) = map(int, input().split())
dists = [int(x) for x in input().split()]
dists.sort()
max_dist = 0
for i in range(n - 1):
	if dists[i + 1] - dists[i] > max_dist:
		max_dist = dists[i + 1] - dists[i]
if max_dist < dists[0] * 2:
	max_dist = dists[0] * 2
if max_dist < (l - dists[-1]) * 2:
	max_dist = (l - dists[-1]) * 2
print('{:.10f}'.format(max_dist / 2))


(n, l) = map(int, input().split())
lights = sorted(list(map(int, input().split())) + [0, l])
max_len = max(lights[1] - lights[0], lights[-1] - lights[-2])
for i in range(1, len(lights)):
	max_len = max(max_len, (lights[i] - lights[i - 1]) / 2)
print('{:.10f}'.format(max_len))


(n, l) = map(int, input().split())
a = input().split()
for i in range(len(a)):
	a[i] = int(a[i])
a.sort()
ma = 0
aa = 0
for i in range(len(a) - 1):
	if ma < a[i + 1] - a[i]:
		ma = a[i + 1] - a[i]
print(max(ma / 2, a[0], l - a[-1]))


from sys import stdin, exit
(n, l) = map(int, stdin.readline().split())
li = list(map(int, stdin.readline().split()))
li.sort()
m = 0
for i in range(1, n):
	m = max(m, abs(li[i - 1] - li[i]) / 2)
if li[0] != 0:
	m = max(m, li[0])
if li[n - 1] != l:
	m = max(m, l - li[n - 1])
print('{0:.5f}'.format(m))


(n, l) = input().split(' ')
n = int(n)
l = int(l)
a = [int(c) for c in input().split(' ')]
a.sort()
first = a[0] - 0
last = l - a[-1]
max1 = 0
for i in range(0, n - 1):
	max1 = max(max1, (a[i + 1] - a[i]) / 2)
else:
	print(max(first, last, max1))


(n, l) = map(int, input().split())
lst = list(map(int, input().split()))
lst.sort()
x = []
for i in range(len(lst) - 1):
	x.append(lst[i + 1] - lst[i])
x.sort()
ans = 0
if n > 1:
	ans = x[-1] / 2
a1 = lst[0] - 0
a2 = l - lst[-1]
c = max(a1, a2)
c1 = max(c, ans)
print('{:.10f}'.format(c1))


(n, l) = map(int, input().split())
data = list(map(int, input().split()))
data.sort()
s = []
if n > 1:
	for i in range(n - 1):
		s.append(data[i + 1] - data[i])
	max_dis = max(s) / 2
	print('%.10f' % max(max_dis, data[0] - 0, l - data[-1]))
else:
	print('%.10f' % max(data[0] - 0, l - data[0]))


(n, l) = map(int, input().split())
a = input().split()
b = []
c = 0
m = 0
x = 0
y = 0
for i in range(n):
	b.append(int(a[i]))
b.sort()
for i in range(n - 1):
	c = (int(b[i + 1]) - int(b[i])) / 2
	if m < c:
		m = c
x = int(b[0]) - 0
y = l - int(b[-1])
print(float(max(m, x, y)))


def cantidadMinima():
	nl = [int(j) for j in input().split(' ')]
	lenght = nl[1]
	lights = [float(i) for i in input().split(' ')]
	lights.sort()
	maxDis = lights[0]
	for l in range(len(lights) - 1):
		if (lights[l + 1] - lights[l]) / 2 > maxDis:
			maxDis = (lights[l + 1] - lights[l]) / 2
	if lenght - lights[-1] > maxDis:
		maxDis = lenght - lights[-1]
	return maxDis
print(cantidadMinima())


(n, l) = map(int, input().split())
a = sorted(map(int, input().split()))
b = []
if len(a) > 1:
	for i in range(n):
		if i == 0:
			b.append(a[i] - 0)
		else:
			b.append((a[i] - a[i - 1]) / 2)
			if i == n - 1:
				b.append(l - a[n - 1])
else:
	b.append(a[0] - 0)
	b.append(l - a[0])
m = max(b)
print('%.10f' % m)


from sys import stdin, stdout

def main():
	(n, m) = map(int, stdin.readline().split())
	l = list(map(int, stdin.readline().split()))
	l.sort()
	d = 1
	x = l[0]
	for i in range(n - 1):
		if (l[i + 1] - l[i]) / 2 > x:
			x = (l[i + 1] - l[i]) / 2
	if m - l[-1] > x:
		x = m - l[-1] / 1
	stdout.write(str(x))
main()


(n, l) = map(int, input().split())
M = list(map(int, input().split()))
M.sort()
r = 0
for i in range(n - 1):
	r = max(r, M[i + 1] - M[i])
print('{:.9f}'.format(max(float(M[0]), r / 2, float(l - M[-1]))))


lst1 = [int(i) for i in input().split()]
lanterns = [int(i) for i in input().split()]
lanterns.sort()
maxdis = 0
for i in range(len(lanterns) - 1):
	dis = lanterns[i + 1] - lanterns[i]
	if dis > maxdis:
		maxdis = dis
enddis = 2 * (lst1[1] - lanterns[-1])
sdis = 2 * lanterns[0]
maxdis = max(maxdis, enddis, sdis)
print(maxdis / 2)


(n, l) = str(input()).split()
n = int(n)
l = int(l)
temp_list = str(input()).split()
temp_list = [int(it) for it in temp_list]
temp_list.sort()
value = max(temp_list[0], l - temp_list[-1])
for i in range(1, n):
	value = max(value, (temp_list[i] - temp_list[i - 1]) / 2)
print(value)


import sys
from random import choice, randint
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
M = lambda : map(int, sys.stdin.readline().strip().split())
L = lambda : list(map(int, sys.stdin.readline().strip().split()))

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

def LI():
	return list(map(int, sys.stdin.readline().strip().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().strip().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().strip().split()]

def LS():
	return sys.stdin.readline().strip().split()

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

def F():
	return float(sys.stdin.readline().strip())

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

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))
inp = sys.stdin.readline
out = sys.stdout.write

def main():
	(n, l) = M()
	a = L()
	a.sort()
	mx = 0
	for i in range(len(a) - 1):
		d = a[i + 1] - a[i]
		if d > mx:
			mx = d
	if mx / 2 > a[0] and mx / 2 > l - a[-1]:
		pf(mx / 2)
	else:
		pf(max(a[0], l - a[-1]))
main()


(n, l) = map(int, input().split())
a = [0] + [int(x) for x in input().split()] + [l]
a.sort()
d = 0
for i in range(n + 1):
	p = a[i + 1] - a[i]
	if 1 <= i <= n and p / 2 > d:
		d = p / 2
	if i == 0 or (i == n and p > d):
		d = p
print(d)


(n, l) = map(int, input().split())
(*i,) = map(int, input().split())
i.sort()
p = 0
for j in range(n - 1):
	s = i[j + 1] - i[j]
	p = max(p, s)
print(max(p / 2, i[0], l - i[-1]))


b = [int(i) for i in input().split(' ')]
n = b[0]
l = b[1]
d_1 = -1
d_2 = -1
d = 0
a = [int(n) for n in input().split(' ')]
a = sorted(a)
for i in range(1, n):
	if (a[i] - a[i - 1]) / 2 > d:
		d = (a[i] - a[i - 1]) / 2
if a[0] > d:
	d = a[0]
if l - a[-1] > d:
	d = l - a[-1]
print(float(d))


(n, l) = map(int, input().split())
lanterns = sorted(list(map(int, input().split())))
dis = [lanterns[0] - 0, l - lanterns[n - 1]]
for i in range(1, n):
	dis.append((lanterns[i] - lanterns[i - 1]) / 2)
print(max(dis))


(N, L) = map(int, input().split())
A = list(map(int, input().split()))
left = 0
right = 10 ** 9 + 10
A.sort()
import time
x = time.time()

def func(mid):
	maxval = A[0] + mid
	if A[0] - mid > 0:
		return False
	for a in A[1:]:
		if maxval < a - mid:
			return False
		maxval = a + mid
	if maxval < L:
		return False
	return True
tmp = 0
while left <= right:
	if right - left <= 10 ** (-10):
		mid = (left + right) / 2
		break
	mid = (left + right) / 2
	y = time.time()
	if y - x > 0.8:
		break
	if func(mid):
		right = mid
	else:
		left = mid
print(mid)


(n, l) = list(map(int, input().split()))
s = list(map(int, input().split()))
s = sorted(s)
sv = []
if s[0] != 0:
	sv.append(s[0])
if s[-1] != l:
	sv.append(l - s[-1])
sf = 0
for ss in s:
	sv.append((ss - sf) / 2)
	sf = ss
print(max(sv))


import math
(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
maxdist = -math.inf
for i in range(1, n):
	maxdist = max(maxdist, a[i] - a[i - 1])
print(max(maxdist / 2, a[0] - 0, l - a[n - 1]))


from math import *
inpt = [int(i) for i in input().split()]
val = [int(j) for j in input().split()]
res = []
val.sort()
for s in range(len(val) - 1):
	c = (val[s + 1] - val[s]) / 2
	res.append(c)
if len(val) == 1:
	res.append(val[0])
ans = max(res)
if val[0] != 0:
	if val[0] > ans:
		ans = val[0]
val.reverse()
if val[0] != inpt[1]:
	if inpt[1] - val[0] > ans:
		ans = inpt[1] - val[0]
print(str(float(ans)) + '000000000')


from math import *
(n, l) = [int(el) for el in input().split(' ')]
if n == 1:
	a = int(input())
	print(max(a, l - a))
else:
	a = input().split(' ')
	for i in range(n):
		a[i] = int(a[i])
	a.sort()
	d = a[1] - a[0]
	for i in range(2, n):
		if a[i] - a[i - 1] > d:
			d = a[i] - a[i - 1]
	print(max(d / 2, max(a[0], l - a[n - 1])))


(n, l) = map(int, input().split())
ls = list(map(int, input().split()))
ls.sort()
d = [ls[i + 1] - ls[i] for i in range(len(ls) - 1)]
d = list(map(lambda x: x / 2, d)) + [ls[0], l - ls[n - 1]]
print(max(d))


from sys import stdin as inp
from sys import stdout as out
a = lambda : list(map(int, inp.readline().split()))
(n, l) = a()
s = sorted(a())
ans = 0
for i in range(1, n):
	ans = max(ans, (s[i] - s[i - 1]) / 2)
print(max(s[0], ans, l - s[-1]))


t = input()
temp = t.split()
n = int(temp[0])
l = int(temp[1])
s = input()
temp = s.split()
lamps = [int(i) for i in temp]
maximum = 0
lamps = sorted(lamps)
for i in range(n):
	if i == 0:
		m = (lamps[0] - 0) * 2
	elif i > 0:
		m = lamps[i] - lamps[i - 1]
	if m > maximum:
		maximum = m
	if i == n - 1:
		if (l - lamps[i]) * 2 > maximum:
			maximum = (l - lamps[i]) * 2
result = float(maximum) / 2
print('%.10f' % result)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
d = 0
a = sorted(a, key=int)
m = 0
for x in range(0, n - 1):
	if a[x + 1] - a[x] > m:
		m = a[x + 1] - a[x]
m /= 2
if a[0] > m:
	m = a[0]
if l - a[-1] > m:
	m = l - a[-1]
print(m)


import math
(n, l) = input('').split()
(n, l) = (eval(n), eval(l))
List = list(map(int, input('').split()))
d = []
if List.count(0) == 0:
	d.append(min(List))
List.sort()
if List.count(l) == 0:
	d.append(l - List[n - 1])
for i in range(n):
	if i + 1 < n:
		d.append((List[i + 1] - List[i]) / 2)
print('{:.9f}'.format(max(d)))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
if n == 1:
	print(format(max(l - a[0], a[0]), '.10f'))
	exit(0)
a.sort()
ans = max(a[0], l - a[n - 1], (a[1] - a[0]) / 2, (a[n - 1] - a[n - 2]) / 2)
for i in range(1, n - 1):
	ans = max(ans, (a[i] - a[i - 1]) / 2, (a[i] - a[i + 1]) / 2)
print(format(ans, '.10f'))


[n, l] = [int(x) for x in input().split()]
lights = sorted([int(x) for x in input().split()])
minimum = 0
if 0 not in lights:
	minimum = lights[0]
	lights.insert(0, 0)
if l not in lights:
	last = l - lights[len(lights) - 1]
	if last > minimum:
		minimum = last
	lights.append(l)
i = 0
while i < len(lights) - 1:
	half = (lights[i + 1] - lights[i]) / 2
	if half > minimum:
		minimum = half
	i += 1
print(minimum)


def main():
	(n, l) = [int(x) for x in input().split()]
	arr = [int(x) for x in input().split()]
	arr.sort()
	ans = 0
	start = max(0, arr[0])
	for i in range(1, n):
		ans = max(ans, arr[i] - arr[i - 1])
	end = l - arr[n - 1]
	ans = max(ans / 2, end, start)
	print(ans)
	return
main()


(n, l) = [int(x) for x in input().split()]
As = list(set([int(x) for x in input().split()]))
As.sort()
ans = As[0]
ans = max(ans, l - As[-1])
for i in range(0, len(As) - 1):
	ans = max(ans, (As[i + 1] - As[i]) / 2)
print(ans)


(n, L) = [int(s) for s in input().split()]
Post = [int(s) for s in input().split()]
Post.sort()
Distance = [0]
for o in range(n - 1):
	Distance.append(Post[o + 1] - Post[o])
print(max(0.5 * max(Distance), min(Post), L - max(Post)))


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
max2 = 0
a.sort()
diffl = a[0] - 0
diffr = l - a[n - 1]
max1 = max(diffr, diffl)
for i in range(n - 1):
	diff = a[i + 1] - a[i]
	if diff > max2:
		max2 = diff
if max1 >= max2 / 2:
	print(str.format('{0:.10f}', max1))
else:
	print(str.format('{0:.10f}', max2 / 2))


(n, l) = input().split()
(n, l) = [int(n), int(l)]
list = [int(x) for x in input().split()]
list.sort()
d = 0
for i in range(n - 1):
	temp = abs(list[i] - list[i + 1]) / 2
	if temp > d:
		d = temp
if float(list[0]) > d:
	d = list[0]
if float(l - list[n - 1]) > d:
	d = l - list[n - 1]
print(d)


(n, k) = map(int, input().strip().split(' '))
lst = list(map(int, input().strip().split(' ')))
lst.sort()
m = 0
for i in range(1, n):
	if (lst[i] - lst[i - 1]) / 2 > m:
		m = (lst[i] - lst[i - 1]) / 2
if lst[0] != 0:
	if lst[0] > m:
		m = lst[0]
if lst[-1] != k:
	if k - lst[-1] > m:
		m = k - lst[-1]
print(m)


(n, m) = map(int, input().split())
A = list(map(int, input().split()))
A = sorted(A)
ans = 0
for i in range(n - 1):
	ans = max(ans, A[i + 1] - A[i])
ans = ans / 2
if A[0] == 0:
	pass
else:
	ans = max(ans, A[0])
if A[n - 1] == m:
	pass
else:
	ans = max(ans, m - A[n - 1])
print(ans)


(n, l) = map(int, input().split())
ls = [int(a) for a in input().split()]
ls.sort()
dist = [2 * ls[0], 2 * (l - ls[-1])]
for i in range(n - 1):
	dist.append(ls[i + 1] - ls[i])
print(max(dist) / 2)


(n, m) = list(map(int, input().split()))
l = list(map(float, input().split()))
l.sort()
ma = 0
if 0 not in l:
	ma = l[0] - 0
if m not in l and m - l[n - 1] > ma:
	ma = m - l[n - 1]
for i in range(1, n):
	if (l[i] - l[i - 1]) / 2 > ma:
		ma = (l[i] - l[i - 1]) / 2
print(ma)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
dist = []
a.sort()
for i in range(1, n):
	dist.append((a[i] - a[i - 1]) / 2)
dist.insert(0, a[0] - 0)
dist.insert(m, m - a[-1])
print(max(dist))


from sys import stdin, stdout
from collections import defaultdict
import heapq as hq

def get_int():
	return int(stdin.readline().strip())

def get_ints():
	return map(int, stdin.readline().strip().split())

def get_array():
	return list(map(int, stdin.readline().strip().split()))

def get_string():
	return stdin.readline().strip()
INF = 10000000000.0
(n, l) = get_ints()
a = get_array()
a.sort()
max_d = -INF
for i in range(n - 1):
	max_d = max(max_d, abs(a[i] - a[i + 1]))
ans = max(max_d / 2, a[0], abs(l - a[n - 1]))
print(ans)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
res = 2 * max(a[0], l - a[n - 1])
for i in range(n - 1):
	res = max(res, a[i + 1] - a[i])
print('{:.10f}'.format(res / 2))


(n, l) = map(int, input().split())
nums = sorted(list(map(int, input().split())))
maxi = 0
for i in range(n - 1):
	maxi = max(maxi, nums[i + 1] - nums[i])
maxi = max(maxi / 2, nums[0], l - nums[n - 1])
print('%.10f' % maxi)


(n, l) = map(int, input().split())
A = [int(x) for x in input().split()]
A.sort()
B = [A[0], l - A[-1]]
for i in range(1, n):
	B.append((A[i] - A[i - 1]) / 2)
print(max(B))


entrada = list(map(int, input().split()))
linternas = list(map(int, input().split()))
final = entrada[1]
linternas.sort()
max = linternas[0]
prev = 0
for j in linternas:
	distance = (j - prev) / 2
	if distance > max:
		max = distance
	prev = j
if final - linternas[-1] > max:
	max = final - linternas[-1]
print(max)


def main():
	inp = input().split()
	inp2 = [int(x) for x in input().split()]
	inp2.sort()
	Max = inp2[0] * 2
	for i in range(1, int(inp[0])):
		Max = max(Max, inp2[i] - inp2[i - 1])
	Max = max(Max, (int(inp[1]) - inp2[len(inp2) - 1]) * 2)
	print('{:.10f}'.format(Max / 2))
main()


(n, d) = [int(i) for i in input().split()]
data = sorted([int(i) for i in input().split()])
res = data[0]
res = max(res, d - data[-1])
for i in range(1, n):
	res = max(res, abs(data[i] - data[i - 1]) / 2)
print(res)


from sys import stdin

def input():
	return stdin.readline()[:-1]
import math

def binary_search(beg, end, value):
	global a
	if beg == end:
		return (beg + 1, value - a[beg])
	mid = (beg + end) // 2
	if a[mid] < value and a[mid + 1] >= value:
		return (mid + 1, value - a[mid])
	elif a[mid] >= value:
		end = mid - 1
	else:
		beg = mid + 1
	return binary_search(beg, end, value)
(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
d = 0
for i in range(1, n):
	if (a[i] - a[i - 1]) / 2 > d:
		d = (a[i] - a[i - 1]) / 2
if d < max(a[0], l - a[-1]):
	d = max(a[0], l - a[-1])
print(d)


l = int(input().split()[1])
f = list(map(int, input().split()))
f.sort()
m = 0
p = 0
for i in f:
	if i != p and (i - p) / 2 > m:
		m = (i - p) / 2
	p = i
if min(f) != 0 and f[0] > m:
	m = f[0]
if max(f) != l and l - f[len(f) - 1] > m:
	m = l - f[len(f) - 1]
print(m)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
x = max([a[0], m - a[n - 1]] + [(a[i] - a[i - 1]) / 2 for i in range(1, n)])
print(x)


from sys import exit
(n, t) = input().split()
n = int(n)
t = int(t)
test_case = input()
a = []
for i in test_case.split():
	r = int(i)
	a.append(r)
a.sort()
max1 = 0
for x in range(len(a) - 1):
	if a[x + 1] - a[x] > max1:
		max1 = a[x + 1] - a[x]
max1 = max(max1 / 2, max(a[0] - 0, t - a[n - 1]))
print('{0:.10f}'.format(max1))
exit()


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
L = sorted(a)
biggest = 0
for i in range(len(L) - 1):
	biggest = max(biggest, L[i + 1] - L[i])
print(max(biggest / 2, L[0], l - L[-1]))


from sys import stdin
(n, l) = [int(x) for x in stdin.readline().split()]
a = [int(x) for x in stdin.readline().split()]
a = sorted(a)
fake = 0
for i in range(n - 1):
	if a[i + 1] - a[i] > fake:
		fake = a[i + 1] - a[i]
fake = fake / 2
max_0 = a[0] - 0
max_l = l - a[n - 1]
print('%.10f' % max(max_l, max_0, fake))


x = [int(item) for item in input().split()]
y = [int(item) for item in input().split()]
n = x[0]
l = x[1]
y.sort()
ans = []
if len(y) == 1:
	answer = max([l - y[0], y[0] - 0])
elif 0 in y:
	if l in y:
		y.remove(0)
		for item in range(len(y) - 1):
			ans.append(y[item + 1] - y[item])
		ans.append(y[0] - 0)
		answer = max(ans) / 2
	else:
		y.remove(0)
		for item in range(len(y) - 1):
			ans.append(y[item + 1] - y[item])
		ans.append(y[0] - 0)
		ans.append(2 * (l - y[-1]))
		answer = max(ans) / 2
elif l in y:
	for item in range(len(y) - 1):
		ans.append(y[item + 1] - y[item])
	ans.append(2 * (y[0] - 0))
	answer = max(ans) / 2
else:
	for item in range(len(y) - 1):
		ans.append(y[item + 1] - y[item])
	ans.append(2 * (y[0] - 0))
	ans.append(2 * (l - y[-1]))
	answer = max(ans) / 2
print(f'{answer:.10f}')


(n, l) = [int(x) for x in input().split()]
line = [int(x) for x in input().split()]
line.sort()
maxx = max(2 * line[0], 2 * (l - line[-1]))
for i in range(1, n):
	if line[i] - line[i - 1] >= maxx:
		maxx = line[i] - line[i - 1]
n = maxx / 2
print('%.10f' % n)


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
s1 = a[0] - 0
s2 = l - a[-1]
s3 = 0
if len(a) > 1:
	b = [abs(j - i) for (i, j) in zip(a, a[1:])]
	s3 = max(b) / 2
print(max(s1, s2, s3))


(n, l) = map(int, input().split())
lanterns = list(map(int, input().split()))
lanterns.sort()
d_min = 0
for i in range(n):
	if i == 0:
		d_min = lanterns[i] - 0
		if n == 1:
			d_min = max(l - lanterns[i], d_min)
	elif i == n - 1:
		d_min = max(l - lanterns[i], d_min, abs(lanterns[i] - lanterns[i - 1]) / 2)
	else:
		d_min = max(abs(lanterns[i - 1] - lanterns[i]) / 2, d_min)
print(d_min)


k = []
(n, l) = map(int, input().split())
s = [int(x) for x in input().split()]
a = sorted(s)
x = a[0]
y = l - a[-1]
for i in range(1, n):
	r = a[i] - a[i - 1]
	k.append(r)
k.append(2 * x)
k.append(2 * y)
mm = max(k)
print('{:.10f}'.format(mm / 2))


[n, l] = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.sort()
val = max(arr[0], l - arr[n - 1])
for idx in range(1, n):
	val = max(val, (arr[idx] - arr[idx - 1]) / 2)
print(val)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
l = sorted(l)
x = []
for i in range(n - 1):
	x.append(l[i + 1] - l[i])
if n == 1:
	x.append(l[0])
print('%.9f' % max([l[0], max(x) / 2, k - l[n - 1]]))


(n, x) = map(int, input().split())
coords = list(map(int, input().split()))
coords.sort()
min_dist = 0
if 0 not in coords:
	min_dist = coords[0]
if x not in coords:
	min_dist = max(min_dist, x - coords[n - 1])
for i in range(n - 1):
	min_dist = max(min_dist, (coords[i + 1] - coords[i]) / 2)
print('{0:.9f}'.format(min_dist))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
k = 0
for i in range(1, n):
	p = a[i] - a[i - 1]
	if k < p:
		k = p
r = k / 2
if r < a[0]:
	r = a[0]
if r < l - a[n - 1]:
	r = l - a[n - 1]
print('{:.9f}'.format(r))


(n, l) = map(int, input().split())
x = [int(q) for q in input().split()]
y = sorted(x)
a = []
for i in range(1, len(x)):
	a.append(y[i] - y[i - 1])
if len(a) == 0:
	print(max(y[0], l - y[-1]))
else:
	print(max(max(a) / 2, y[0], l - y[-1]))


(n, l) = list(map(int, input().split(' ')))
lst = list(map(int, input().split(' ')))
lst.sort()
max_distance = 0
cor = 0
for i in range(0, len(lst) - 1):
	temp = lst[i + 1] - lst[i]
	if temp > max_distance:
		max_distance = temp
if not 0 == min(lst) and (not l == len(lst)):
	start_corner_distance = min(lst)
	end_corner_distance = l - max(lst)
	if start_corner_distance >= end_corner_distance:
		cor = start_corner_distance
	else:
		cor = end_corner_distance
ans = max(max_distance / 2, cor)
if ans == 0:
	ans = l
print(ans)


(n, p) = input('').split()
p = int(p)
n = int(n)
li = list(map(int, input('').split()[:n]))
t = len(li)
li.sort()
li1 = []
if li[0] != 0:
	li1.append(li[0])
	if li[t - 1] != p:
		li1.append(p - li[t - 1])
		for i in range(t - 1):
			m = (li[i + 1] - li[i]) / 2
			li1.append(m)
	else:
		for i in range(t - 1):
			m = (li[i + 1] - li[i]) / 2
			li1.append(m)
elif li[t - 1] != p:
	li1.append(p - li[t - 1])
	for i in range(t - 1):
		m = (li[i + 1] - li[i]) / 2
		li1.append(m)
else:
	for i in range(t - 1):
		m = (li[i + 1] - li[i]) / 2
		li1.append(m)
print(max(li1))


(a, b) = input().split()
(a, b) = (int(a), int(b))
s = input()
lst = s.split()
for i in range(len(lst)):
	lst[i] = int(lst[i])
lst = sorted(lst)
smin = 0
if lst[0] - 0 >= smin:
	smin = lst[0]
for i in range(len(lst) - 1):
	if (lst[i + 1] - lst[i]) / 2 > smin:
		smin = (lst[i + 1] - lst[i]) / 2
if b - lst[-1] > smin:
	smin = b - lst[-1]
smin = '%.10f' % smin
print(smin)


def find_max_distance(points, end_length):
	longest_distance = points[0] - 0
	for lantern in range(len(points)):
		if lantern == len(points) - 1:
			distance = end_length - points[lantern]
		else:
			distance = (points[lantern + 1] - points[lantern]) / 2
		if distance > longest_distance:
			longest_distance = distance
	return longest_distance
(num_of_lanterns, length_of_street) = [int(i) for i in input().split()]
lantern_points = sorted([int(i) for i in input().split()])
d = find_max_distance(lantern_points, length_of_street)
print(d)


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
if n == 1:
	r = max(a[0], l - a[0])
else:
	b = l - max(a)
	c = min(a)
	d = 0.5 * max([a[i + 1] - a[i] for i in range(n - 1)])
	r = max(b, c, d)
print('%.10f' % r)


(count, distance) = input().split()
count = int(count)
distance = int(distance)
array = sorted([int(i) for i in input().split()])
start = 0
end = distance
current_dist = array[0] - start
pre = array[0]
for elem in array:
	current_dist = max((elem - pre) / 2, current_dist)
	pre = elem
current_dist = max(end - array[-1], current_dist)
print(current_dist)


(n, l) = map(int, input().split())
a = sorted(list(set(map(int, input().split()))))
j = [a[0] - 0, l - a[-1]]
for i in range(1, len(a)):
	j.append(a[i] - a[i - 1])
if max(j) / 2 > j[0] and max(j) / 2 > j[1]:
	print(max(j) / 2)
else:
	print(max(j[:2]))


(n, l) = map(int, input().split())
lps = list(map(int, input().split()))
t = lps[:]
if 0 not in t:
	t.append(0)
if l not in t:
	t.append(l)
t.sort()
x = len(t)
m = 0
for i in range(1, x):
	tmp = t[i] - t[i - 1]
	if t[i - 1] == 0 and t[i - 1] not in lps:
		tmp *= 2
	elif t[i] == l and t[i] not in lps:
		tmp *= 2
	if tmp > m:
		m = tmp
print(m / 2)


a = []
(n, l) = map(int, input().split())
b = list(map(int, input().split()))
b.sort()
a.append(b[0] - 0)
for j in range(1, n):
	a.append((b[j] - b[j - 1]) / 2)
a.append(l - b[-1])
print('{:.9f}'.format(max(a)))


nl = [int(x) for x in input().split()]
data = sorted([int(x) for x in input().split()])
gap = [abs(data[i] - data[i + 1]) / 2 for i in range(len(data) - 1)] if len(data) > 1 else [data[0]]
print('%.10f' % max(max(gap), max(data[0] - 0, nl[1] - data[-1])))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
high = a[0] * 2
if (l - a[-1]) * 2 > high:
	high = (l - a[-1]) * 2
for i in range(n - 1):
	s = a[i + 1] - a[i]
	if s > high:
		high = s
print(high / 2)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
c = []
x = 0
y = 0
for i in range(n - 1):
	c.append(a[i + 1] - a[i])
	if a[i] == 0:
		x += 1
	elif a[i] == max(a):
		y += 1
if x == 0:
	c.append(2 * min(a))
if y == 0:
	c.append(2 * (l - max(a)))
print(max(c) / 2)


(n, l) = [int(i) for i in input().split()]
x = sorted([int(i) for i in input().split()])
res = []
for i in range(n - 1):
	res.append(x[i + 1] - x[i])
res.insert(0, x[0])
print('%.9f' % (max(res) / 2) if res[0] == 0 and x[-1] == l else '%.9f' % max(res[0], l - x[-1], max(res) / 2))


def main():
	par = input().split()
	liczba = int(par[0])
	dlug = int(par[1])
	latarnie = []
	for iter in input().split():
		latarnie.append(int(iter))
	latarnie.sort()
	d = 2 * latarnie[0]
	l = 2 * (dlug - latarnie[len(latarnie) - 1])
	if d < l:
		d = l
	for iter in range(1, len(latarnie)):
		l = latarnie[iter] - latarnie[iter - 1]
		if d < l:
			d = l
	print(d / 2)
main()


input_s = input().split(' ')
input_l = input().split(' ')
list_l = []
for l in input_l:
	list_l.append(int(l))
list_l = list(set(list_l))
for i in range(len(list_l) - 1):
	for j in range(i, len(list_l)):
		if list_l[i] > list_l[j]:
			(list_l[i], list_l[j]) = (list_l[j], list_l[i])
max_length = 0
for i in range(1, len(list_l)):
	max_length = max(max_length, list_l[i] - list_l[i - 1])
max_length /= 2
max_length = max(list_l[0] - 0, int(input_s[1]) - list_l[-1], max_length)
print('%.10f' % max_length)


line = input().split()
(n, l) = (int(line[0]), int(line[1]))
line = input().split()
a = [int(x) for x in line]
a = sorted(a)
if len(a) == 1:
	print(max(a[0], l - a[0]))
else:
	diff = [a[i] - a[i - 1] for i in range(1, n)]
	print(max(max(diff) / 2.0, min(a), l - max(a)))


(n, l) = map(int, input().split())
an = sorted(map(int, input().split()))
result = max(an[0], l - an[-1])
for i in range(n - 1):
	result = max(result, (an[i + 1] - an[i]) / 2.0)
print(result)


(n, l) = map(int, input().split())
f = input().split(' ')
a = []
for cur in f:
	a.append(int(cur))
a.sort()
dmax = a[0]
len = len(a)
if l - a[len - 1] > dmax:
	dmax = l - a[len - 1]
for i in range(len - 1):
	d = (a[i + 1] - a[i]) / 2
	if d > dmax:
		dmax = d
print(dmax)


l = int(input().split()[1])
(*a,) = map(int, input().split())
b = c = 0
for i in sorted(a):
	b = max(b, i - c)
	c = i
print(max(sorted(a)[0], b / 2, l - sorted(a)[-1]))


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
n_l = inlt()
(num_lanterns, l) = (n_l[0], n_l[1])
lantern_pos = inlt()
lantern_pos.sort()
length = len(lantern_pos)
left_dist = lantern_pos[0] - 0
right_dist = l - lantern_pos[length - 1]
res = 0
for i in range(1, length):
	(p, p_prev) = (lantern_pos[i], lantern_pos[i - 1])
	res = max(res, (p - p_prev) / 2)
print(max([left_dist, right_dist, res]))


string_input = input().split(' ')
l = int(string_input[1])
lamps = [int(x) for x in input().split(' ')]
lamps.sort()
dist_max = 0
for i in range(len(lamps) - 1):
	x = lamps[i + 1] - lamps[i]
	if dist_max < x:
		dist_max = x
print(max(dist_max / 2, lamps[0], l - lamps[-1]))


(n, l) = map(int, input().split())
p = input().split()
for i in range(len(p)):
	p[i] = float(p[i])
p.sort()
d = float(max(p[0], l - p[len(p) - 1]))
if n == 2:
	print(max(d, (p[1] - p[0]) / 2))
else:
	for i in range(len(p) - 1):
		d = float(max(d, (p[i + 1] - p[i]) / 2))
	print(d)


(n, l) = map(int, input().split())
lanterens = list(map(int, input().split()))
lanterens.sort()
front = lanterens[0]
end = l - lanterens[-1]
m = 0
curr = 0
for i in range(1, len(lanterens)):
	curr = lanterens[i] - lanterens[i - 1]
	if curr > m:
		m = curr
print(max([m / 2, front, end]))


(n, l) = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
if n == 1:
	print(max(A[0], l - A[0]))
else:
	s = A[1] - A[0]
	for i in range(n - 1):
		if A[i + 1] - A[i] > s:
			s = A[i + 1] - A[i]
	print(max(A[0], l - A[n - 1], s / 2))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
s = a[0] - 0
e = l - a[n - 1]
m = 0
for i in range(n - 1):
	x = a[i + 1] - a[i]
	if x > m:
		m = x
ans = max(s, e)
re = max(m / 2, ans)
print('{0:.10f}'.format(re))


(n, l) = map(int, input().strip().split())
a = map(int, input().strip().split())
a = sorted(a)
prev = a[0] if len(a) else 0
total = 0
if prev > total:
	total = prev
for lamp in a[1:]:
	if (lamp - prev) / 2 > total:
		total = (lamp - prev) / 2
	prev = lamp
if l - prev > total:
	total = l - prev
print(float(total))


n = input()
n = n.split(' ')
l = int(n[1])
n = int(n[0])
arr1 = input()
arr1 = arr1.split(' ')
arr = list()
for i in range(0, len(arr1)):
	a = int(arr1[i])
	arr.append(a)
m = 0
arr = sorted(arr)
for i in range(0, n - 1):
	if arr[i + 1] - arr[i] > m:
		m = arr[i + 1] - arr[i]
m = m / 2
if min(arr) > m:
	m = min(arr)
if l - max(arr) > m:
	m = l - max(arr)
print('{0:.9f}'.format(m))


(n, l) = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.sort()
diff = []
arr = arr
for i in range(1, len(arr)):
	diff.append(arr[i] - arr[i - 1])
if len(diff) >= 1:
	m = max(diff) / 2
	a = arr[0] - 0
	b = l - arr[-1]
	print(max(m, a, b))
else:
	(l, r) = (arr[0], l - arr[0])
	print(max(l, r))


(fu, b) = map(int, input().split())
a = input()
list1 = list(map(int, a.split()))
list1.sort()
list2 = []
if 0 not in list1:
	list2.append(list1[0])
for i in range(len(list1) - 1):
	num1 = list1[i]
	num2 = list1[i + 1]
	list2.append((num2 - num1) / 2)
try:
	if b - list1[-1] <= max(list2):
		print(max(list2))
	else:
		print(b - list1[-1])
except:
	print(b)


production = True
import sys, math, collections, bisect, itertools, heapq, decimal, random, copy, re

def input(f=0, m=0):
	if m > 0:
		return [input(f) for i in range(m)]
	else:
		l = sys.stdin.readline()[:-1]
		if f >= 10:
			u = False
			f = int(str(f)[-1])
		else:
			u = True
		if f == 0:
			p = [l]
		elif f == 1:
			p = list(map(int, l.split()))
		elif f == 2:
			p = list(map(float, l.split()))
		elif f == 3:
			p = list(l)
		elif f == 4:
			p = list(map(int, list(l)))
		elif f == 5:
			p = l.split()
		return p if u else p[0]

def out(l, f=0, n=True):
	if f == 0:
		p = str(l)
	elif f == 1:
		p = ' '.join(map(str, l))
	elif f == 2:
		p = '\n'.join(map(str, l))
	elif f == 3:
		p = ''.join(map(str, l))
	print(p, end='\n' if n else '')

def log(*args):
	if not production:
		print('$$$', end='')
		print(*args)
enu = enumerate
ter = lambda a, b, c: b if a else c
ceil = lambda a, b: -(-a // b)

def mapl(i, f=0):
	if f == 0:
		return list(map(int, i))
	elif f == 1:
		return list(map(str, i))
	elif f == 2:
		return list(map(list, i))

def solve():
	(n, l) = input(1)
	a = input(1)
	a.sort()
	m = max(a[0], l - a[-1]) * 2
	for (i, j) in zip(a, a[1:]):
		m = max(m, abs(i - j))
	out(m / 2)
	log()
	return
solve()


l = int(input().split()[1])
a = sorted(set(map(int, input().split())))
b = []
for i in range(1, len(a)):
	b += [(a[i] - a[i - 1]) / 2]
print(max(b + [a[0], l - a[-1]]))


(n, l) = [int(x) for x in input().split()]
L = [float(x) for x in input().split()]
L.sort()
d = []
for i in range(n):
	if i == 0:
		mind = L[0] - 0
		d.append(mind)
	if i == n - 1:
		mind1 = L[i] - L[i - 1]
		mind2 = l - L[i]
		d.append(mind1 / 2)
		d.append(mind2)
	else:
		mind = L[i] - L[i - 1]
		d.append(mind / 2)
print(max(d))


(n, l) = map(int, input().split())
d = sorted([int(x) for x in input().split()])
dm = max(((d[i + 1] - d[i]) / 2 for i in range(len(d) - 1))) if len(d) > 1 else d[0]
print(max(dm, d[0], l - d[-1]))


(n, l) = [int(x) for x in input().split()]
li = [int(x) for x in input().split()]
li.sort()
maxD = 2 * max(li[0], l - li[n - 1])
for i in range(n - 1):
	if li[i + 1] - li[i] > maxD:
		maxD = li[i + 1] - li[i]
print(maxD / 2)


import re
import sys
first = input().split()
count = int(first[0])
length = int(first[1])
positions = list(map(int, input().split()))
positions.sort()
maxLength = max(positions[0], length - positions[-1])
for i in range(1, count):
	maxLength = max(maxLength, (positions[i] - positions[i - 1]) / 2)
print(maxLength)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
min = 0
a.sort()
for i in range(len(a) - 1):
	sum = a[i + 1] - a[i]
	if sum > min:
		min = sum
if a[0] - 0 > min / 2 or l - a[len(a) - 1] > min / 2:
	print(max(l - a[len(a) - 1], a[0] - 0))
else:
	print(min / 2)


(n, l) = list(map(int, input().split()))
(arr, array) = (sorted(list(map(int, input().split()))), [])
for i in range(n - 1):
	array.append(abs(arr[i] - arr[i + 1]) / 2)
if 0 not in arr:
	array.append(arr[0])
if l not in arr:
	array.append(l - arr[n - 1])
print(float(max(array)))


(n, l) = map(int, input().split())
a = list(map(float, input().split()))
a.sort()
s = a[0] - 0
e = l - a[n - 1]
d = -1
for i in range(0, n - 1):
	d = max(d, a[i + 1] - a[i])
d /= 2
print('%.9f' % max(s, e, d))


lanterns_length = input()
lanterns_location = input()
lanterns_length = list(map(int, lanterns_length.split(' ')))
lanterns_location = list(map(int, lanterns_location.split(' ')))
lanterns_location.append(lanterns_length[1])
lanterns_location = sorted(lanterns_location)
max_distance = lanterns_location[0]
if lanterns_location[-1] - lanterns_location[-2] > max_distance:
	max_distance = lanterns_location[-1] - lanterns_location[-2]
for lanterns in range(len(lanterns_location) - 1):
	distance = lanterns_location[lanterns + 1] - lanterns_location[lanterns]
	if distance / 2 > max_distance:
		max_distance = distance / 2
print(max_distance)


(n, l) = list(map(int, input().split()))
street = list(map(int, input().split()))
street.sort()
maxdist = 0
maxdist = max(street[0], l - street[n - 1]) * 2
for i in range(n - 1):
	t = street[i + 1] - street[i]
	if maxdist < t:
		maxdist = t
print(maxdist / 2)


(a, b) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
low = arr[0] - 0
high = b - arr[-1]
mx = 0
c = 0
for i in range(1, a):
	c = arr[i] - arr[i - 1]
	if c > mx:
		mx = c
print(max(mx / 2, max(low, high)))


n_l = input()
n_l = n_l.split(' ')
n = int(n_l[0])
l = int(n_l[1])
lanterns = input()
lanterns = lanterns.split(' ')
for i in range(len(lanterns)):
	lanterns[i] = int(lanterns[i])
lanterns.sort()
m = int(lanterns[0])
for i in range(1, len(lanterns)):
	distancia = (float(lanterns[i]) - float(lanterns[i - 1])) / 2.0
	if distancia > m:
		m = distancia
last = l - float(lanterns[n - 1])
if last > m:
	m = last
print(m)


(n, l) = map(int, input().split())
arr = []
arr = list(map(int, input().split()))
arr.sort()
if arr[0] != 0:
	d = arr[0]
else:
	d = 0
for i in range(0, n - 1):
	p = (arr[i + 1] - arr[i]) / 2
	if p > d:
		d = p
if arr[n - 1] != l:
	d1 = l - arr[n - 1]
	if d1 > d:
		d = d1
print(d)


(n, l) = map(int, input().split())
pos = list(map(int, input().split()))
pos.sort()
p1 = 0
p2 = 1
maxi = 0
while p2 <= n - 1:
	if pos[p2] - pos[p1] > maxi:
		maxi = pos[p2] - pos[p1]
	p1 += 1
	p2 += 1
maxi = maxi / 2
if pos[0] != 0:
	if pos[0] - 0 > maxi:
		maxi = pos[0] - 0
if pos[-1] != n:
	if l - pos[n - 1] > maxi:
		maxi = l - pos[n - 1]
print(maxi)


(n, l) = [int(x) for x in input().split()]
s = sorted([int(x) for x in input().split()])
d = max(min(s) - 0, l - max(s))
for i in range(n - 1):
	dd = (s[i + 1] - s[i]) / 2
	if dd > d:
		d = dd
print(d)


(n, l) = map(int, input().split())
init = list(map(int, input().split()))
init.sort()
if init[0] != 0:
	c = init[0]
else:
	c = init[0] / 2
for i in range(n - 1):
	if init[i + 1] - init[i] > 2 * c:
		c = (init[i + 1] - init[i]) / 2
if init[n - 1] + c < l:
	print(l - init[n - 1])
else:
	print(c)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
b = []
a.sort()
x = 0
if n == 1:
	p = l - a[0]
	q = a[0]
	if p > q:
		a[0] = p
	else:
		a[0] = q
for i in range(0, n, 1):
	if i == 0:
		b.append(a[i])
	elif i == n - 1 and l - a[i] > 0:
		b.append(l - a[i])
		x = (a[i] - a[i - 1]) / 2
		b.append(x)
	else:
		x = (a[i] - a[i - 1]) / 2
		b.append(x)
b.sort()
b.reverse()
print(b[0])


first = input().split(' ')
n = int(first[0])
l = int(first[1])
second = [int(s) for s in input().split(' ')]
second.sort()
d = 0
for i in range(len(second) - 1):
	d = max(second[i + 1] - second[i], d)
if second[0] != 0 and second[-1] != l:
	print(max(max(second[0], d / 2), max(l - second[-1], d / 2)))
elif second[0] != 0:
	print(max(second[0], d / 2))
elif second[-1] != l:
	print(max(l - second[-1], d / 2))
else:
	print(d / 2)


(n, street_length) = map(int, input().split())
a = list(set(map(int, input().split())))
a.sort()
max_distance = 0
for i in range(1, len(a)):
	distance = a[i] - a[i - 1]
	if distance > max_distance:
		max_distance = distance
radius = max(a[0], max_distance / 2, street_length - a[-1])
print(radius)


(n, l) = (int(x) for x in input().split())
a = [int(x) for x in input().split()]
a.sort()
diff = [0]
for i in range(1, len(a)):
	diff.append(a[i] - a[i - 1])
print(max(l - max(a), min(a), max(diff) / 2))


def main():
	params = [int(x) for x in input().split(' ')]
	a = [int(x) for x in input().split(' ')]
	a.sort()
	res = a[0]
	for i in range(1, len(a)):
		nmax = (a[i] - a[i - 1]) / 2
		if nmax > res:
			res = nmax
	nmax = params[1] - a[params[0] - 1]
	if nmax > res:
		res = nmax
	print(res)
main()


(n, l) = map(int, input().split())
lantern = [int(x) for x in input().split()]
lantern.sort()
D = 0
for i in range(1, n):
	d = 0.5 * (lantern[i] - lantern[i - 1])
	D = max(D, d)
start = lantern[0]
end = l - lantern[-1]
D = max(D, start, end)
print(D)


import sys
(n, l) = list(map(int, sys.stdin.readline().rstrip().split(' ')))
s = list(map(int, sys.stdin.readline().rstrip().split(' ')))
s.sort()
ss = 0
pre = 0
for i in s:
	if i - pre > ss:
		ss = i - pre
	pre = i
ss = ss / 2
if s[0] > ss:
	ss = s[0]
if l - s[-1] > ss:
	ss = l - s[-1]
print(ss)


(n, l) = map(int, input().split())
s = sorted([int(x) for x in input().split()])
print(max(l - s[n - 1], s[0], (max((s[i + 1] - s[i] for i in range(n - 1))) if n > 1 else 0) / 2))


from math import *
from copy import *
from string import *
from random import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
import math
(n, l) = map(int, input().split(' '))
l1 = list(map(int, input().split(' ')))
l1.sort()
mini = 0.0
for i in range(n - 1):
	val = abs(l1[i] - l1[i + 1]) / 2
	if val > mini:
		mini = val
if l1[0] != 0 and mini < l1[0]:
	mini = l1[0] / 1
if l - l1[n - 1] > mini:
	mini = (l - l1[n - 1]) / 1
print(mini)


(a, b) = map(int, input().split())
s = input().split()
s.sort(key=lambda i: int(i))
k = max(int(s[0]) * 2, (b - int(s[-1])) * 2)
for i in range(a - 1):
	if int(s[i + 1]) - int(s[i]) > k:
		k = int(s[i + 1]) - int(s[i])
print(k / 2)


(n, l) = input().split(' ')
n = int(n)
l = int(l)
a = input().split(' ')
for i in range(n):
	a[i] = int(a[i])
a.sort()
m = int(a[0])
f = False
for i in range(1, n):
	b = (int(a[i]) - int(a[i - 1])) / 2
	if b > m:
		m = b
if m < l - a[i]:
	m = l - a[i]
print(m)


(n, l) = map(int, input().split())
a = input()
b = a.split()
c = [int(x) for x in b]
c.sort(reverse=True)
t = []
s = [float(x) for x in t]
s.append(float(c[n - 1] - 0))
s.append(float(l - c[0]))
for i in range(0, n - 1):
	s.append(float(c[i] - c[i + 1]) / 2)
print(max(s))


def count(lantern, N, L):
	max = 0.0
	result = 0.0
	if lantern[0] > L - lantern[N - 1]:
		max = lantern[0]
	else:
		max = L - lantern[N - 1]
	for i in range(0, N - 1):
		result = (lantern[i + 1] - lantern[i]) / 2
		if result > max:
			max = result
	return max
(n, l) = list(map(int, input().split()))
lanterns = list(map(int, input().split()))
lanterns.sort()
score = count(lanterns, n, l)
print(str(score))


(n, k) = list(map(int, input().split()))
l = list(map(int, input().split()))
l.sort()
ans = []
if l[0] != 0:
	ans.append(2 * l[0])
if l[-1] != k:
	ans.append(2 * abs(l[-1] - k))
for i in range(1, n):
	ans.append(l[i] - l[i - 1])
print(max(ans) / 2)


(n, l) = input().split(' ')
n = int(n)
l = int(l)
q = []
p = [int(x) for x in input().split(' ')]
p = sorted(set(p))
q.append(2 * (l - p[-1]))
q.append(2 * p[0])
for i in range(len(p) - 1):
	q.append(p[i + 1] - p[i])
q = sorted(set(q))
print('{:.9f}'.format(q[-1] / 2))


l1 = list(map(int, input().split()))
l2 = list(map(int, input().split()))
l2.sort()
max1 = l2[0]
max2 = l1[1] - max(l2)
max3 = 0
for i in range(l1[0] - 1):
	if l2[i + 1] - l2[i] > max3:
		max3 = l2[i + 1] - l2[i]
print(max(max1, max2, max3 / 2))


(n, l) = [int(i) for i in input().split()]
p = [int(i) for i in input().split()]
p.sort()
d = max(p[0], l - p[-1])
for i in range(n - 1):
	d = max(d, (p[i + 1] - p[i]) / 2)
print(d)


(n, l) = input().split()
n = int(n)
l = int(l)
street = list(map(float, input().split()))
street = sorted(street)
street.insert(0, 0.0)
street.append(float(l + 1))
dist = max(street[1], (street[2] - street[1]) / 2)
for i in range(2, n):
	dist = max(dist, (street[i] - street[i - 1]) / 2, (street[i + 1] - street[i]) / 2)
dist = max(dist, (street[n] - street[n - 1]) / 2, l - street[n])
print('%.8f' % dist)


(n, l) = input().split()
n = int(n)
l = int(l)
k = input().split()
s = []
for i in range(n):
	k[i] = int(k[i])
k.sort()
for i in range(n - 1):
	s.append(k[i + 1] - k[i])
if len(s) == 0:
	p = 0
else:
	p = max(s)
if p / 2 < k[0] or p / 2 < l - k[-1]:
	if k[0] > l - k[-1]:
		print(k[0])
	else:
		print(l - k[-1])
else:
	print(p / 2)


(n, l) = map(int, input().split())
L = set(map(int, input().split()))
L = sorted(L)
d = 0
for i in range(len(L) - 1):
	if d < L[i + 1] - L[i]:
		d = L[i + 1] - L[i]
x = d / 2
y = 0
z = 0
if 0 not in L and L[0] > x:
	y = L[0]
if l not in L and l - L[-1] > x:
	z = l - L[-1]
x = max(x, y, z)
print('%.10f' % x)


import os, sys
from collections import defaultdict, Counter
from io import BytesIO, IOBase
from math import ceil

def main():
	(n, d) = map(int, input().split())
	a = [int(x) for x in input().split()]
	a.sort()
	x = []
	for i in range(n - 1):
		x.append(a[i + 1] - a[i])
	x.append(2 * (a[0] - 0))
	x.append(2 * (d - a[-1]))
	print(max(x) / 2)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		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')
main()


a = tuple(map(int, input().split()))
q = list(map(int, input().split()))
x = []
q.sort()
x += [q[0]] + [a[1] - q[-1]]
for i in range(1, a[0]):
	x += [(q[i] - q[i - 1]) / 2]
print(max(x))


(n, l) = input().split()
n = int(n)
l = int(l)
arr = [int(x) for x in input().split()]
arr.sort(key=None, reverse=False)
md = max(arr[0], l - arr[-1])
for i in range(n - 1):
	if (arr[i + 1] - arr[i]) / 2 > md:
		md = (arr[i + 1] - arr[i]) / 2
print(md)


(n, l) = map(int, input().split())
a = list(map(int, input().strip().split()))
m = -100000
a.sort()
for i in range(n - 1):
	m = max(abs(a[i] - a[i + 1]), m)
m = max(m / 2, max(a[0] - 0, l - a[n - 1]))
print('%.9f' % m)


(n, l) = map(int, input().split())
lst = list(map(int, input().split()))
lst.sort()
dist = 0
for i in range(n - 1):
	if dist < lst[i + 1] - lst[i]:
		dist = lst[i + 1] - lst[i]
dist1 = lst[0]
dist2 = l - lst[n - 1]
dist3 = max(float(dist1), float(dist2), dist / 2)
dist3 = str(dist3)
a = dist3.find('.')
b = dist3[a + 1:]
c = dist3[:a + 1]
while len(b) < 9:
	b += '0'
c += b
print(c)


(a, b) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
m = 0
for i in range(0, a - 1):
	q = l[i + 1] - l[i]
	if q > m:
		m = q
if l.count(0) == 0:
	if min(l) * 2 > m:
		m = min(l) * 2
if l.count(b) == 0:
	if (b - max(l)) * 2 > m:
		m = (b - max(l)) * 2
print(m / 2)


(l, s) = input().split()
l = int(l)
s = int(s)
lanterns = [int(i) for i in input().split()]
lanterns.sort()
ans = 0
for i in range(l):
	if i == 0:
		if l == 1:
			x = max(lanterns[0] - 0, s - lanterns[0])
		else:
			x = max(lanterns[0] - 0, (lanterns[1] - lanterns[0]) / 2)
		ans = max(ans, x)
	elif i == l - 1:
		x = max(s - lanterns[l - 1], (lanterns[l - 1] - lanterns[l - 2]) / 2)
		ans = max(ans, x)
	else:
		x = max((lanterns[i] - lanterns[i - 1]) / 2, (lanterns[i + 1] - lanterns[i]) / 2)
		ans = max(ans, x)
print(ans)


(n, l) = [int(x) for x in input().split()]
arr = sorted(list({int(x) for x in input().split()}))
mx = max(arr[0], l - arr[-1])
for i in range(len(arr) - 1):
	mx = max(mx, (arr[i + 1] - arr[i]) / 2)
print('%.9f' % mx)


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
maxdist = 0
for i in range(n - 1):
	if max(a[i], a[i + 1]) - min(a[i], a[i + 1]) > maxdist:
		maxdist = max(a[i], a[i + 1]) - min(a[i], a[i + 1])
print(max(maxdist / 2, max(a[0], l - a[n - 1])))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
ans = 0
for i in range(n - 1):
	ans = max(ans, abs(a[i] - a[i + 1]))
if a[0] == 0 and a[n - 1] == l:
	print(ans / 2)
else:
	print(max(a[0], ans / 2, l - a[n - 1]))


specs = input().split(' ')
specs = list(map(int, specs))
positions = input().split(' ')
positions = list(map(int, positions))
positions.sort()
totalmax = 0
for i in range(1, specs[0]):
	totalmax = max(totalmax, (positions[i] - positions[i - 1]) / 2)
p1 = False
pn = False
if positions[0] == 0:
	p1 = True
if positions[-1] == specs[1]:
	pn = True
if p1 and pn:
	print(totalmax)
elif p1:
	print(max(totalmax, specs[1] - positions[-1]))
elif pn:
	print(max(totalmax, positions[0]))
else:
	print(max(totalmax, positions[0], specs[1] - positions[-1]))


f = lambda : map(int, input().split())
(n, l) = f()
v = sorted(list(map(int, input().split())))
dmax = 0
for i in range(n - 1):
	d = (int(v[i + 1]) - int(v[i])) / 2
	if d > dmax:
		dmax = d
if int(v[0]) != 0:
	if int(v[0]) > dmax:
		dmax = int(v[0])
if int(v[n - 1]) != l:
	if l - int(v[n - 1]) > dmax:
		dmax = l - int(v[n - 1])
print(dmax)


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
ans = 0
if len(a) == 1:
	ans = max([ans, a[0], l - a[0]])
else:
	for i in range(n):
		if i == 0:
			ans = max(ans, a[i])
		else:
			gap = (a[i] - a[i - 1]) / 2
			ans = max(ans, gap)
			if i == n - 1:
				ans = max(ans, l - a[i])
print(ans)


(n, l) = [int(a) for a in input().split()]
lanters = [int(a) for a in input().split()]
lanters.sort()
maxdist = 0
for x in range(1, len(lanters)):
	maxdist = max(lanters[x] - lanters[x - 1], maxdist)
print(max(maxdist / 2, max(lanters[0], l - lanters[-1])))


(n, l) = map(int, input().split(' '))
ip = list(map(int, input().split(' ')))
op = sorted(ip)
count = 1
i = 1
maxx = 1
maxx1 = op[0] - 0
maxx2 = l - op[n - 1]
while i < n:
	if op[i] - op[i - 1] > maxx:
		maxx = op[i] - op[i - 1]
	i += 1
if maxx1 > maxx2:
	if maxx1 > maxx / 2:
		print(float(maxx1))
	else:
		print(float(maxx / 2))
elif maxx2 > maxx / 2:
	print(float(maxx2))
else:
	print(float(maxx / 2))


def solve(n, l, arr):
	arr.sort()
	ans = 2 * max(arr[0], l - arr[n - 1])
	for i in range(n - 1):
		ans = max(ans, arr[i + 1] - arr[i])
	return ans / 2
(n, l) = map(int, input().split())
arr = [int(x) for x in input().split()]
print(solve(n, l, arr))


p = 0
v = []
(n, l) = map(int, input().split())
for i in sorted(map(int, input().split())):
	v.append((i - p) / 2)
	p = i
v[0] *= 2
v.append(l - p)
print(max(v))


(n, l) = map(int, input().split())
x = [int(x) for x in input().split()]
x.sort()
radius = 0
if x[0] != 0:
	radius = x[0] - 0
if x[-1] != l:
	if radius == 0:
		radius = l - x[-1]
	else:
		temp = l - x[-1]
		if radius < temp:
			radius = temp
for i in range(len(x) - 1):
	temp = (x[i + 1] - x[i]) / 2
	if temp > radius:
		radius = temp
print('%.10f' % float(radius))


(n, l) = map(int, input().split())
r = sorted(map(int, input().split()))
d = max(r[0], l - r[n - 1])
for i in range(1, n):
	d = max((r[i] - r[i - 1]) / 2, d)
print(d)


line = input()
(n, l) = map(int, line.split(' '))
line = input()
points = list(map(int, line.split(' ')))
points.sort()
d = max(points[0], l - points[-1])
for i in range(1, len(points)):
	d = max(d, (points[i] - points[i - 1]) / 2)
print(d)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
a = []
if arr[0] != 0:
	a.append(arr[0])
if arr[-1] != l:
	a.append(l - arr[-1])
for i in range(n - 1):
	a.append((arr[i + 1] - arr[i]) / 2)
a.sort(reverse=True)
print('{:.10f}'.format(a[0]))


(n, l) = [float(e) for e in input().split()]
a = [float(e) for e in input().split()]
a.sort()
b = [a[0] - 0, l - a[-1]]
for i in range(len(a) - 1):
	b.append((a[i + 1] - a[i]) / 2)
print(round(max(b), 10))


(n, l) = map(int, input().split())
ilums = sorted(list(map(int, input().split())))
d = max(ilums[0] - 0.0, l - ilums[-1])
for i in range(n - 1):
	tmp = (ilums[i + 1] - ilums[i]) / 2
	if tmp > d:
		d = tmp
print('%.10f' % d)


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
(b, ma) = ([], 0)
b += set(a)
b.sort()
for i in range(len(b) - 1):
	if b[i + 1] - b[i] > ma:
		ma = b[i + 1] - b[i]
print(max(ma / 2, b[0], l - b[len(b) - 1]))


from math import *
(n, l) = map(int, input().split())
niz = list(map(int, input().split()))
niz.sort()
res = max(niz[0] - 0, l - niz[n - 1])
for i in range(1, n):
	res = max(res, (niz[i] - niz[i - 1]) / 2)
print(res)


(n, l) = map(int, input().split())
li = [int(x) for x in input().split()]
li.sort()
a = list()
for i in range(n - 1):
	x = li[i + 1] - li[i]
	a.append(x)
first = li[0] - 0
last = l - li[-1]
a.append(first * 2)
a.append(last * 2)
print('%.10f' % float(max(a) / 2))


from math import *
from time import *
from calendar import *
(n, l) = [int(x) for x in input().split()]
a = [float(x) for x in input().split()]
a = sorted(a)
ans = a[0]
for i in range(1, len(a)):
	ans = max(ans, (a[i] - a[i - 1]) / 2)
ans = max(ans, l - a[n - 1])
print('{:.10f}'.format(ans))


(n, l) = map(int, input().split(' '))
p = set(map(int, input().split(' ')))
positions = list(p)
positions.sort()
differences = []
if len(positions) == 1:
	differences = positions
else:
	for i in range(len(positions) - 1):
		differences.append(positions[i + 1] - positions[i])
max_d = max(differences)
(d1, d2) = (0, 0)
if positions[0] != 0 and positions[0] >= max_d / 2:
	d1 = positions[0]
if positions[len(positions) - 1] != l and l - positions[len(positions) - 1] >= max_d / 2:
	d2 = l - positions[len(positions) - 1]
if d1 != 0 or d2 != 0:
	print(max(d1, d2))
else:
	print(max_d / 2)


a = input('').split(' ')
asd = input('').split(' ')
newAsd = []
for value in asd:
	newAsd.append(int(value))
newAsd.sort()
listOfD = [-1]
for value in range(len(newAsd) - 1):
	listOfD.append(newAsd[value + 1] - newAsd[value])
print(max(max(listOfD) / 2, min(newAsd), int(a[1]) - max(newAsd)))


def main():
	(n, l) = list(map(int, input().split()))
	locations = list(map(int, input().split()))
	locations.sort()
	d = locations[0]
	for index in range(n - 1):
		if locations[index] + 2 * d < locations[index + 1]:
			d = (locations[index + 1] - locations[index]) / 2
	if locations[-1] + d < l:
		d = l - locations[-1]
	d = float(d)
	rest = str(d - int(d))
	d = str(d)
	d = d + '0' * (10 - (len(rest) - 2))
	print(d)
main()


str = input()
str = str.split(' ')
n = int(str[0])
l = int(str[1])
str = input()
arr = str.split(' ')
arr = [int(i) for i in arr]
arr.sort()
maxx = 0
for i in range(1, n):
	maxx = max(maxx, arr[i] - arr[i - 1])
maxx /= 2
maxx = max(maxx, arr[0], l - arr[n - 1])
print(maxx)


import sys
(n, l) = (int(temp) for temp in input().split(' '))
lamps = list(set((int(temp) for temp in input().split(' '))))
lamps.sort()
temp = []
if 0 not in lamps:
	temp.append(float(lamps[0]))
if l not in lamps:
	temp.append(float(l - lamps[len(lamps) - 1]))
for i in range(0, len(lamps) - 1, 1):
	temp.append(float((lamps[i + 1] - lamps[i]) / 2))
print(max(temp))


(n, l) = list(map(int, input().split()))
posns = list(map(int, input().split()))
posns.sort()
diff = 0
i = 1
while i < len(posns):
	dist = abs(posns[i] - posns[i - 1])
	if dist > diff:
		diff = dist
	i = i + 1
if not 0 in posns:
	dist1 = abs(posns[0] - 0)
else:
	dist1 = 0
if not l in posns:
	dist2 = abs(l - posns[-1])
else:
	dist2 = 0
ans = max(diff / 2, dist1, dist2)
print(ans)


(n, l1) = map(int, input().split())
l = [int(x) for x in input().split()]
l = sorted(l)
maximum = 0
for i in range(n - 1):
	if l[i + 1] - l[i] > maximum:
		maximum = l[i + 1] - l[i]
print(float(max(l[0], maximum / 2, l1 - l[-1])))


def solve():
	distances = arr[0]
	for i in range(1, n):
		currentdistance = arr[i] - arr[i - 1]
		distances = max(currentdistance / 2, distances)
	distances = max(l - arr[-1], distances)
	return '{:.10f}'.format(distances)
(n, l) = map(int, input().split())
arr = sorted(list(map(int, input().split())))
print(solve())


(a, b) = map(int, input().split())
c = list(map(int, input().split()))
c.sort()
i = 1
d = max(c[0] - 0, b - c[a - 1])
while i < a:
	d = max(d, (c[i] - c[i - 1]) / 2)
	i = i + 1
print(d)


(n, l) = map(int, input().split())
cord = sorted(map(int, input().split()))
cord.reverse()
m = 0
for i in range(len(cord) - 1):
	if cord[i] - cord[i + 1] > m:
		m = cord[i] - cord[i + 1]
print(f'{max(m / 2, cord[len(cord) - 1], l - cord[0]):.10f}')


(n, k) = map(int, input().split())
a = list(map(int, input().strip().split()))
a.sort()
mini1 = 0
mini2 = 0
mini3 = 0
if 0 not in a:
	mini1 = a[0]
if k not in a:
	mini3 = k - a[n - 1]
for i in range(n - 1):
	if mini2 < (a[i + 1] - a[i]) / 2:
		mini2 = (a[i + 1] - a[i]) / 2
print('%.10f' % max(mini1, mini2, mini3))


(n, l) = [int(x) for x in input().split()]
lanterns = [int(x) for x in input().split()]
lanterns.sort()
required_radius = lanterns[0]
for i in range(1, len(lanterns)):
	dist = lanterns[i] - lanterns[i - 1]
	required_radius = max(required_radius, dist / 2)
required_radius = max(required_radius, l - lanterns[len(lanterns) - 1])
print(required_radius)


(n, l) = map(int, input().split())
List = list(map(int, input().split()))
List.sort()
maxim = 0
for i in range(1, len(List)):
	maxim = max(maxim, List[i] - List[i - 1])
maxim = max(maxim / 2, List[0])
maxim = max(maxim, l - List[-1])
print('{:.10f}'.format(maxim))


(lamps_count, street_length) = [int(x) for x in input().split()]
lamps_positions = sorted([int(x) for x in input().split()])
max_half_diff = 0
for i in range(1, lamps_count):
	half_diff = (lamps_positions[i] - lamps_positions[i - 1]) / 2
	max_half_diff = max(max_half_diff, half_diff)
diff_from_start = lamps_positions[0] - max_half_diff
diff_to_end = street_length - lamps_positions[lamps_count - 1] - max_half_diff
max_diff_from_sides = max(diff_from_start, diff_to_end)
res = max_half_diff
if max_diff_from_sides > 0:
	res += max_diff_from_sides
print(format(res, '.10f'))


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
maxrange = 0
if len(arr) == 1:
	print(max(arr[0], l - arr[0]))
else:
	for i in range(len(arr)):
		if i == 0:
			maxrange = max([maxrange, arr[i], (arr[i + 1] - arr[i]) / 2])
		elif i == len(arr) - 1:
			maxrange = max([maxrange, (arr[i] - arr[i - 1]) / 2, l - arr[len(arr) - 1]])
		else:
			maxrange = max([maxrange, (arr[i] - arr[i - 1]) / 2, (arr[i + 1] - arr[i]) / 2])
	print(maxrange)


def sol():
	(n, l) = map(int, input().split())
	A = [int(i) for i in input().split()]
	A.sort()
	A.insert(0, -A[0])
	A.append(l + (l - A[n]))
	dp = []
	maxDiff = 0
	prev = A[0]
	for i in range(1, n + 2):
		if A[i] - prev > maxDiff:
			maxDiff = A[i] - prev
		prev = A[i]
	print('%.10f' % (maxDiff / 2))
sol()


(n, l) = map(int, input().split())
v = sorted([int(i) for i in input().split()])
print(max(v[0], l - v[-1], max(((v[i + 1] - v[i]) / 2 for i in range(n - 1))) if len(v) > 1 else 0))


def solve():
	ins = input().split()
	n = int(ins[0])
	l = int(ins[1])
	a = sorted(list(map(int, input().split())))
	max_dist = max(a[0], l - a[len(a) - 1]) * 2
	for i in range(1, n):
		if a[i] - a[i - 1] > max_dist:
			max_dist = a[i] - a[i - 1]
	print(max_dist / 2)
solve()


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a = list(set(a))
a.sort()
ans = 0
for i in range(len(a) - 1):
	if (a[i + 1] - a[i]) / 2 > ans:
		ans = (a[i + 1] - a[i]) / 2
print(max(ans, a[0], l - a[-1]))


(m, n) = map(int, input().split())
l = sorted(list(map(int, input().split())))[::-1]
l0 = [2 * l[-1], 2 * (n - l[0])]
for i in range(m - 1):
	l0.append(l[i] - l[i + 1])
max = sorted(l0)[-1]
print('%.10f' % float(max / 2))


(n, l) = (int(x) for x in input().split())
t = list(map(int, input('').split()))
t.sort()
najvecja_razdalja = 0
if t[0] != 0:
	najvecja_razdalja = t[0] - 0
if t[n - 1] != l and l - t[n - 1] > najvecja_razdalja:
	najvecja_razdalja = l - t[n - 1]
for i in range(len(t) - 1):
	if (t[i + 1] - t[i]) / 2 > najvecja_razdalja:
		najvecja_razdalja = (t[i + 1] - t[i]) / 2
print(format(najvecja_razdalja, '.10f'))


(a, b) = input().split()
a = int(a)
b = int(b)
x = [int(x) for x in input().split()]
x.sort()
if len(x) == 1:
	if x[0] == 0 or x[0] == b:
		print(float(b))
		exit()
	else:
		print(max(x[0], b - x[0]))
		exit()
for i in range(a):
	if i == 0:
		mx = x[i] - 0
	elif i == a - 1:
		c = max(b - x[i], (x[i] - x[i - 1]) / 2)
		if c > mx:
			mx = c
	elif (x[i] - x[i - 1]) / 2 > mx:
		mx = (x[i] - x[i - 1]) / 2
print(float(mx))


(n, l) = map(int, input().split())
a = map(int, input().split())
a = list(a)
c = a
b = []
a.sort()
c.sort()
if c[0] != 0:
	c = [0] + c
else:
	c = c
if c[-1] != l:
	c = c + [l]
else:
	c = c
c.sort()
for i in range(len(c) - 1):
	b = b + [c[i + 1] - c[i]]
if a[0] != 0 and a[-1] != l:
	if max(b) / 2 < max(b[0], b[-1]):
		print(max(b[0], b[-1]))
	else:
		print(max(b) / 2)
elif a[0] == 0 and a[-1] == l:
	print(max(b) / 2)
elif a[0] == 0 and a[-1] != l:
	if max(b) / 2 < b[-1]:
		print(b[-1])
	else:
		print(max(b) / 2)
elif a[0] != 0 and a[-1] == l:
	if max(b) / 2 < b[0]:
		print(b[0])
	else:
		print(max(b) / 2)


(n, l) = input().split()
length = int(l)
number_lat = int(n)
lanterns = list(map(int, input().split()))
lanterns.sort()
filter_list = []

def find_biggest_number_from_list(number_list):
	biggest_number = 0
	for number in number_list:
		if number > biggest_number:
			biggest_number = number
	return biggest_number
if number_lat >= 1 and number_lat <= 1000 and (length >= 0) and (length <= 10 ** 9):
	if not 0 in lanterns:
		filter_list.append(lanterns[0])
	if not length in lanterns:
		filter_list.append(length - lanterns[len(lanterns) - 1])
	for i in range(0, len(lanterns) - 1):
		value = lanterns[i + 1] - lanterns[i]
		filter_list.append(value / 2)
	print(find_biggest_number_from_list(filter_list))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
b = []
for i in a:
	if i not in b:
		b.append(i)
c = []
if len(b) > 1:
	for i in range(len(b) - 1):
		c.append(abs(b[i] - b[i + 1]))
	c.sort()
	maxdist = max(c)
elif len(b) == 1:
	maxdist = 1
left = b[0] - 0
right = l - b[len(b) - 1]
number = max(maxdist / 2, max(left, right))
print(number)


(n, l) = map(int, input().split())
l1 = list(map(int, input().split()))
l1.sort()
l2 = []
if not 0 in l1 and (not l in l1):
	l1.insert(0, 0)
	l1.append(l)
	for i in range(len(l1) - 1):
		d = l1[i + 1] - l1[i]
		l2.append(d)
	if max(l2) / 2 > l2[0] and max(l2) / 2 > l2[-1]:
		print(max(l2) / 2)
	elif l2[0] > l2[-1]:
		print(l2[0])
	else:
		print(l2[-1])
elif not 0 in l1:
	l1.insert(0, 0)
	for i in range(len(l1) - 1):
		d = l1[i + 1] - l1[i]
		l2.append(d)
	if l2[0] > max(l2) / 2:
		print(l2[0])
	else:
		print(max(l2) / 2)
elif not l in l1:
	l1.append(l)
	for i in range(len(l1) - 1):
		d = l1[i + 1] - l1[i]
		l2.append(d)
	if l2[-1] > max(l2) / 2:
		print(l2[-1])
	else:
		print(max(l2) / 2)
else:
	for i in range(len(l1) - 1):
		d = l1[i + 1] - l1[i]
		l2.append(d)
	print(max(l2) / 2)


(n, l) = [int(i) for i in input().split()]
arr = [int(i) for i in input().split()]
arr.sort()
max_dist = float('-inf')
curr = 0
for elem in arr:
	max_dist = max(max_dist, elem - curr)
	curr = elem
max_dist = max_dist / 2
print(max(max_dist, arr[0], l - curr))


(n, l) = map(int, input().split(' '))
arr = list(map(int, input().split(' ')))
arr2 = []
arr2.append(min(arr) * 2)
arr2.append((l - max(arr)) * 2)
for i in range(len(arr)):
	n = max(arr)
	arr[arr.index(n)] = -1
	m2 = max(arr)
	arr2.append(n - m2)
print(max(arr2) / 2)


(n, l) = map(int, input().split())
list1 = []
list1 = list(input().split())
for x in range(0, len(list1)):
	list1[x] = int(list1[x])
list1.sort()
maxm = 0
for x in range(1, len(list1)):
	diff = list1[x] - list1[x - 1]
	if diff / 2 > maxm:
		maxm = diff / 2
ans = max(list1[0], l - list1[n - 1])
if ans > maxm:
	print(ans)
else:
	print(maxm)


(n, l) = map(int, input().split())
positions = sorted(list(map(int, input().split())))
high = positions[0] * 2
for i in range(1, len(positions)):
	if positions[i] - positions[i - 1] > high:
		high = positions[i] - positions[i - 1]
high = max((l - positions[-1]) * 2, high)
print(high / 2)


a = input().split()
l = int(a[0])
r = int(a[1])
a = input().split()
a = [int(i) for i in a]
a.sort()
dmax = 0
for i in range(l):
	if i == 0:
		d = a[0]
	else:
		d = (a[i] - a[i - 1]) / 2
	if d > dmax:
		dmax = d
d = r - a[l - 1]
if dmax > d:
	print(dmax)
else:
	print(d)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
r1 = a[0]
r2 = l - a[n - 1]
if n > 1:
	r3 = a[1] - a[0]
else:
	r3 = 0
for i in range(1, n):
	r4 = a[i] - a[i - 1]
	if r4 > r3:
		r3 = r4
r3 = r3 / 2
d = max(r1, r2, r3)
print(d)


firstinput = list(map(int, input().split()))
lightpositions = sorted(list(map(int, input().split())))
lastvalue = 0
greatestdistance = lightpositions[0]
flagbetweenlights = 0
for i in range(len(lightpositions)):
	if (lightpositions[i] - lastvalue) / 2 > greatestdistance:
		greatestdistance = (lightpositions[i] - lastvalue) / 2
		flagbetweenlights = 1
	lastvalue = lightpositions[i]
endofstreet = firstinput[1]
if endofstreet - lastvalue > greatestdistance:
	greatestdistance = endofstreet - lastvalue
	flagbetweenlights = 0
if flagbetweenlights == 1:
	print(greatestdistance)
else:
	print(greatestdistance)


(n, length) = map(int, input().split())
positions = list(map(int, input().split()))
positions.sort()
radii = [(positions[i] - positions[i - 1]) / 2 for i in range(1, n)]
radii += [positions[0], length - positions[-1]]
print(max(radii))


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
d = []
if 0 in a and l in a:
	for i in range(n - 1):
		b = (a[i + 1] - a[i]) / 2
		d.append(b)
elif 0 in a and l not in a:
	for i in range(len(a) - 1):
		b = (a[i + 1] - a[i]) / 2
		d.append(b)
	d.append(l - a[n - 1])
elif 0 not in a and l in a:
	for i in range(len(a) - 1):
		b = (a[i + 1] - a[i]) / 2
		d.append(b)
	d.append(a[0])
else:
	for i in range(len(a) - 1):
		b = (a[i + 1] - a[i]) / 2
		d.append(b)
	d.append(a[0])
	d.append(l - a[n - 1])
print(max(d))


(n, ll) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
b = []
ans1 = 0
ans2 = 0
ans3 = 0
if a[0] != 0:
	ans1 = a[0]
if a[n - 1] != ll:
	ans2 = ll - a[n - 1]
for i in range(n):
	try:
		b.append(abs(a[i + 1] - a[i]))
	except:
		continue
	ans3 = max(b) / 2
print(max(ans1, ans2, ans3))


(lmp, dis) = [int(x) for x in input().split()]
lar = [int(x) for x in input().split()]
p = sorted(list(set(lar)))
if len(p) > 1:
	v = max([p[i + 1] - p[i] for i in range(len(p) - 1)])
else:
	v = 0
print(max(v / 2, p[0] - 0, dis - p[-1]))


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
m = a[0] - 0
for i in range(1, n):
	m = max(m, (a[i] - a[i - 1]) / 2)
m = max(m, k - a[n - 1])
print('{0:.10f}'.format(m))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
d = 0
a.sort()
for i in range(1, n):
	m = a[i] - a[i - 1]
	if d < m:
		d = m
o = d / 2
if o < a[0]:
	o = a[0]
if o < l - a[n - 1]:
	o = l - a[n - 1]
print('{:.10f}'.format(o))


(lanternsNum, lengthStreet) = map(int, input().split())
lanterns = list(map(int, input().split()))
lanterns.sort()
maxDif = 0
if lanterns[0] != 0:
	maxDif = 2 * lanterns[0]
if lanterns[-1] != lengthStreet and 2 * (lengthStreet - lanterns[-1]) > maxDif:
	maxDif = 2 * (lengthStreet - lanterns[-1])
for i in range(lanternsNum - 1):
	if lanterns[i + 1] - lanterns[i] > maxDif:
		maxDif = lanterns[i + 1] - lanterns[i]
print(maxDif / 2)


(n, l) = map(int, input().split())
lamps = list(map(int, input().split()))
lamps.sort()
first = lamps[0]
last = l - lamps[n - 1]
d = -1
for i in range(0, n - 1):
	d = max(lamps[i + 1] - lamps[i], d)
d = max(first, last, d / 2)
print(d)


def vanya(n, le, arr):
	arr.sort()
	if arr[0] > le - arr[-1]:
		r = arr[0]
	else:
		r = le - arr[-1]
	for i in range(n - 1):
		if float(arr[i + 1] - arr[i]) / 2.0 > r:
			r = float(arr[i + 1] - arr[i]) / 2.0
	return r
(na, s) = map(int, input().strip().split())
a = list(map(int, input().strip().split()))
print('%.9f' % vanya(na, s, a))


(n, l) = input().split()
lanterns = [int(i) for i in input().split()]
lanterns.sort()
m = max((a - b for (a, b) in zip(lanterns[1:], lanterns)), default=0) / 2
print(max(lanterns[0], m, int(l) - lanterns[-1]))


(N, L) = map(int, input().split())
lamps = sorted(map(int, input().split()))
diff = [lamps[i + 1] - lamps[i] for i in range(len(lamps) - 1)]
print(max(diff + [lamps[0] * 2, (L - lamps[-1]) * 2]) / 2)


k = [int(a) for a in input().strip().split()]
n = k[0]
l = k[1]
P = [int(b) for b in input().split()]
P.sort()
d = 0
for j in range(n - 1):
	x = P[j + 1] - P[j]
	if x > d:
		d = x
d1 = P[0]
d2 = l - P[n - 1]
r = d / 2
if d1 > r:
	r = d1
if d2 > r:
	r = d2
print(r)


(n, l) = map(int, input().split())
p = list(map(int, input().split()))
for i in range(n - 1):
	for j in range(n - 1):
		if p[j] > p[j + 1]:
			t = p[j]
			p[j] = p[j + 1]
			p[j + 1] = t
g = []
g.append(p[0])
for i in range(n - 1):
	e = abs(p[i] - p[i + 1])
	g.append(e)
g.append(l - p[n - 1])
mav = g[0]
if mav < g[-1]:
	mav = g[-1]
for i in range(len(g)):
	if g[i] / 2 > mav:
		mav = g[i] / 2
print(mav)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
d = 0
if a[0] != 0:
	d = a[0]
if a[-1] != l:
	t = l - a[-1]
	if d < t:
		d = t
for i in range(n - 1):
	t = (a[i + 1] - a[i]) / 2
	if d < t:
		d = t
print('{:.9f}'.format(d))


(n, l) = map(int, input().split())
m = 0
a = sorted(list(map(int, input().split())))
for i in range(n - 1):
	if a[i + 1] - a[i] > m:
		m = a[i + 1] - a[i]
x = a[0]
y = m / 2
ans = max(x, y)
z = l - a[n - 1]
ans = max(z, ans)
print(ans)


(n, l) = list(map(int, input().split()))
lantern_locatios = list(map(int, input().split()))
lantern_locatios.sort()
locations_diff = []
for i in range(n - 1):
	locations_diff.append(lantern_locatios[i + 1] - lantern_locatios[i])
if n == 1:
	max_diff = max(lantern_locatios[0], l - lantern_locatios[n - 1])
else:
	max_diff = max(locations_diff) / 2
	max_diff = max(max_diff, lantern_locatios[0], l - lantern_locatios[n - 1])
print(max_diff)


(n, l) = list(map(int, input().split()))
lights = set(map(int, input().split()))
sorted_lights = sorted(lights)
max_dist = 0
for i in range(len(lights) - 1):
	max_dist = max(max_dist, sorted_lights[i + 1] - sorted_lights[i])
max_dist = max(max_dist, sorted_lights[0] * 2)
max_dist = max(max_dist, (l - sorted_lights[-1]) * 2)
print(max_dist / 2)


(N, L) = [int(x) for x in input().split()]
lan = [int(x) for x in input().split()]
lan.sort()
x = lan[0]
y = L - lan[-1]
d = -10
for i in range(N - 1):
	if abs(lan[i] - lan[i + 1]) > d:
		d = abs(lan[i] - lan[i + 1])
dis = max(x, y)
dis = max(d / 2, dis)
print(dis, end='')


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
max = 0
for i in range(len(a) - 1):
	if a[i + 1] - a[i] > max:
		max = a[i + 1] - a[i]
if a[0] >= max / 2 and a[0] >= l - a[len(a) - 1]:
	print('%.10f' % a[0])
elif l - a[len(a) - 1] >= max / 2 and l - a[len(a) - 1] >= a[0]:
	print('%.10f' % (l - a[len(a) - 1]))
elif max / 2 >= l - a[len(a) - 1] and max / 2 >= a[0]:
	print('%.10f' % (max / 2))


(n, l) = map(int, input().split())
latern = list(map(int, input().split()))
latern.sort()
Dist = 0
for i in range(1, len(latern)):
	dist = latern[i] - latern[i - 1]
	if dist > Dist:
		Dist = dist
d = max(latern[0], l - latern[len(latern) - 1], Dist / 2)
print(d)


def solve(n, l, e):
	big = float('inf')
	small = float('-inf')
	e.sort()
	diff = max(e[0], l - e[-1])
	for i in range(n - 1):
		diff = max(diff, (e[i + 1] - e[i]) / 2)
	return diff

def main():
	d = input()
	d = [int(i) for i in d.split()]
	a = d[0]
	b = d[1]
	e = input()
	e = [int(i) for i in e.split()]
	ans = solve(a, b, e)
	print(ans)
main()


(n, l) = map(int, input().split())
lan = list(map(int, input().split()))
lan.sort()
d = 0
for x in range(n):
	if x == 0:
		if lan[x] > d:
			d = lan[x]
		if n == 1 and l - lan[x] > d:
			d = l - lan[x]
	if x == n - 2 and lan[-1] != l:
		if (lan[x + 1] - lan[x]) / 2 > d:
			d = (lan[x + 1] - lan[x]) / 2
		if l - lan[-1] > d:
			d = l - lan[-1]
	if x < n - 1 and (lan[x + 1] - lan[x]) / 2 > d:
		d = (lan[x + 1] - lan[x]) / 2
print(d)


(n, l) = map(int, input().split())
a = sorted([int(_) for _ in input().split()])
d = max(min(a), l - max(a))
for i in range(n - 1):
	d = max(d, (a[i + 1] - a[i]) / 2)
print('{0:.10f}'.format(d))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
max2 = 0
if len(a) > 1:
	max2 = abs(a[0] - a[1])
	for i in range(1, len(a) - 1):
		if max2 < abs(a[i] - a[i + 1]):
			max2 = abs(a[i] - a[i + 1])
max1 = max(min(a), l - max(a), max2 / 2)
max1 = format(max1, '0.10f')
print(max1)


a = input()
b = input()
a1 = a.split()
b1 = b.split()
b1.sort(key=float)
d = max(int(b1[0]), int(a1[1]) - int(b1[int(a1[0]) - 1]))
i = 0
while i < int(a1[0]) - 1:
	if int(b1[i + 1]) - int(b1[i]) > 2 * d:
		d = (int(b1[i + 1]) - int(b1[i])) / 2
	i += 1
print(d)


from sys import stdin, stderr

def readInts():
	return map(int, stdin.readline().strip().split())

def print_err(*args, **kwargs):
	print(*args, file=stderr, **kwargs)

def solve(vs, l):
	vs2 = sorted(vs)
	maxd2 = max(2 * vs2[0], 2 * (l - vs2[-1]))
	for ix_lo in range(len(vs2) - 1):
		d2 = vs2[ix_lo + 1] - vs2[ix_lo]
		if d2 > maxd2:
			maxd2 = d2
	return maxd2 / 2

def run():
	(n, l) = readInts()
	vs = readInts()
	print(solve(vs, l))
run()


from sys import stdin, stdout
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
mod = 1000000007
(n, l) = iia()
arr = sorted(iia())
res = max(arr[0] - 0, l - arr[-1])
for i in range(1, n):
	res = max(res, (arr[i] - arr[i - 1]) / 2)
print(res)


(m, l) = input().split()
(m, l) = (int(m), int(l))
lanterns = sorted([int(x) for x in input().split()])
dists = []
for i in range(m - 1):
	dists.append((lanterns[i + 1] - lanterns[i]) / 2)
dists.append(lanterns[0] / 1)
dists.append((l - lanterns[-1]) / 1)
print(max(dists))


inputs = [int(x) for x in input().split()]
l = inputs[1]
lamp_positions = [int(x) for x in input().split()]
sorted_lamp_positions = sorted(lamp_positions)
max_gap = max([sorted_lamp_positions[0], l - sorted_lamp_positions[-1]])
for i in range(len(sorted_lamp_positions) - 1):
	gap = (sorted_lamp_positions[i + 1] - sorted_lamp_positions[i]) / 2
	if gap > max_gap:
		max_gap = gap
print(max_gap)


def sol(L, a):
	a.sort()
	i = 0
	j = 1
	d = 0
	if len(a) == 0:
		return 0
	if len(a) == 1:
		return max(a[0], L - a[0])
	while j != len(a):
		if a[j] - a[i] > d:
			d = a[j] - a[i]
		j = j + 1
		i = i + 1
	min = d / 2
	if a[0] == 0 and a[len(a) - 1] == L:
		return min
	if a[0] != 0 and a[len(a) - 1] == L:
		if min > a[0]:
			return min
		else:
			return a[0]
	if a[0] == 0 and a[len(a) - 1] != L:
		if min > L - a[len(a) - 1]:
			return min
		else:
			return L - a[len(a)]
	if a[0] != 0 and a[len(a) - 1] != len(a):
		return max(min, a[0], L - a[len(a) - 1])
(n, l) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
print(sol(l, a))


n = input().split()
(n, l) = (int(n[0]), int(n[1]))
pts = list(map(int, input().split()))
pts.sort()
fromOrigin = pts[0]
fromEnd = l - pts[-1]
maxDiff = -1
for i in range(n - 1):
	if pts[i + 1] - pts[i] > maxDiff:
		maxDiff = pts[i + 1] - pts[i]
print(max(fromOrigin, fromEnd, maxDiff / 2))


(a, b) = map(int, input().split())
l = sorted((int(i) for i in input().split()))
c = 0
for i in range(1, a):
	if l[i] - l[i - 1] > c:
		c = l[i] - l[i - 1]
c = max(l[0], b - l[a - 1], c / 2)
print('{:.10f}'.format(c))


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
if n > 1:
	a.sort()
	d = a[1] - a[0]
	for i in range(2, n):
		b = a[i] - a[i - 1]
		if d < b:
			d = b
	d /= 2
	if a[0] > d:
		d = a[0]
	if d < l - a[n - 1]:
		d = l - a[n - 1]
	print(format(d, '.10f'))
else:
	if a[0] < l - a[0]:
		d = l - a[0]
	else:
		d = a[0]
	print(format(d, '.10f'))


(n, l) = map(int, input().split())
ls = sorted(list(map(int, input().split())))
b = max(ls[0], max(l - ls[-1], 0), max((ls[i] - ls[i - 1] for i in range(1, n))) / 2 if n > 1 else 0)
print(b)


(n, l1) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
mx = l[0]
for i in range(1, len(l)):
	mx = max(mx, l[i] - l[i - 1])
if l[0] != 0:
	mx = max(mx, 2 * l[0])
if l[n - 1] != 1:
	mx = max(mx, 2 * (l1 - l[n - 1]))
print('%.10f' % (mx / 2))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
radius = 0
for i in range(len(a) - 1):
	rad = a[i + 1] - a[i]
	if radius == 0 or radius < rad:
		radius = rad
print(max(max(a[0], radius / 2), max(a[0], l - a[-1])))


(n, l) = [int(x) for x in input().split()]
x = [int(y) for y in input().split()]
t = False
u = False
for y in x:
	if y == 0:
		t = True
	if y == l:
		u = True
x.sort()
if t == False:
	x.insert(0, 0)
if u == False:
	x.append(l)
i = len(x) - 1
m = -1
while i > 0:
	if i == 1:
		if m < 2 * (x[i] - x[i - 1]) and t == False:
			m = 2 * (x[i] - x[i - 1])
			continue
	if i == len(x) - 1:
		if m < 2 * (x[i] - x[i - 1]) and u == False:
			m = 2 * (x[i] - x[i - 1])
			continue
	if m < x[i] - x[i - 1]:
		m = x[i] - x[i - 1]
	i -= 1
v = m / 2.0
c = str(v) + '000000000'
print(c)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
m = max(min(a), l - max(a))
f = f1 = 0
for i in range(1, n):
	f = a[i] - a[i - 1]
	if f > f1:
		f1 = f
if f1 / 2 > m:
	print(f1 / 2)
else:
	print(m)


def organiseLanterns(lanternList):
	return sorted(lanternList)

def findMinDistLightForFullStreet(orderedLanterns, streetLength):
	assert len(orderedLanterns) > 0
	if len(orderedLanterns) == 1:
		return max(streetLength - orderedLanterns[0], orderedLanterns[0])
	lantFrom = 0
	posFrom = None
	bestDist = 0
	posTo = 0
	lantTo = orderedLanterns[0]
	if lantTo - lantFrom > 0:
		bestDist = lantTo
	posFrom = 0
	lantFrom = orderedLanterns[0]
	posTo += 1
	lantTo = orderedLanterns[posTo]
	while posTo < len(orderedLanterns):
		thisDist = (lantTo - lantFrom) / 2
		if thisDist > bestDist:
			bestDist = thisDist
		posFrom = posTo
		posTo += 1
		if posTo < len(orderedLanterns):
			lantTo = orderedLanterns[posTo]
			lantFrom = orderedLanterns[posFrom]
	if orderedLanterns[-1] < streetLength:
		thisDist = streetLength - orderedLanterns[-1]
		if thisDist > bestDist:
			bestDist = thisDist
	return bestDist

def runLanternDist(listIn):
	(numberOfLanterns, streetLen) = listIn[0].split()
	numberOfLanterns = int(numberOfLanterns)
	streetLen = int(streetLen)
	unorderedLanterns = listIn[1].split()
	for pos in range(len(unorderedLanterns)):
		unorderedLanterns[pos] = int(unorderedLanterns[pos])
	orderedLants = organiseLanterns(unorderedLanterns)
	return findMinDistLightForFullStreet(orderedLants, streetLen)

def inputToData():
	lineOne = input()
	lineTwo = input()
	print(runLanternDist([lineOne, lineTwo]))
inputToData()


(lanterns, maxStreet) = map(int, input().split())
lanternPositions = sorted([int(x) for x in input().split()])
maxDistance = 0
for i in range(lanterns - 1):
	distance = lanternPositions[i + 1] - lanternPositions[i]
	if maxDistance < distance:
		maxDistance = distance
answer = maxDistance / 2
if 0 not in lanternPositions:
	if answer < lanternPositions[0]:
		answer = lanternPositions[0]
if maxStreet not in lanternPositions:
	if answer < maxStreet - lanternPositions[lanterns - 1]:
		answer = maxStreet - lanternPositions[lanterns - 1]
print(answer)


import sys
import math
(a, b) = map(int, input().split())
c = list(map(int, input().split()))
c.sort()
d = []
d.append(c[0])
for i in range(1, a):
	d.append((c[i] - c[i - 1]) / 2)
d.append(b - c[-1])
e = round(max(d), 9)
print(e)


a = input().split()
b = input().split()
c = []
for i in b:
	c.append(int(i))
c.sort()
abstand = []
try:
	for i in range(len(c) - 1):
		x = abs(int(c[i]) - int(c[i + 1]))
		abstand.append(x)
		abstand.sort(reverse=True)
	d = c[0]
	e = int(a[1]) - c[len(c) - 1]
	f = abstand[0] / 2
	if d >= e and d > f:
		print(d)
	elif e > d and e > f:
		print(e)
	else:
		print(f)
except IndexError:
	g = int(a[1]) - c[0]
	if c[0] > g:
		print(c[0])
	else:
		print(g)


import os
import sys
from math import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def array():
	return [int(i) for i in input().split()]
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		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')

def nc2(n):
	if n == 1:
		return 0
	return n * (n - 1) // 2
(n, k) = map(int, input().split())
a = array()
a.sort()
d = a[0]
for i in range(1, n):
	dif = a[i] - a[i - 1]
	if dif / 2 > d:
		d = dif / 2
if k - a[-1] > d:
	d = k - a[-1]
print(d)


arr = [int(_) for _ in input().split()]
a_i = [int(_) for _ in input().split()]
n = arr[0] + 2
a_i.append(0)
a_i.append(arr[1])
a_i.sort()
max_diff = 0
for i in range(1, n):
	diff = a_i[i] - a_i[i - 1]
	if 1 < i < n - 1:
		diff = diff / 2
	if max_diff < diff:
		max_diff = diff
print(max_diff)


(n, s) = [int(x) for x in input().split()]
l = sorted(list(set([int(x) for x in input().split()])))
x = max(l[0], s - l[-1])
y = 0
for i in range(len(l) - 1):
	if l[i + 1] - l[i] > y:
		y = l[i + 1] - l[i]
print(max(x, y / 2))


import sys
inf = float('inf')
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
(mod, MOD) = (1000000007, 998244353)
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

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

def input():
	return sys.stdin.readline().strip()
(n, l) = get_ints()
Arr = get_array()
Arr.sort()
maxi = 0
for i in range(n - 1):
	diff = Arr[i + 1] - Arr[i]
	if diff > maxi:
		maxi = diff
ans = max(maxi / 2, Arr[0], l - Arr[-1])
print(ans)


(n, l) = map(int, input().split())
k = []
a = [int(x) for x in input().strip().split(' ')]
a.sort()
x = a[0] - 0
y = l - a[-1]
if len(a) > 1:
	for i in range(1, n):
		k.append((a[i] - a[i - 1]) / 2)
		max_dist = max(k)
else:
	max_dist = a[0] / 2
z = max(max_dist, max(x, y))
print(z)


(n, l) = [int(x) for x in input().split()]
lanterns = [int(x) for x in input().split()]
lanterns.sort()
max_diff = 0
d1 = 0
d2 = 0
ln = len(lanterns)
i = 0
while i < ln - 1:
	if max_diff < lanterns[i + 1] - lanterns[i]:
		max_diff = lanterns[i + 1] - lanterns[i]
	i = i + 1
if not 0 in lanterns:
	d1 = lanterns[0]
if not n in lanterns:
	d2 = l - lanterns[n - 1]
d = max((max_diff / float(2), d1, d2))
print('{:.10f}'.format(d))


n = list(map(int, input().split(' ')))
l = list(map(int, input().split(' ')))
l.sort()
diff = 2 * (l[0] - 0)
for i in range(n[0] - 1):
	if l[i + 1] - l[i] > diff:
		diff = l[i + 1] - l[i]
if 2 * (n[-1] - l[-1]) > diff:
	diff = (n[-1] - l[-1]) * 2
s = diff / 2
print(s)


def solve():
	(n, l) = [int(x) for x in input().split()]
	a_list = [int(x) for x in input().split()]
	a_list = sorted(a_list)
	max_dist = 0
	for i in range(1, len(a_list)):
		max_dist = max(max_dist, a_list[i] - a_list[i - 1])
	max_dist = max_dist / 2
	edge_max = max(a_list[0], l - a_list[-1])
	print(max(max_dist, edge_max))
solve()


[n, l] = [int(_) for _ in input().split()]
lis = [int(_) for _ in input().split()]
ans = 0
lis.sort()
for i in range(n - 1):
	ans = max(ans, lis[i + 1] - lis[i])
ans = max(lis[0], ans / 2, l - lis[-1])
print(ans)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
maxim = -1
for i in range(1, n):
	if a[i] - a[i - 1] > maxim:
		maxim = a[i] - a[i - 1]
maxim = maxim / 2
if not 0 in a and maxim < a[0]:
	maxim = a[0]
if not l in a and maxim < l - a[-1]:
	maxim = l - a[-1]
print(maxim)


(a, b) = map(int, input().split())
sp = list(map(int, input().split()))
sp.sort()
mx = 0
if not 0 in sp:
	if sp[0] > mx:
		mx = sp[0]
if not b in sp:
	if b - sp[-1] > mx:
		mx = b - sp[-1]
for i in range(1, len(sp)):
	if (sp[i] - sp[i - 1]) / 2 > mx:
		mx = (sp[i] - sp[i - 1]) / 2
print(mx)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
r = max(a[0], l - a[n - 1]) * 2
for i in range(0, n - 1):
	r = max(r, a[i + 1] - a[i])
print(f'{r / 2:.10f}')


(a, b) = input().split(' ')
a = int(a)
b = int(b)
c = input().split(' ')
c = sorted(c, key=lambda x: int(x))
d = c[0]
e = max(b - int(c[-1]), int(c[0]))
for i in c:
	e = max(e, (int(i) - int(d)) / 2)
	d = i
print(e)


p = input()
p = p.split()
n = int(p[0])
l = int(p[1])
m = input()
m = m.split()
a = 0
for i in range(n):
	m[i] = int(m[i])
m.sort()
for i in range(1, n):
	if m[i] - m[i - 1] > a:
		a = m[i] - m[i - 1]
a = a / 2
b = int(m[0])
c = l - int(m[n - 1])
print('%.10f' % max(a, b, c))


(n, l) = map(int, input().split())
s = list(map(int, input().split()))
s.sort()
max = -1
for i in range(1, n):
	if s[i] - s[i - 1] > max:
		max = s[i] - s[i - 1]
max = max / 2
if l - s[n - 1] > max:
	max = l - s[n - 1]
if s[0] - 0 > max:
	max = s[0]
print(format(max, '.10f'))


def main():
	(n, l) = map(int, input().split())
	arr = sorted(list(map(int, input().split())))
	k = 0
	for i in range(n - 1):
		if k < arr[i + 1] - arr[i]:
			k = arr[i + 1] - arr[i]
	(d1, d2) = (0, 0)
	if arr[0] != 0:
		d1 = arr[0]
	if arr[-1] != l:
		d2 = l - arr[-1]
	print(max(k / 2, d1, d2))
main()


a = input().split()
n = int(a[0])
l = int(a[1])
a = input().split()
a = [int(a[i]) for i in range(n)]
a.sort()
M = 0
for i in range(1, len(a)):
	if a[i] - a[i - 1] >= M:
		M = a[i] - a[i - 1]
if a[0] != 0 and a[-1] != l:
	if M / 2 >= max(a[0], l - a[-1]):
		print(M / 2)
	else:
		print(max(a[0], l - a[-1]))
if a[0] != 0 and a[-1] == l:
	if M / 2 >= a[0]:
		print(M / 2)
	else:
		print(a[0])
if a[0] == 0 and a[-1] != l:
	if M / 2 >= l - a[-1]:
		print(M / 2)
	else:
		print(l - a[-1])
if a[0] == 0 and a[-1] == l:
	print(M / 2)


(l, n) = map(int, input().split())
s = sorted(map(int, input().split()))
ans = 0
for i in range(l - 1):
	ans = max(ans, s[i + 1] - s[i])
print(max(ans / 2, s[0], n - s[-1]))


def solution():
	s = input()
	(n, l) = map(int, s.split())
	n = int(n)
	l = int(l)
	numbers = list(map(int, input().split()))
	numbers.sort()
	current_max = numbers[0] * 2
	current_pos = numbers[0]
	for i in range(1, len(numbers)):
		x = numbers[i] - current_pos
		if current_max < x:
			current_max = x
		current_pos = numbers[i]
	x = (l - current_pos) * 2
	if current_max < x:
		current_max = x
	print(current_max / 2)
solution()


(n, l) = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.sort()
max_value = 0
for i in range(0, len(arr) + 1):
	if i == 0:
		max_value = max(max_value, arr[i] * 2)
	elif i == len(arr):
		max_value = max(max_value, abs((l - arr[i - 1]) * 2))
	elif i == len(arr) - 2:
		max_value = max(max_value, abs(arr[i] - arr[i - 1]))
	else:
		max_value = max(max_value, abs(arr[i] - arr[i - 1]))
print(format(max_value / 2, '.9f'))


fi = lambda : map(int, input().split())
(n, l) = fi()
a = sorted(fi())
c = lambda p, q: (q - p) / 2
if len(a) > 1:
	z = zip(a[:-1], a[1:])
	d = max((c(*i) for i in z))
else:
	d = 0
d = max(d, a[0], l - a[-1])
print(d)


(n, p) = map(int, input().split())
l = list(map(int, input().split()))
if n == 1:
	print(max(l[0], p - l[0]))
else:
	l = list(set(l))
	l.sort()
	x = len(l)
	if x == 1:
		print(max(l[0], p - l[0]))
	else:
		t = (l[1] - l[0]) / 2
		for i in range(2, x):
			if (l[i] - l[i - 1]) / 2 > t:
				t = (l[i] - l[i - 1]) / 2
		if t > max(l[0], p - l[x - 1]):
			print(t)
		else:
			print(max(l[0], p - l[x - 1]))


str1 = input()
L1 = str1.split(' ')
length = int(L1[1])
str2 = input()
L2 = str2.split(' ')
numList = []
for number in L2:
	numList.append(int(number))
numList = list(set(numList))
numList.sort()
n = len(numList)
maxlength = 0
x1 = numList[0] - 0
x2 = length - numList[-1]
maxlength = max(maxlength, x1, x2)
for i in range(n - 1):
	x = numList[i + 1] - numList[i]
	maxlength = max(maxlength, x / 2)
print('%.10f' % maxlength)


(n, l) = input().split()
n = int(n)
l = int(l)
list1 = [int(x) for x in input().split()]
list1.sort()
diff = []
for i in range(len(list1) - 1):
	diff.append(list1[i + 1] - list1[i])
final = []
if len(diff) > 0:
	final.append(max(diff) / 2)
final.append(list1[0])
final.append(l - list1[-1])
print('%.10f' % max(final))


(n, m) = map(int, input().split())
li = list(map(int, input().split()))
li = sorted(li)
s = 0
for i in range(1, n):
	s = max(s, li[i] - li[i - 1])
print(max(s / 2, max(li[0] - 0, m - li[n - 1])))


(m, n) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
dist = 0
prev = arr[0]
for i in range(m):
	dist = max(dist, arr[i] - prev)
	prev = arr[i]
dist = max(dist / 2, max(arr[0] - 0, n - arr[m - 1]))
print('%.10f' % dist)


def main():
	(n, m) = map(int, input().split())
	l = list(map(int, input().split()))
	l.sort()
	ans = l[0] - 0
	for i in range(1, n):
		tmp = (l[i] - l[i - 1]) / 2
		ans = max(ans, tmp)
	tmp = m - l[-1]
	ans = max(ans, tmp)
	print('{0:.10f}'.format(ans))
main()


(n, l) = [int(x) for x in input().split()]
deng = []
cha = []
for i in input().split():
	deng.append(int(i))
deng.sort()
if n > 1:
	for i in range(1, n):
		cha.append(deng[i] - deng[i - 1])
	print(max(deng[0], max(cha) / 2, l - deng[n - 1]))
else:
	print(max(l - deng[0], deng[0]))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
x = 0 in a
y = l in a
if x & y:
	mini = 0
	for i in range(n - 1):
		diff = a[i + 1] - a[i]
		if diff > mini:
			mini = diff
	print('{:.9f}'.format(mini / 2))
elif x or y:
	mini = 0
	for i in range(n - 1):
		diff = a[i + 1] - a[i]
		if diff > mini:
			mini = diff
	if 0 in a:
		if l - a[n - 1] > mini / 2:
			print('{:.9f}'.format(l - a[0]))
		else:
			print('{:.9f}'.format(mini / 2))
	elif a[0] - 0 > mini / 2:
		print('{:.9f}'.format(a[0] - 0))
	else:
		print('{:.9f}'.format(mini / 2))
else:
	mini = 0
	for i in range(n - 1):
		diff = a[i + 1] - a[i]
		if diff > mini:
			mini = diff
	start = a[0] - 0
	end = l - a[n - 1]
	if start >= mini / 2 and start >= end:
		print('{:.9f}'.format(start))
	elif end > mini / 2 and end > start:
		print('{:.9f}'.format(end))
	else:
		print('{:.9f}'.format(mini / 2))


(n, l) = input().split()
n = int(n)
gg = int(l)
arr = list(map(int, input().split()))
arr = sorted(arr)
l = 0
for i in range(n - 1):
	h = arr[i + 1] - arr[i]
	l = max(l, h)
ff = max(l / 2, arr[0], gg - arr[-1])
print(ff)


import sys
(pole, l) = input().split(' ')
(pole, l) = (int(pole), int(l))
lis = list(map(int, input().split(' ')))
if pole == 1:
	diff = lis[0] if lis[0] > l - lis[0] else l - lis[0]
	print('{0:.10f}'.format(diff))
	sys.exit()
lis.sort()
diff = lis[1] - lis[0]
for i in range(1, len(lis) - 1):
	if diff < lis[i + 1] - lis[i]:
		diff = lis[i + 1] - lis[i]
diff = diff / 2
if lis[0] == 0 and lis[-1] == l:
	print('{0:.10f}'.format(diff))
elif lis[0] != 0 and lis[-1] == l:
	if lis[0] <= diff:
		print('{0:.10f}'.format(diff))
	else:
		print('{0:.10f}'.format(lis[0]))
elif lis[0] == 0 and lis[-1] != l:
	if l - lis[-1] <= diff:
		print('{0:.10f}'.format(diff))
	else:
		print('{0:.10f}'.format(l - lis[-1]))
elif lis[0] != 0 and lis[-1] != l:
	diff2 = lis[0] if lis[0] > l - lis[-1] else l - lis[-1]
	if diff >= diff2:
		print('{0:.10f}'.format(diff))
	else:
		print('{0:.10f}'.format(diff2))


(n, l) = map(int, input().strip().split())
x = list((int(i) for i in input().strip().split()))
d = 0
x.sort()
for i in range(n - 1):
	d = max(d, x[i + 1] - x[i])
t = d
if 0 not in x:
	d = max(d / 2, x[0])
if l not in x:
	if t != d:
		d = max(d, l - x[n - 1])
	else:
		d = max(d / 2, l - x[n - 1])
if t != d:
	print(d)
else:
	print(d / 2)


(n, l) = map(int, input().split())
ai = list(map(int, input().split()))
ai.sort()
i = 0
x = ai[0]
while i < n - 1:
	if (ai[i + 1] - ai[i]) / 2 > x:
		x = (ai[i + 1] - ai[i]) / 2
	i += 1
if l - ai[n - 1] > x:
	print(l - ai[n - 1])
else:
	print(x)


(n, l) = map(int, input().split())
lamps = [int(i) for i in input().split()]
lamps.sort()
if n > 0:
	left = lamps[0]
	right = l - lamps[n - 1]
	max_d = 0
	for i in range(n - 1):
		if lamps[i + 1] - lamps[i] > max_d:
			max_d = lamps[i + 1] - lamps[i]
	if max_d / 2 > left and max_d / 2 > right:
		print(max_d / 2)
	elif left > right:
		print(left)
	else:
		print(right)
else:
	print(0)


LT = input()
L = input()
LT = LT.split(' ')
L = L.split(' ')
Tama = L
Tama.append(0)
Tama.append(LT[1])
T = []
for i in range(0, len(Tama)):
	T.append(int(Tama[i]))
Tama = T
Tama = sorted(Tama)
D = []
for i in range(0, len(Tama) - 1):
	if i == 0 or i == len(Tama) - 2:
		D.append(Tama[i + 1] - Tama[i])
	else:
		D.append((Tama[i + 1] - Tama[i]) / 2)
D = sorted(D)
print(D.pop())


x = input()
xx = x.split(' ')
n = int(xx[0])
l = int(xx[1])
x = input()
xx = x.split(' ')
a = []
mx = 0
for i in xx:
	a.append(int(i))
	a.sort()
for i in range(n - 1):
	mx = max(float(float(a[i + 1] - a[i]) / 2), mx)
if a[0] != 0:
	mx = max(float(a[0] - 0), mx)
if a[n - 1] != l:
	mx = max(float(l - a[n - 1]), mx)
print(mx)


(n, l) = map(int, input().split())
(ms, ans) = (sorted(map(int, input().split())), 0)
for i in range(n):
	if i == n - 1:
		ans = max(ans, l - ms[i])
		break
	if i == 0:
		ans = max(ans, ms[i] - 0)
	ans = max(ans, ms[i + 1] - ms[i])
print(max(ans / 2, max(ms[0], l - ms[n - 1])))


(n, l) = [int(i) for i in input().split()]
arr = sorted([int(i) for i in input().split()])
maxi = 0
for i in range(n - 1):
	maxi = max(maxi, arr[i + 1] - arr[i])
maxi = max(maxi / 2, arr[0] - 0, l - arr[n - 1])
print(maxi)


(n, l) = [int(m) for m in input().split()]
points = sorted([int(m) for m in input().split()])
a = []
j = -1 * points[0]
for i in range(n):
	a.append((points[i] - j) / 2)
	j = points[i]
a.append(l - points[n - 1])
print(max(a))


(n, l) = map(int, input().split())
k = list(map(int, input().split()))
k.sort()
m = 0
for i in range(0, len(k) - 1):
	if k[i + 1] - k[i] > m:
		m = k[i + 1] - k[i]
x = k[0]
y = m / 2
j = max(x, y)
z = l - k[n - 1]
ans = max(j, z)
print('%.10f' % ans)


(n, l) = map(int, input().split())
lst = list(map(int, input().split()))
lst.sort()
prev = -1
maxdif = 0
count = 1
for el in lst:
	if prev == -1:
		diff = 2 * el
	else:
		diff = el - prev
	maxdif = max(maxdif, diff)
	prev = el
	count += 1
maxdif = max(maxdif, 2 * (l - lst[-1]))
print(maxdif / 2)


(n, l) = map(int, input().split())
m = list(map(int, input().split()))
m.sort()
maxd = 0
d = 0
if m[0] != 0:
	maxd = m[0]
	for i in range(n - 1):
		d = (m[i + 1] - m[i]) / 2
		if d > maxd:
			maxd = d
	d = l - m[n - 1]
	if d > maxd:
		maxd = d
	print(maxd)
else:
	for i in range(n - 1):
		d = (m[i + 1] - m[i]) / 2
		if d > maxd:
			maxd = d
	d = l - m[n - 1]
	if d > maxd:
		maxd = d
	print(maxd)


(la, le) = map(int, input().split())
p_la = list(map(int, input().split()))
p_la.sort()
m = max(p_la[0], le - p_la[-1])
for i in range(0, la - 1):
	m = max(m, (p_la[i + 1] - p_la[i]) / 2)
print(m)


(n, l) = input().split(' ')
(n, l) = (int(n), int(l))
m = list(map(int, input().split(' ')))
m.sort()
d = list()
if m[0] != 0:
	d.append(m[0])
if m[len(m) - 1] != l:
	d.append(l - m[len(m) - 1])
for i in range(len(m) - 1):
	d.append((m[i + 1] - m[i]) / 2)
print('%.10f' % max(d))


import sys
data = sys.stdin.read().strip()
data = data.split('\n')
pos = data[1].split(' ')
n = data[0].split(' ')
for (i, item) in enumerate(pos):
	pos[i] = int(item)
pos.sort()
maxDistEnd = pos[0]
maxDist = 0
for i in range(1, len(pos)):
	if pos[i] - pos[i - 1] > maxDist:
		maxDist = pos[i] - pos[i - 1]
if int(n[1]) - pos[-1] > maxDistEnd:
	maxDistEnd = int(n[1]) - pos[-1]
if maxDistEnd > maxDist / 2:
	print(maxDistEnd)
else:
	print(maxDist / 2)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
razn = []
for i in range(len(a) - 1):
	r = a[i + 1] - a[i]
	razn.append(r)
if len(razn) >= 1:
	m = max(razn) / 2
if not 0 in a or not l in a:
	if len(razn) < 1:
		m = max(a[0], l - a[-1])
	else:
		m = max(m, a[0], l - a[-1])
print('%.10f' % m)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
x = a[0] - 0
y = l - a[n - 1]
re = 0
q = 0
sm = 0
if x > y:
	re = x
else:
	re = y
for i in range(n - 1, 0, -1):
	m = a[i] - a[i - 1]
	if m > sm:
		sm = m
if re >= sm / 2:
	print('{0:.10f}'.format(re))
else:
	print('{0:.10f}'.format(sm / 2))


(n, l) = [int(x) for x in input().split()]
locations = [int(x) for x in input().split()]
locations.sort()
distance = 0
for i in range(n - 1):
	distance = max(distance, locations[i + 1] - locations[i])
print(max(l - max(locations), min(locations), distance / 2))


a = list(input().split(' '))
(n, l) = (int(a[0]), int(a[1]))
a = list(input().split(' '))
a = list((int(x) for x in a))
a.sort()
res = 0
for i in range(n - 1):
	res = max(res, (a[i + 1] - a[i]) / 2)
res = max(res, a[0] - 0)
res = max(res, l - a[n - 1])
print(res)


(n, m) = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
B = [A[0] * 2, (m - A[-1]) * 2]
for i in range(n - 1):
	B.append(A[i + 1] - A[i])
print(max(B) / 2)


(n, l) = map(int, input().split())
a = [int(v) for v in input().split()]
a.sort()
temp = a[0]
b = []
b.append(a[0])
b.append(l - a[n - 1])
for i in range(1, n):
	b.append(round(a[i] - temp) / 2)
	temp = a[i]
b.sort(reverse=-1)
print(format(b[0], '8f'))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
f = a[0]
e = l - a[n - 1]
res = max(f, e)
ini = 0
for i in a:
	mx = (i - ini) / 2
	ini = i
	if mx > res:
		res = mx
print(res)


def createLanternArray(lanterns):
	outputArray = []
	lanternsList = lanterns.split(' ')
	for item in lanternsList:
		outputArray.append(int(item))
	return outputArray

def selection_sort(the_array):
	for k in range(len(the_array) - 1):
		minimum = k
		for j in range(k, len(the_array)):
			if the_array[j] < the_array[minimum]:
				minimum = j
		swap(the_array, minimum, k)

def find_distance(lanterns, length):
	max = 0
	for k in range(len(lanterns) - 1):
		if lanterns[k + 1] - lanterns[k] > max:
			max = lanterns[k + 1] - lanterns[k]
	if lanterns[0] * 2 > max:
		max = lanterns[0] * 2
	if (length - lanterns[-1]) * 2 > max:
		max = (length - lanterns[-1]) * 2
	return max

def swap(the_array, a, b):
	temp = the_array[a]
	the_array[a] = the_array[b]
	the_array[b] = temp
inString1 = input()
numberOfLanterns = int(inString1.split(' ')[0])
length = int(inString1.split(' ')[1])
lanternString = input()
lanternArray = createLanternArray(lanternString)
selection_sort(lanternArray)
max_distance = find_distance(lanternArray, length)
print(max_distance / 2)


(n, l) = map(int, input().split())
lanterns = [int(i) for i in input().split()]
lanterns.sort()
max_diff = max(min(lanterns), l - max(lanterns))
for i in range(n - 1):
	check = (lanterns[i + 1] - lanterns[i]) / 2
	if max_diff < check:
		max_diff = check
print(max_diff)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
b = 0
for i in range(n - 1):
	c = a[i + 1] - a[i]
	if b < c:
		b = c
b = b / 2
g = l - a[-1]
otv = float(max(b, a[0], g))
print(str(otv).ljust(12, '0'))


(n, l) = map(int, input().split())
p = list(map(int, input().split()))
p.sort()
max1 = p[0] - 0
max2 = l - p[n - 1]
maxd = 0
for i in range(1, n):
	dif = p[i] - p[i - 1]
	d = dif / 2
	if d > maxd:
		maxd = d
di = []
di.append(max1)
di.append(max2)
di.append(maxd)
print(max(di))


nl = list(map(int, input().split()))
(n, l) = (nl[0], nl[1])
a = list(map(int, input().split()))
a.sort()
maxdist = 0
for i in range(1, len(a)):
	if a[i] - a[i - 1] > maxdist:
		maxdist = a[i] - a[i - 1]
d = max(maxdist / 2, max(a[0] - 0, l - a[n - 1]))
print('%.10f' % d)


(n, l) = map(int, input().split())
s = input().split()
m = []
for i in range(len(s)):
	m.append(int(s[i]))
m.sort()
if l == 1:
	print('%.10f' % 1)
	raise SystemExit
elif n == 1 and m[0] == 0:
	print('%.10f' % l)
	raise SystemExit
elif n == 1 and m[0] == l:
	print('%.10f' % l)
	raise SystemExit
elif n == 1:
	u = max(m[0], l - m[0])
	print('%.10f' % u)
	raise SystemExit
k = set()
for i in range(len(m) - 1):
	r = m[i + 1] - m[i]
	k.add(r)
a = max(k) / 2
t = max(float(l - m[-1]), float(m[0]))
if t > max(k) / 2:
	print('%.10f' % t)
else:
	print('%.10f' % a)


n = list(map(int, input().split()))
x = list(map(int, input().split()))
p = []
while len(x) > 0:
	p.append(max(x))
	x.remove(max(x))
k = []
v = 0
for l in range(0, len(p) - 1):
	if p[l] == p[l + 1]:
		v = v + 1
if len(p) > 1 and v != len(p) - 1:
	for i in range(0, len(p) - 1):
		k.append(p[i] - p[i + 1])
	c = 0
	j = 0
	if max(k) / 2 < n[1] - max(p):
		print(n[1] - max(p))
	elif max(k) / 2 < min(p):
		print(min(p))
	else:
		print(max(k) / 2)
elif n[1] - p[0] > p[0]:
	print(-p[0] + n[1])
else:
	print(p[0])


a = 0
[m, n] = map(int, input().split())
l = [int(x) for x in input().split()]
ll = set(l)
L = list(ll)
L.sort(reverse=False)
for i in range(len(L) - 1):
	if L[i + 1] - L[i] > a:
		a = L[i + 1] - L[i]
if L[0] > a / 2:
	a = L[0] * 2
if n - L[-1] > a / 2:
	a = (n - L[-1]) * 2
print(float(a) / 2)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
m = -999999
for i in range(n - 1):
	m = max(m, arr[i + 1] - arr[i])
m = max(m / 2, arr[0], l - arr[-1])
print('%.10f' % m)


(n, l) = (int(x) for x in input().split())
lst = [int(x) for x in input().split()]
lst = sorted(lst)
x = 0
for i in range(n - 1):
	if lst[i + 1] - lst[i] > x:
		x = lst[i + 1] - lst[i]
d1 = x / 2
a0 = lst[0]
a1 = l - lst[-1]
a2 = max([a0, a1])
if d1 > max([a0, a1]):
	print('%.10f' % d1)
else:
	print('%.10f' % float(a2))


(n, l) = map(int, input().split())
a = sorted(map(int, input().split()))
dis = [a[i + 1] - a[i] for i in range(n - 1)]
if a[0] == 0 and a[-1] == n:
	print(max(dis) / 2)
elif n == 1:
	print(max(a[0], l - a[0]))
elif max(dis) / 2 < max(a[0], l - a[n - 1]):
	print(max(a[0], l - a[n - 1]))
else:
	print(max(dis) / 2)


(n, a) = map(int, input().split())
N = [int(num) for num in input().split(' ', n - 1)]
N.sort()
b = len(N)
i = 1
x = 0
while i < b:
	m = N[i] - N[i - 1]
	m = m / 2
	x = max(x, m)
	i += 1
i = 1
b = len(N)
N.sort()
N = N + [0]
N = N + [a]
b = len(N)
N.sort()
p = N[1] - N[0]
o = N[b - 1] - N[b - 2]
x = max(x, p, o)
print('%.9f' % x)


def read_data():
	(n, m) = map(int, list(input().strip().split()))
	a = list(map(int, list(input().strip().split())))
	return (n, m, a)

def solve():
	sol = -1
	for i in range(n - 1):
		if a[i + 1] - a[i] > sol:
			sol = a[i + 1] - a[i]
	return max(sol / 2, a[0], m - a[n - 1])
(n, m, a) = read_data()
a.sort()
print(solve())


(n, l) = list(map(int, input().split()))
lanterns = list(map(int, input().split()))
lanterns.sort()
maiorDist = 0
for i in range(len(lanterns) - 1):
	dist = (int(lanterns[i + 1]) - int(lanterns[i])) / 2
	if dist > maiorDist:
		maiorDist = dist
distFim = l - int(lanterns[-1])
if distFim > maiorDist:
	maiorDist = distFim
distInic = int(lanterns[0])
if distInic > maiorDist:
	maiorDist = distInic
if distFim == maiorDist or distInic == maiorDist:
	print('%.9f' % maiorDist)
else:
	print('%.9f' % maiorDist)


nlStr = input()
n = int(nlStr.split()[0])
l = int(nlStr.split()[1])
aStr = input()
aS = aStr.split()
a = [0] * n
for i in range(n):
	a[i] = int(aS[i])
a.sort()
dis_ini = a[0]
dis_fin = l - a[-1]
dis_lan = 0
i = 0
while i < n - 1:
	if dis_lan < a[i + 1] - a[i]:
		dis_lan = a[i + 1] - a[i]
	i = i + 1
dis_lan = dis_lan / 2
print(max(dis_fin, dis_ini, dis_lan))


from collections import deque
from collections import OrderedDict
import math
import sys
import os
from io import BytesIO
(n, l) = map(int, input().split())
alen = input().split()
for i in range(n):
	alen[i] = int(alen[i])
alen.sort()
maxLen = max(alen[0], l - alen[n - 1])
maxLen1 = 0
for i in range(1, n):
	leng = alen[i] - alen[i - 1]
	maxLen1 = max(leng, maxLen1)
if maxLen > maxLen1 / 2:
	print(maxLen)
else:
	print(maxLen1 / 2)


road = input()
road_length = road.split()
lamp_posi = input()
lamp = lamp_posi.split()
lamps = []
for i in lamp:
	lamps.append(int(i))
lamps.sort()
d = 0
for i in lamps:
	if lamps.index(i) != len(lamps) - 1:
		ind = lamps.index(i) + 1
		e = (lamps[ind] - i) / 2
		if e > d:
			d = e
terminal1 = lamps[0] - 0
terminal2 = int(road_length[1]) - lamps[-1]
final = [d, terminal1, terminal2]
print(f'{max(final):.10f}')


from sys import stdin, stdout

def solve(spots, n, l):
	sorted_spots = sorted(set(spots))
	n = len(sorted_spots)
	i = 0
	max_distance = -1
	for i in range(n - 1):
		max_distance = max(max_distance, sorted_spots[i + 1] - sorted_spots[i])
	radius = max_distance / 2
	test_begin = sorted_spots[0] != 0
	first_distance = sorted_spots[0]
	test_end = sorted_spots[n - 1] != l
	last_distance = l - sorted_spots[n - 1]
	if test_begin and first_distance > radius:
		radius = first_distance
	if test_end and last_distance > radius:
		radius = last_distance
	return radius
(n, l) = list(map(int, stdin.readline().strip().split()))
spots = list(map(int, input().rstrip().split()))
stdout.write(str(solve(spots, n, l)))


(n, m) = map(int, input().strip().split())
a = list(map(int, input().split()))
a.sort()
max_diff = 0
for i in range(1, n):
	diff = a[i] - a[i - 1]
	max_diff = max(max_diff, diff)
ans = max_diff / 2
d1 = a[0]
d2 = m - a[n - 1]
ans = max(ans, max(d1, d2))
round(ans, 10)
print(ans)


(n, l) = map(int, input().split())
a = list(sorted(list(map(int, input().split()))))
ans = max(a[0], l - a[-1])
for (i, el) in enumerate(a[1:]):
	ans = max(ans, (el - a[i]) / 2)
print(ans)


(n, l) = map(int, input().split())
x = [int(x) for x in input().split()]
x.sort()
d = len(x)
k = []
for i in range(d - 1):
	m = (x[i + 1] - x[i]) / 2
	k.append(m)
if x[0] != 0:
	k.append(x[0])
if x[-1] != l:
	k.append(l - x[-1])
k.sort()
print(k[-1])


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
if a[0] == 0 and a[-1] == l:
	m = 0
	for f in range(len(a) - 1):
		if a[f + 1] - a[f] > m:
			m = a[f + 1] - a[f]
	ans = m / 2
	print(ans)
else:
	m1 = max(a[0] - 0, l - a[-1])
	m2 = 0
	for f in range(len(a) - 1):
		if a[f + 1] - a[f] > m2:
			m2 = a[f + 1] - a[f]
	m2 /= 2
	print(max(m1, m2))


(n, le) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
r = max(0, l[0] - 0)
for i in range(n - 1):
	r = max(r, (l[i + 1] - l[i]) / 2)
r = max(r, le - l[n - 1])
print(r)


import math
(n, l) = map(int, input().split())
locations = sorted(list(map(int, input().split())))
maxi = 0
for i in range(0, len(locations) - 1):
	maxi = max(maxi, abs(locations[i] - locations[i + 1]))
print(max(maxi / 2, max(locations[0] - 0, l - locations[n - 1])))


(n, l) = map(int, input().split())
posi = list(map(int, input().split()))
posi.sort()
max_diff = -18768437862437
for i in range(len(posi) - 1):
	diff = posi[i + 1] - posi[i]
	if diff > max_diff:
		max_diff = diff
print(max(max_diff / 2, posi[0] - 0, l - posi[-1]))


a = []
a = input().split()
n = int(a[0])
l = int(a[1])
b = []
b = input().split()
c = []
for i in range(n):
	ele = int(b[i])
	c.append(ele)
c.sort()
if len(c) == 1:
	if c[0] >= l - c[0]:
		print(c[0])
	else:
		print(l - c[0])
	exit()
M = []
for i in range(n - 1):
	ele = int(c[i + 1]) - int(c[i])
	M.append(ele)
M.sort()
if c[0] == 0 and c[n - 1] == l:
	print(M[n - 2] / 2)
if c[0] != 0 and c[n - 1] == l:
	if c[0] >= M[n - 2] / 2:
		print(c[0])
	else:
		print(M[n - 2] / 2)
if c[0] == 0 and c[n - 1] != l:
	if l - c[n - 1] >= M[n - 2] / 2:
		print(l - c[n - 1])
	else:
		print(M[n - 2] / 2)
if c[0] != 0 and c[n - 1] != l:
	if c[0] >= M[n - 2] / 2 and c[0] >= l - c[n - 1]:
		print(c[0])
	elif l - c[n - 1] >= M[n - 2] / 2 and l - c[n - 1] >= c[0]:
		print(l - c[n - 1])
	else:
		print(M[n - 2] / 2)


import math
(n, l) = map(int, input().split())
a = sorted(map(int, input().split()))
r = max([a[0], l - a[-1]] + [(a[i + 1] - a[i]) / 2 for i in range(n - 1)])
print('%.10f' % r)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
result = [arr[0], l - arr[n - 1]]
maximum = 0
for i in range(1, len(arr)):
	if (arr[i] - arr[i - 1]) / 2 > maximum:
		maximum = (arr[i] - arr[i - 1]) / 2
result.append(maximum)
print(max(result))


(N, L) = [int(i) for i in input().split()]
Lanterns = [int(j) for j in input().split()]
Lanterns.sort()
Distance = 0
for i in range(N - 1):
	if Lanterns[i + 1] - Lanterns[i] > Distance:
		Distance = Lanterns[i + 1] - Lanterns[i]
print(max(Distance / 2, Lanterns[0], L - Lanterns[-1]))


def main():
	(n, l) = (int(x) for x in input().strip().split(' '))
	a = [int(x) for x in input().strip().split(' ')]
	a.sort()
	d = a[0]
	last_place = a[0]
	for i in range(1, len(a)):
		if (a[i] - last_place) / 2 > d:
			d = (a[i] - last_place) / 2
		last_place = a[i]
	if l - last_place > d:
		d = l - last_place
	print('%.10f' % float(d))
main()


(n, l) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort()
ans = [a[0]]
for i in range(1, n):
	ans.append(a[i] - a[i - 1])
ans.append(l - a[-1])
res = max(ans) / 2
if max(ans) == ans[-1] or max(ans) == a[0]:
	print(max(ans))
	exit(0)
if ans[-1] > res:
	print(ans[-1])
	exit(0)
if ans[0] > res:
	print(ans[0])
	exit(0)
print(res)


def minimum_distance(nl, a):
	(n, l) = (int(x) for x in nl.split())
	lamps = sorted(list(map(int, a.split())))
	val = max(lamps[0], l - lamps[-1])
	if n > 1:
		dist = max((lamps[i] - lamps[i - 1] for i in range(1, n))) / 2
		val = max(val, dist)
	print(val)
minimum_distance(input(), input())


(a, l) = map(int, input().split())
A = list(map(int, input().split()))
A = sorted(A)
if 0 not in A:
	n = min(A)
	x = max(A)
	m = max(n, l - x)
	for i in range(len(A) - 1):
		if (A[i + 1] - A[i]) / 2 > m:
			m = (A[i + 1] - A[i]) / 2
	answer = m
else:
	m = l - max(A)
	for i in range(len(A) - 1):
		if (A[i + 1] - A[i]) / 2 > m:
			m = (A[i + 1] - A[i]) / 2
	answer = m
s = format(m, '6f')
m = str(s) + '0000'
print(m)


ln = input().split(' ')
l = int(ln[0])
n = int(ln[1])
array = input().split(' ')
street = []
for s in array:
	street.insert(len(street), int(s))
street.sort()
if street[0] != 0:
	street.insert(0, -street[0])
if street[len(street) - 1] != n:
	street.insert(len(street), 2 * n - street[len(street) - 1])
m = 0
for i in range(len(street)):
	if i == 0:
		continue
	if street[i] - street[i - 1] > m:
		m = street[i] - street[i - 1]
print('{:.10f}'.format(m / 2))


def main():
	(n, l) = list(map(int, input().split()))
	nums = list(map(int, input().split()))
	nums = sorted(nums)
	ll = nums[0] - 0
	lr = l - nums[-1]
	res = 0
	for i in range(n - 1):
		res = max(res, nums[i + 1] - nums[i])
	res = max(res / 2, ll, lr)
	print(res)
main()


(n, m) = input().split()
n = int(n)
m = int(m)
li = [int(i) for i in input().split()]
li.sort()
lis = []
if n == 1:
	x = li[0]
	y = m - x
	if y == 0:
		m = float(m)
		print(m)
	elif x <= y:
		x = y
		x = float(x)
		print(x)
	else:
		x = float(x)
		print(x)
else:
	for i in range(n):
		if i == n - 1:
			break
		else:
			x = li[i + 1] - li[i]
			lis.append(x)
	lis.sort()
	y = lis[-1]
	y = y / 2
	z = m - li[-1]
	if y <= li[0]:
		y = li[0]
	if y <= z:
		y = z
	y = float(y)
	print(y)


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
mini = a[0]
curr = a[0] + mini
for i in range(1, n):
	if a[i] - mini > curr:
		mini = (a[i] - a[i - 1]) / 2
	curr = a[i] + mini
if curr < l:
	mini = l - a[n - 1]
print(mini)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
notzero = 0
if a[0] != 0:
	notzero = 1
endl = 0
if a[n - 1] != l:
	endl = 1
max = 0
for i in range(1, n):
	maxi = a[i] - a[i - 1]
	if max < maxi:
		max = maxi
max = max / 2
if notzero:
	if a[0] > max:
		max = a[0]
if endl:
	if l - a[n - 1] > max:
		max = l - a[n - 1]
print(max)


(n, l) = map(int, input().split())
q = list(map(int, input().split()))
a = sorted(q)
if len(a) == 1:
	d = l - a[0]
	if d > a[0]:
		print(d)
	else:
		print(a[0])
else:
	d = a[1] - a[0]
	for i in range(1, n - 1):
		b = a[i:i + 2]
		if b[1] - b[0] > d:
			d = b[1] - b[0]
	c = d / 2
	f = a[0]
	x = l - a[n - 1]
	if f > c and f > x:
		print(f)
	elif c > f and c > x:
		print(c)
	else:
		print(x)


from typing import List

def read_ints() -> List[int]:
	return list(map(int, input().split()))
(lantern_number, length) = read_ints()
lanterns_position = sorted(read_ints())
lanterns_position[0] /= 1
max_d = lanterns_position[0]
for index in range(len(lanterns_position) - 1):
	max_d = max(max_d, (lanterns_position[index + 1] - lanterns_position[index]) / 2)
max_d = max(max_d, length - lanterns_position.pop())
print('{:.10f}'.format(max_d))


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
m = [a[0], l - a[-1]]
for i in range(1, n):
	m.append((a[i] - a[i - 1]) / 2)
x = max(m)
print('{:.10f}'.format(x))


(n, l) = map(int, input().split())
S = list(map(int, input().strip().split()))
S.sort()
temp = 0
maxi = 0
if 0 not in S:
	temp = S[0]
if l not in S:
	maxi = l - S[-1]
maxi = max(temp, maxi)
for i in range(n - 1):
	temp = (S[i + 1] - S[i]) / 2
	maxi = max(maxi, temp)
print('%.10f' % maxi)


(n, l) = [int(x) for x in input().split()]
a = sorted([int(x) for x in input().split()])
max_len = -1
if n > 1:
	for i in range(1, n):
		len = a[i] - a[i - 1]
		if max_len == -1 or len > max_len:
			max_len = len
else:
	max_len = l
print(max(max_len / 2, a[0] - 0, l - a[n - 1]))


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
mx = 0
for i in range(len(a) - 1):
	k = a[i + 1] - a[i]
	if k > mx:
		mx = k
mx = mx / 2
if a[0] != 0:
	if a[0] > mx:
		mx = a[0]
if a[-1] != l:
	h = l - a[-1]
	if h > mx:
		mx = h
print(mx)


(n_lantern, length) = map(int, input().split())
lanterns = sorted([int(i) for i in input().split()])
if len(lanterns) == 1:
	distance = [0]
else:
	distance = [lanterns[i + 1] - lanterns[i] for i in range(len(lanterns) - 1)]
result = max(lanterns[0], max(distance) / 2, length - lanterns[-1])
print(result)


(n, l) = map(int, input().split())
lights = []
for a in map(int, input().split()):
	lights.append(a)
lights.sort()
lights += [2 * l - lights[-1]]
a = lights[0] - 0
b = -a
for x in lights:
	a = max(a, (x - b) / 2)
	b = x
print('%.9f' % round(a, 9))


(lanterns, streetLength) = map(int, input().split())
lanternPositions = sorted([int(x) for x in input().split()])
maxDistance = 0
for i in range(lanterns - 1):
	maxDistance = max(maxDistance, lanternPositions[i + 1] - lanternPositions[i])
answer = max(maxDistance / 2, lanternPositions[0])
answer = max(answer, streetLength - lanternPositions[lanterns - 1])
print(answer)


(a, b) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
x = 0
x = max(0, l[0])
for i in range(len(l) - 1):
	x = max(x, (l[i + 1] - l[i]) / 2)
print(max(x, b - l[len(l) - 1]))


(n, l) = list(map(int, input().split()))
lant = list(map(int, input().split()))
lant.sort()
len = len(lant)
dis = 2 * max(lant[0], l - lant[len - 1])
for i in range(1, len):
	if lant[i] - lant[i - 1] > dis:
		dis = lant[i] - lant[i - 1]
print('{:.10f}'.format(dis / 2))


a = [int(i) for i in input().split(' ')]
n = a[0]
l = a[1]
rmax = 0
r = 0
b = [int(i) for i in input().split(' ')]
b = sorted(b)
for i in range(1, len(b)):
	r = b[i] - b[i - 1]
	if r >= rmax:
		rmax = r
print(max(rmax / 2, b[0], l - b[len(b) - 1]))


(n, l) = map(int, input().split())
lantern = [int(x) for x in input().split()]
lantern.sort()
dis = [lantern[0], l - lantern[-1]]
if n == 1:
	print('%.10f' % max(dis))
else:
	for i in range(0, n - 1):
		p = (lantern[i + 1] - lantern[i]) / 2
		dis.append(p)
	d = max(dis)
	print('%.10f' % d)


import os
import sys
from io import BytesIO, IOBase
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())

def main():
	(n, l) = invr()
	a = inlt()
	a.sort()
	ans = 0
	ans = max(a[0] - 0, l - a[-1])
	if n > 1:
		for i in range(1, n):
			ans = max(ans, (a[i] - a[i - 1]) / 2)
	print(ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		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')
main()


class First:

	def __init__(self):
		(self.n, self.l) = input().split(' ')
		(self.n, self.l) = (int(self.n), int(self.l))
		self.distance = [int(i) for i in input().split(' ')]

	def max_dist(self):
		(n, l, distance) = (self.n, self.l, self.distance)
		distance.sort()
		max_dis = distance[0] if distance[0] > l - distance[-1] else l - distance[-1]
		flag = 0
		for i in range(1, n):
			(x, y) = (distance[i], distance[i - 1])
			if (x - y) / 2 > max_dis:
				max_dis = (x - y) / 2
				flag = 0 if i - 1 == 0 or i == distance[-1] else 1
		print(format(max_dis, '.10f'))
first = First()
first.max_dist()


(n, l) = (int(i) for i in input().split())
laterns = sorted([int(i) for i in input().split()])
dis = [laterns[i] - laterns[i - 1] for i in range(1, n)]
print(max(max(dis) / 2 if dis else 0, min(laterns), l - max(laterns)))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
d = 0
for i in range(n - 1):
	s = a[i + 1] - a[i]
	d = max(s, d)
d = d / 2
if 0 not in a:
	d = max(a[0], d)
if l not in a:
	d = max(l - a[n - 1], d)
print('%.10f' % d)


(n, m) = map(int, input().split())
a = sorted(list(map(int, input().split())))
count = 0
num1 = 0
num2 = 0
while count < n:
	if count == 0:
		if a[count] != 0:
			if len(a) == 1:
				if a[count] < m:
					num1 = m - a[count]
					if num1 < a[count]:
						num1 = a[count]
					count += 1
				else:
					num1 = a[count]
					count += 1
			else:
				num1 = a[count]
				count += 1
		elif m == 1:
			num1 = 1
			count += 1
		elif len(a) == 1:
			num1 = m - a[count]
			count += 1
		else:
			num1 = (a[count + 1] - a[count]) / 2
			count += 1
	elif count == n - 1:
		if a[count] != m:
			num2 = m - a[count]
			if num2 > num1:
				num1 = num2
				count += 1
			count += 1
		else:
			num2 = (a[count] - a[count - 1]) / 2
			if num2 > num1:
				num1 = num2
				count += 1
			count += 1
	else:
		num2 = (a[count + 1] - a[count]) / 2
		if num2 > num1:
			num1 = num2
			count += 1
		else:
			count += 1
print(num1)


(n, l) = map(int, input().split())
lant = list(map(float, input().split()))
lant.sort()
diff = 0
for i in range(n - 1):
	diff = max(lant[i + 1] - lant[i], diff)
ans = max(diff / 2, lant[0] - 0, l - lant[n - 1])
print(f'{ans:.10f}')


(n, l) = map(int, input().split())
nums = [int(x) for x in input().split()]
nums.sort()
max_distance = 0
for i in range(n - 1):
	if max_distance < nums[i + 1] - nums[i]:
		max_distance = nums[i + 1] - nums[i]
max_distance /= 2
if max_distance < max(l - nums[n - 1], nums[0]):
	max_distance = max(l - nums[n - 1], nums[0])
print(max_distance)


(n, l) = map(int, input().split())
input_list = list(map(int, input().split()))
temp_list = input_list[:]
temp_list.insert(0, 0)
temp_list.insert(n, l)
temp_list.sort()
diff = []
for i in range(n + 1):
	if temp_list[i] in input_list and temp_list[i + 1] in input_list:
		diff.append((temp_list[i + 1] - temp_list[i]) / 2)
	else:
		diff.append(temp_list[i + 1] - temp_list[i])
diff.sort()
print('{:.10f}'.format(diff[len(diff) - 1]))


line1 = input()
line1 = [int(x) for x in line1.strip().split()]
n = line1[0]
l = line1[1]
line2 = input()
lanterns = [int(x) for x in line2.strip().split()]
lanterns = sorted(lanterns)
maxdiff = 0
if len(lanterns) > 2:
	for i in range(len(lanterns) - 1):
		lan1 = lanterns[i]
		lan2 = lanterns[i + 1]
		if lan2 - lan1 > maxdiff:
			maxdiff = lan2 - lan1
	res = [maxdiff / 2, lanterns[0], l - lanterns[-1]]
elif len(lanterns) == 2:
	res = [(lanterns[1] - lanterns[0]) / 2, lanterns[0], l - lanterns[-1]]
elif len(lanterns) == 1:
	res = [lanterns[0], l - lanterns[0]]
print(max(res))


(n, m) = map(int, input().split())
z = list(map(int, input().split()))
z.sort()
x = []
for i in range(len(z) - 1):
	x.append((z[i + 1] - z[i]) / 2)
if not 0 in z:
	x.append(z[0])
if not m in z:
	x.append(m - z[-1])
print(float(max(x)))


def getmax(a, b):
	if a > b:
		return a
	else:
		return b
(n, l) = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
r = getmax(A[0], l - A[n - 1]) * 2
for i in range(n - 1):
	r = getmax(r, A[i + 1] - A[i])
print(r / 2)


(n, l) = [int(q) for q in input().split()]
p = [int(a) for a in input().split()]
p.sort()
h1 = p[0]
h3 = l - p[n - 1]
d = 0
for i in range(n - 1):
	if p[i + 1] - p[i] > d:
		d = p[i + 1] - p[i]
h2 = d / 2
r = max(h1, h2, h3)
print('%.9f' % r)


import sys, threading
sys.setrecursionlimit(10 ** 8)
threading.stack_size(10 ** 8)

def main():
	(n, l) = map(int, input().split())
	a = sorted(list(map(int, input().split())))
	minDist = a[0] - 0
	for i in range(1, n):
		minDist = max(minDist, (a[i] - a[i - 1]) / 2)
	minDist = max(minDist, l - a[-1])
	print(minDist)
threading.Thread(target=main).start()


from sys import stdin

def solve(n, l, street):
	street.sort()
	mxdiff = float('-inf')
	for i in range(1, n):
		mxdiff = max(mxdiff, street[i] - street[i - 1])
	return max(mxdiff / 2, max(street[0], l - street[n - 1]))
(n, l) = list(map(int, stdin.readline().split(' ')))
street = list(map(int, stdin.readline().split(' ')))
print(solve(n, l, street))


import sys
import math
import collections
import operator as op
from collections import deque
from math import gcd
from functools import reduce
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2 ** 20)

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def factors(n):
	return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))
T = 1
for _ in range(T):
	(n, l) = list(map(int, stdin.readline().split()))
	a = list(map(int, stdin.readline().split()))
	a.sort()
	mx = -1
	ld = a[0] - 0
	rd = l - a[-1]
	for i in range(n - 1):
		x = a[i + 1] - a[i]
		if x / 2 > mx:
			mx = x / 2
	if ld > mx or rd > mx:
		print(format(max(ld, rd), '.9f'))
	else:
		print(format(mx, '.9f'))


import sys
from bisect import *
from math import floor, sqrt, ceil, factorial as F, gcd, pi
from itertools import chain, combinations, permutations, accumulate
from collections import Counter, defaultdict, OrderedDict, deque
from array import array
INT_MAX = sys.maxsize
INT_MIN = -sys.maxsize - 1
mod = 1000000007
ch = 'abcdefghijklmnopqrstuvwxyz'
lcm = lambda a, b: a * b // gcd(a, b)
setbit = lambda x: bin(x)[2:].count('1')
input = lambda : sys.stdin.readline()

def solve():
	(n, l) = map(int, sys.stdin.readline().split())
	a = list(map(int, sys.stdin.readline().split()))
	max_diff = 0
	a.sort()
	try:
		for i in range(n):
			max_diff = max(max_diff, a[i + 1] - a[i], a[i] - a[i + 1])
	except:
		pass
	if 0 not in a or l not in a:
		max_diff = max(min(a) - 0, max_diff / 2, l - max(a))
		print(float(max_diff))
	else:
		print(max_diff / 2)
solve()


def mergeSort(alist):
	if len(alist) == 1:
		return alist
	leftList = alist[:len(alist) // 2]
	rightList = alist[len(alist) // 2:len(alist)]
	leftList = mergeSort(leftList)
	rightList = mergeSort(rightList)
	return merge(leftList, rightList)

def merge(rl, ll):
	alist = []
	while len(rl) != 0 and len(ll) != 0:
		if rl[0] > ll[0]:
			alist.append(ll[0])
			ll = ll[1:len(ll)]
		else:
			alist.append(rl[0])
			rl = rl[1:len(rl)]
	while len(rl) != 0:
		alist.append(rl[0])
		rl = rl[1:len(rl)]
	while len(ll) != 0:
		alist.append(ll[0])
		ll = ll[1:len(ll)]
	return alist
[n, pathLen] = [int(x) for x in input().split()]
lantList = [int(x) for x in input().split()]
lantList = mergeSort(lantList)
i = 0
highDiff = 0
while i < len(lantList) - 1:
	lowLant = lantList[i]
	highLant = lantList[i + 1]
	if (highLant - lowLant) / 2 > highDiff:
		highDiff = (highLant - lowLant) / 2
	i += 1
lowLen = lantList[0]
highLen = pathLen - lantList[-1]
if lowLen > highDiff:
	highDiff = lowLen
if highLen > highDiff:
	highDiff = highLen
print('{:.10f}'.format(highDiff))


(num, length) = [int(x) for x in input().split()]
lan = [int(x) for x in input().split()]
s = 0
lan.sort()
for i in range(num):
	if i == 0:
		s = lan[0]
	elif s < lan[i] - lan[i - 1]:
		s = lan[i] - lan[i - 1]
print(max(lan[0], s / 2, length - lan[num - 1]))


from random import randint
(n, l) = list(map(int, input().split()))
s = list(map(int, input().split()))
s.sort()

def f(x):
	d = x / 2
	if s[0] - 0 > d:
		return False
	if l - s[-1] > d:
		return False
	for x in range(len(s) - 1):
		if s[x + 1] - s[x] > 2 * d:
			return False
	return True
left = 0
right = l * 2
for i in range(200):
	mid = (left + right) / 2
	if f(mid):
		right = mid
	else:
		left = mid
print(right / 2)


(n, l) = map(int, input().split())
lan = [int(x) for x in input().split()]
lan.sort()
d1 = 0
d2 = max(lan[0], l - lan[-1])
for i in range(n - 1):
	d1 = max(d1, lan[i + 1] - lan[i])
print(max(d1 / 2, d2))


(n, l) = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
if n == 1:
	print(max(a[0], l - a[0]))
else:
	diff = [a[i + 1] - a[i] for i in range(len(a) - 1)]
	d = []
	d.append(max(diff) / 2)
	d.append(min(a))
	d.append(l - max(a))
	print(max(d))


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
if n == 1:
	print('{:.9f}'.format(max(abs(arr[0] - 0), abs(arr[0] - l))))
else:
	diff = arr[1] - arr[0]
	for i in range(2, n):
		d = arr[i] - arr[i - 1]
		if d > diff:
			diff = d
	if arr[0] != 0 and arr[-1] != l:
		a = float(arr[0] - 0)
		b = float(l - arr[-1])
		c = diff / 2
		print('{:.9f}'.format(max(a, max(b, c))))
	elif arr[0] != 0:
		a = float(arr[0] - 0)
		b = diff / 2
		print('{:.9f}'.format(max(a, b)))
	elif arr[-1] != l:
		a = float(l - arr[-1])
		b = diff / 2
		print('{:.9f}'.format(max(a, b)))
	else:
		print('{:.9f}'.format(diff / 2))


(n, l) = map(int, input().split())
(a, x, r, q) = (sorted(map(int, input().split())), 0, 0, 0)
for i in range(len(a) - 1):
	x = max(x, a[i + 1] - a[i])
print(max(l - max(a), min(a), x / 2))


(n, l) = input().split(' ')
n = int(n)
l = int(l)
arr = list(map(int, input().rstrip().split()))
arr.sort()
best = 0
Min = arr[0] - 0
Max = l - arr[len(arr) - 1]
for i in range(len(arr) - 1):
	ss = arr[i + 1] - arr[i]
	if ss > best:
		best = ss
dd = best / 2
a = [Min, Max, dd]
print(round(max(a), 9))


(n, l) = input('').split()
if int(n) == 0:
	print(0)
else:
	l = int(l)
	a = list(map(int, input('').split()))
	a.sort()
	prev = 0
	g = 0
	for i in a:
		if i - prev > g:
			g = i - prev
		prev = i
	r = g / 2
	if a[0] > r:
		r = a[0]
	if l - a[-1] > r:
		r = l - a[-1]
	print(r)


import sys
input = sys.stdin.readline
read_tuple = lambda _type: map(_type, input().split(' '))

def solve():
	(n, l) = read_tuple(int)
	a = [0] + list(sorted(read_tuple(int))) + [l]
	diffs = [a[i] - a[i - 1] for i in range(1, len(a))]
	ans = max(diffs) / 2
	if diffs[0] > ans:
		ans = diffs[0]
	if diffs[-1] > ans:
		ans = diffs[-1]
	print(ans)
solve()


(n, l) = map(int, input().split())
num = [int(x) for x in input().split()]
num.sort()
maxd = max(num[0] - 0, l - num[n - 1])
pre = num[0]
for i in range(1, n):
	maxd = max((num[i] - pre) / 2, maxd)
	pre = num[i]
print('{num1:.10f}'.format(num1=maxd))


(lamps, length) = list(map(int, input().split()))
position = list(map(int, input().split()))
position.sort()
zero = position[0]
ending = length - position[-1]
answer = [position[i] - position[i - 1] for i in range(1, lamps)]
if len(answer) == 0:
	print(max(zero, ending))
else:
	print(max(max(answer) / 2, max(zero, ending)))


(n, l) = map(int, input().split())
nS = sorted([int(x) for x in input().split()])
maxDis = 0
start = False
end = False
if nS[0] != 0:
	nS.insert(0, 0)
	n += 1
	start = True
if nS[n - 1] != l:
	nS.append(l)
	n += 1
	end = True
for i in range(1, n):
	if i == 1 and start or (i == n - 1 and end):
		dis = nS[i] - nS[i - 1]
	else:
		dis = (nS[i] - nS[i - 1]) / 2
	if dis > maxDis:
		maxDis = dis
print('%.10f' % maxDis)


def lantern(n, l, arr):
	res = max(arr[0], l - arr[n - 1])
	for i in range(1, len(arr)):
		res = max(res, arr[i] / 2 - arr[i - 1] / 2)
	return res
(n, l) = map(int, input().split())
arr = [int(v) for v in input().split()]
arr.sort()
print(lantern(n, l, arr))


import collections
import math
local = False
if local:
	file = open('B.txt', 'r')

def inp():
	if local:
		return file.readline().rstrip()
	else:
		return input().rstrip()

def ints():
	return [int(_) for _ in inp().split()]
(n, l) = ints()
a = ints()
a.sort()
ans = max(a[0], l - a[-1])
for i in range(1, len(a)):
	ans = max(ans, (a[i] - a[i - 1]) / 2)
print(ans)


(m, n) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
k = min(a)
l = max(a)
t = 0
for i in range(1, len(a)):
	if a[i] - a[i - 1] > t:
		t = a[i] - a[i - 1]
if n in a and 0 in a:
	print(t / 2)
elif n in a and 0 not in a:
	print(max(t / 2, k))
elif n not in a and 0 in a:
	print(max(t / 2, n - l))
else:
	print(max(t / 2, n - l, k))


(n, l) = map(int, input().split())
a = list(map(int, input().split()[:n]))
a.sort()
mx = 0
ct0 = 0
ct1 = 0
if a[0] != 0:
	a.insert(0, 0)
	ct0 = 1
if a[len(a) - 1] != l:
	a.insert(len(a), l)
	ct1 = 1
n = len(a)
for i in range(1, n):
	d = a[i] - a[i - 1]
	if a[i - 1] == 0 and ct0 or (a[i] == l and ct1):
		d /= 1
	else:
		d /= 2
	if d > mx:
		mx = d
print(mx)


(n, l) = map(int, input().split())
t0 = input().split()
t = []
for i in range(n):
	t.append(int(t0[i]))
p = set(t)
t = list(p)
t.sort()
r = []
if len(t) > 1:
	for i in range(len(t) - 1):
		r.append(t[i + 1] - t[i])
else:
	r.append(t[0])
if '0' in t0 and str(l) in t0:
	print(max(r) / 2)
if '0' not in t0 and str(l) not in t0:
	print(max(t[0], l - t[-1], max(r) / 2))
if '0' in t0 and str(l) not in t0:
	print(max(l - t[-1], max(r) / 2))
if '0' not in t0 and str(l) in t0:
	print(max(t[0], max(r) / 2))


(n, l) = map(int, input().split())
k = list(map(int, input().split()))
k.sort()
max = max(k[0], l - k[-1])
for i in range(len(k) - 1):
	z = (k[i + 1] - k[i]) / 2
	if z > max:
		max = z
print(max)


(n, l) = map(int, input().split())
l1 = list(map(int, input().split()))
l1.sort()
a = l1[0] - 0
for i in range(n - 1):
	a = max(a, 0.5 * (l1[i + 1] - l1[i]))
a = max(a, l - l1[-1])
print(a)


(n, l) = map(int, input().split())
lanterns = list(map(int, input().split()))
lanterns.sort(reverse=True)
dmin = 0
for i in range(n - 1):
	if i == 0:
		dmin = lanterns[0] - lanterns[1]
	else:
		dmin = max(dmin, lanterns[i] - lanterns[i + 1])
print(max(dmin / 2, l - lanterns[0], lanterns[-1]))


(x, y) = [int(i) for i in input().split()]
l = [int(i) for i in input().split()]
o = []
l.sort()
o.append(l[0])
o.append(y - l[-1])
for i in range(x - 1):
	o.append((l[i + 1] - l[i]) / 2)
k = max(o)
print('%.10f' % k)


(n, l) = [int(i) for i in input().split()]
a = list(input().split())
m = []
for i in range(n):
	m.append(int(a[i]))
c = []
m = sorted(m)
c.append(m[0] - 0)
c.append(l - m[n - 1])
for i in range(n - 1):
	c.append((m[i + 1] - m[i]) / 2)
d = max(c)
print('%.10f' % d)


def next(n, l, arr):
	arr.sort()
	max_diff = 0
	for i in range(len(arr) - 1):
		max_diff = max(max_diff, arr[i + 1] - arr[i])
	max_diff = max(max_diff, (arr[0] - 0) * 2, (l - arr[-1]) * 2)
	print(max_diff / 2)
	return
(a, b) = map(int, input().split())
arr = list(map(int, input().split()))
next(a, b, arr)


info = list(map(int, input().split()))
s = list(map(int, input().split()))
s = sorted(s)
l = info[1]
ans = max(s[0] - 0, l - s[-1])
for i in range(len(s) - 1):
	if s[i + 1] - s[i] > 2 * ans:
		ans = (s[i + 1] - s[i]) / 2
print(ans)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
try:
	fake = max([l[x + 1] - l[x] for x in range(len(l) - 1)])
	print(max(fake / 2, max(l[0], k - l[-1])))
except:
	print(max(l[0], k - l[0]))


(n, l) = [int(x) for x in input().split()]
lanterns = [int(x) for x in input().split()]
lanterns.sort()
gap = 2 * max(lanterns[0], l - lanterns[-1])
for i in range(len(lanterns) - 1):
	gap = max(gap, lanterns[i + 1] - lanterns[i])
print('%.10f' % (gap / 2))


(n, l) = map(int, input().split())
li = list(map(int, input().split()))
if l == 1:
	print(1)
elif n == 1 and l != 1:
	print(max(l - max(li), min(li)))
else:
	d = {}
	for i in li:
		if i == 0:
			d[0] = 'y'
		if i == l:
			d[l] = 'y'
	li = sorted(li)
	f = []
	for i in range(len(li) - 1):
		f.append(li[i + 1] - li[i])
	fin = []
	if d.get(0, 0) == 0:
		fin.append(min(li))
	if d.get(l, 0) == 0:
		fin.append(l - max(li))
	fin.append(float(max(f) / 2))
	print(max(fin))


LInput = input().split()
n = int(LInput[0])
l = int(LInput[1])
L = input().split()
for i in range(n):
	L[i] = int(L[i])
L.sort()
m = L[0] - 0
for i in range(0, n - 1):
	if L[i + 1] - L[i] > m:
		m = L[i + 1] - L[i]
m = m / 2
if m < l - L[n - 1] or m < L[0] - 0:
	m = float(max(l - L[n - 1], L[0] - 0))
print('%.10f' % m)


(n, l) = map(int, input().split(' '))
a = sorted(list(map(int, input().split(' '))))
max_d = a[0]
for i in range(len(a) - 1):
	d = (a[i + 1] - a[i]) / 2
	if d > max_d:
		max_d = d
d = l - a[n - 1]
if d > max_d:
	max_d = d
print(max_d)


(n, l) = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
arr.sort()
ans = arr[0]
for i in range(1, n):
	if ans < (arr[i] - arr[i - 1]) / 2:
		ans = (arr[i] - arr[i - 1]) / 2
if ans < l - arr[n - 1]:
	ans = l - arr[n - 1]
if n == 2:
	print('{:.10f}'.format(max(l - arr[1], (arr[1] - arr[0]) / 2, arr[0] - 0)))
else:
	print('{:.10f}'.format(ans))


(lan, street) = [int(x) for x in input().split()]
location = [int(x) for x in input().split()]
location = sorted(location)
d = 0
start = location[0]
end = street - location[-1]
d = max(start, end)
for i in range(lan - 1):
	distance = (location[i + 1] - location[i]) / 2
	d = max(d, distance)
print(d)


R = lambda : map(int, input().split())
(n, l) = R()
arr = sorted(list(R()))
res = 0
for i in range(len(arr) - 1):
	res = max(res, (arr[i + 1] - arr[i]) / 2)
print(max(res, arr[0], l - arr[-1]))


(n, l) = map(int, input().split())
locs = sorted([int(x) for x in input().split()])
m = 0
if n > 1:
	diffs = [locs[i + 1] - locs[i] for i in range(len(locs) - 1)]
	m = max(diffs) / 2
print(max([m, min(locs), l - max(locs)]))


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
arr = [0]
for i in range(1, n):
	arr.append(a[i] - a[i - 1])
print('%.9f' % max(l - max(a), min(a), max(arr) / 2))


(n, l) = map(int, input().split())
s = list(map(int, input().split()))
s.sort()
_max = 0
for i in range(1, n):
	_max = max(_max, s[i] - s[i - 1])
_max /= 2
_max = max(_max, s[0] - 0, l - s[-1])
print('%.9f' % _max)


(n, l) = map(int, input().split())
a = set(map(int, input().split()))
a = list(a)
a.sort()
mi = -float('inf')
mi = max(a[0], l - a[-1])
for i in range(len(a) - 1):
	mi = max(mi, (a[i + 1] - a[i]) / 2)
print('%.10f' % mi)


(x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
maximum = 0.0
for i in range(1, len(a)):
	if a[i] - a[i - 1] > maximum:
		maximum = a[i] - a[i - 1]
if maximum < 2 * a[0]:
	maximum = 2 * a[0]
if maximum < 2 * (y - a[-1]):
	maximum = 2 * (y - a[-1])
print(maximum / 2)


(n, l) = map(int, input().split())
s = list(map(int, input().split()))
s.sort()
a = 0
if s[0] != 0:
	a = 2 * (s[0] - 0)
if s[-1] != l and 2 * (l - s[-1]) > a:
	a = 2 * (l - s[-1])
for i in range(n):
	if i == 0:
		continue
	elif s[i] - s[i - 1] > a:
		a = s[i] - s[i - 1]
print(a / 2)


import math

def main():
	(n, l) = [int(x) for x in input().split()]
	a = [int(x) for x in input().split()]
	a.sort()
	max_dist = 0
	i = 1
	while i < len(a):
		if max_dist < a[i] - a[i - 1]:
			max_dist = a[i] - a[i - 1]
		i += 1
	print(max(a[0], l - a[-1], max_dist / 2))
main()


mod = 1000000007
ssi = lambda : map(int, input().split())
(n, l) = ssi()
a = list(ssi())
a.sort()
low = a[0] - 0
high = l - a[n - 1]
diff = low
for i in range(n - 1):
	diff = max(diff, a[i + 1] - a[i])
diff /= 2
res = max(diff, low, high)
print('%.10f' % res)


def lattern(arr, l):
	arr.sort()
	diff = 0
	for i in range(1, len(arr)):
		if arr[i] - arr[i - 1] > diff:
			diff = arr[i] - arr[i - 1]
	dstart = arr[0]
	dend = l - arr[len(arr) - 1]
	dmid = diff / 2
	result = max(dstart, dmid, dend)
	print('%.10f' % result)
nl = list(map(int, input().strip().split()))
arr = list(map(int, input().strip().split()))
lattern(arr, nl[1])


def solve():
	(n, l) = map(int, input().split())
	lans = sorted([int(i) for i in input().split()])
	(left, right, diff) = (lans[0] - 0, l - lans[-1], 0)
	for i in range(1, len(lans)):
		curr = lans[i] - lans[i - 1]
		if curr > diff:
			diff = curr
	print(max(left, right, diff / 2))
solve()


(N, L) = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
max = A[0]
for i in range(0, N - 1):
	if max < (A[i + 1] - A[i]) / 2:
		max = (A[i + 1] - A[i]) / 2
if max < L - A[N - 1]:
	max = L - A[N - 1]
print(max)


nl = list(input().split(' '))
n = int(nl[0])
l = int(nl[1])
lamps = list(input().split(' '))
lamps = list(map(int, lamps))
lamps.sort()
longestDist = 0
for x in range(1, len(lamps)):
	longestDist = max(longestDist, lamps[x] - lamps[x - 1])
longestDist = max(longestDist / 2, lamps[0], l - lamps[len(lamps) - 1])
print(longestDist)


np = list(map(int, input().split()))
n = np[0]
p = np[1]
a = list(map(int, input().split()))
a.sort()
max1 = -1
for i in range(n - 1):
	if max1 < a[i + 1] - a[i]:
		max1 = a[i + 1] - a[i]
mx = max(a[0] - 0, p - a[-1])
max1 = max(mx, max1 / 2)
print(max1)


import sys
import os

def get_int():
	return map(int, input().split())

def get_array():
	return list(map(int, input().split()))

def str_replacer(old_str, new_str, index):
	if index in range(len(old_str)):
		return old_str[:index] + new_str + old_str[index + 1:]
	else:
		return old_str
if os.environ.get('DEBUGSTER_PYTHON'):
	sys.stdin = open('in.txt', 'r')
	sys.stdout = open('out.txt', 'w')
(n, l) = get_int()
pos = get_array()
mx = -1
pos.sort()
for i in range(1, n):
	mx = max(mx, pos[i] - pos[i - 1])
mx /= 2
if 0 not in pos:
	mx = max(mx, pos[0])
if l not in pos:
	mx = max(mx, l - pos[n - 1])
print(mx)


(n, l) = [int(x) for x in input().split()]
lanterns = [int(x) for x in input().split()]
lanterns.sort()
y = [lanterns[0], l - lanterns[-1]]
for i in range(0, n):
	y.append((lanterns[i] - lanterns[i - 1]) / 2)
m = max(y)
print(m)


(n, l) = input().split()
n = int(n)
l = int(l)
arr = [int(i) for i in input().split()]
arr.sort()
dif = arr[0]
for i in range(n - 1):
	if (arr[i + 1] - arr[i]) / 2 > dif:
		dif = (arr[i + 1] - arr[i]) / 2
if l - arr[-1] > dif:
	print(l - arr[-1])
else:
	print(dif)


list1 = [int(x) for x in input().split(' ')]
n = list1[0]
l = list1[1]
list2 = [int(x) for x in input().split(' ')]
list2.extend([0, l])
list2.sort()
t = 0
for i in range(n + 1):
	if i == 0 or i == n:
		t = max(t, list2[i + 1] - list2[i])
	else:
		t = max(t, (list2[i + 1] - list2[i]) / 2)
print(t)


(n, l) = [int(i) for i in input().split()]
a = sorted([int(i) for i in input().split()])
d = [(a[i + 1] - a[i]) / 2 for i in range(len(a) - 1)]
d.append(a[0])
d.append(l - a[-1])
print(max(d))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
st = a[0] - 0
end = abs(a[-1] - l)
pre = a[0]
maxi = -1
for i in range(1, n):
	le = a[i] - pre
	maxi = max(maxi, le)
	pre = a[i]
maxi = max(maxi / 2, st, end)
print('%.9f' % maxi)


(num_lamps, length) = map(int, input().split())
lamps = sorted(list(map(int, input().split())))
max_dist = 2 * (lamps[0] - 0)
for i in range(num_lamps - 1):
	dist = lamps[i + 1] - lamps[i]
	if dist > max_dist:
		max_dist = dist
dist = 2 * (length - lamps[-1])
if dist > max_dist:
	max_dist = dist
print(max_dist / 2)


(n, l) = map(int, input().split())
candles = list(map(int, input().split()))
bandles = sorted(candles)
(prothom, dwitiyo, shesh, kurukhkhetro) = (0, 0, 0, 0)
if bandles[0] != 0:
	prothom = bandles[0] - 0
if bandles[-1] != l:
	shesh = l - bandles[-1]
for i in range(n - 1):
	kurukhkhetro = bandles[i + 1] - bandles[i]
	if kurukhkhetro > dwitiyo:
		dwitiyo = kurukhkhetro
if dwitiyo / 2 > prothom and dwitiyo / 2 > shesh:
	print(dwitiyo / 2)
elif prothom > shesh and prothom > dwitiyo / 2:
	print(prothom)
else:
	print(shesh)


import sys
input = sys.stdin.readline

def main():
	nl = list(map(int, input().split()))
	n = nl[0]
	l = nl[1]
	lanterns = list(map(int, input().split()))
	lanterns.sort()
	i = 0
	lanterns = list(set(lanterns))
	llen = len(lanterns)
	if llen == 1:
		if lanterns[0] in [0, l]:
			l1 = [l, lanterns[0]]
			l1.sort()
			print(l1[1])
			return
		elif lanterns[0] - 1 > l - lanterns[0]:
			print(lanterns[0])
			return
		else:
			print(lanterns[0] + 1)
			return
	if l == 1:
		print(1)
		return
	lanterns.sort()
	max = lanterns[0]
	while i < llen - 1:
		if lanterns[i + 1] - lanterns[i] > max:
			max = lanterns[i + 1] - lanterns[i]
		i += 1
	if l != lanterns[llen - 1]:
		if l - lanterns[llen - 1] >= max / 2:
			print(l - lanterns[llen - 1])
			return
	if lanterns[0] != 0 and lanterns[1] >= max:
		print(lanterns[0])
		return
	print(max / 2)
main()


n = input()
m = input()
a = []
a = m.split(' ')
b = []
c = []
b = n.split(' ')
q = int(b[0])
w = int(b[1])
for i in range(q):
	a[i] = int(a[i])
a.sort()
for j in range(q - 1):
	c.append(int(a[j + 1] - a[j]))
c.append(a[0] * 2)
e = (w - a[q - 1]) * 2
c.append(e)
print(max(c) / 2)


(n, l) = map(int, input().split())
T = list(map(int, input().split()))
dif = 0
T.sort()
if 0 not in T:
	dif = T[0]
if l not in T:
	dif = max(l - T[len(T) - 1], dif)
for i in range(n - 1):
	dif = max(dif, (T[i + 1] - T[i]) / 2)
print(dif)


a = list(map(int, input().split()))
b = sorted(list(map(int, input().split())))
c = max([b[0], a[1] - b[a[0] - 1]] + [(b - a) / 2 for (a, b) in zip(b, b[1:])])
print(c)


o = input().rstrip().split(' ')
p = input().rstrip().split(' ')
p.sort(key=int)
maxi = -10000000000000
if len(p) == 1:
	A = int(p[0]) - 0
	B = int(o[1]) - int(p[0])
	print(max(A, B))
else:
	for i in range(0, len(p)):
		if i == 0:
			maxi = max(int(p[i]), maxi)
		elif i == len(p) - 1:
			maxi = max(maxi, int(o[1]) - int(p[i]))
			maxi = max(maxi, (int(p[i]) - int(p[i - 1])) / 2)
		else:
			maxi = max(maxi, (int(p[i]) - int(p[i - 1])) / 2)
	print(maxi)


(n, l) = map(int, input().split())
list1 = sorted(list(map(int, input().split())))
list2 = []
for m in range(0, n - 1):
	k = list1[m + 1] - list1[m]
	list2.append(k / 2)
list2.append(list1[0])
list2.append(l - list1[-1])
print(max(list2))


(n, l) = list(map(int, input().split()))
b = list(map(int, input().split()))
b.sort()
a = []
for i in b:
	if i not in a:
		a.append(i)
d = 0
for i in range(0, len(a) - 1):
	if a[i + 1] - a[i] > d:
		d = a[i + 1] - a[i]
d = d / 2
if a[0] != 0:
	if a[0] > d:
		d = a[0]
if a[-1] != l:
	if l - a[-1] > d:
		d = l - a[-1]
print('%.10f' % d)


(n, l) = map(int, input().split())
ls = sorted(list(map(int, input().split())))
start = abs(ls[0] - 0)
end = abs(ls[-1] - l)
mid = 0
for i in range(len(ls) - 1):
	tmp = abs(ls[i] - ls[i + 1])
	mid = max(mid, tmp)
print(max(start, end, mid / 2))


(n, l) = map(int, input().split())
lantern = sorted(map(int, input().split()))
spacing = []
if len(lantern) > 1:
	for i in range(len(lantern) - 1):
		spacing.append(lantern[i + 1] - lantern[i])
	if lantern[0] - max(spacing) / 2 <= 0 and lantern[-1] + max(spacing) / 2 >= l:
		print(max(spacing) / 2)
	else:
		print(max(lantern[0], l - lantern[-1]))
else:
	print(max(lantern[0], l - lantern[0]))


(n, length) = map(int, input().split())
lanterns = list(map(int, input().split()))
lanterns = sorted(lanterns)

def get_widest_lanterns(lanterns):
	widest = 0
	last_lantern_pos = -1
	for lantern_pos in lanterns:
		if last_lantern_pos == -1:
			last_lantern_pos = lantern_pos
			continue
		wide = lantern_pos - last_lantern_pos
		widest = max(widest, wide)
		last_lantern_pos = lantern_pos
	return widest / 2
wide_from_start = lanterns[0]
wide_from_end = length - lanterns[len(lanterns) - 1]
widest = max(get_widest_lanterns(lanterns), wide_from_start, wide_from_end)
print(widest)


def main():
	(n, l) = [int(i) for i in input().split(' ')]
	_ = [int(i) for i in input().split(' ')]
	_.sort()
	if _[0] != 0:
		d = _[0]
	else:
		d = 0
	for i in range(1, n):
		dif = _[i] - _[i - 1]
		if dif / 2 > d:
			d = dif / 2
	if _[-1] != l:
		dif = l - _[-1]
		if dif > d:
			d = dif
	print(d)
main()


(n, l) = map(int, input().split())
lA = list(map(int, input().split()))
lA.sort()
s1 = lA[0]
s2 = l - lA[-1]
lB = []
for i in range(1, len(lA)):
	s3 = lA[i] - lA[i - 1]
	lB.append(s3)
if lB == []:
	lB.append(0)
s = max(lB) / 2
lC = [s1, s2, s]
print('%.10f' % max(lC))


(n, l) = map(int, input().split())
lan = sorted(list(map(int, input().split())))
arr = [lan[i + 1] - lan[i] for i in range(n - 1)]
if arr:
	print(max(lan[0], max(arr) / 2, l - lan[n - 1]))
else:
	print(max(lan[0], l - lan[n - 1]))


def merge(C, l, s, r):
	A = C[l:s + 1].copy()
	A.append(10 ** 10)
	B = C[s + 1:r + 1].copy()
	B.append(10 ** 10)
	j = 0
	k = 0
	for i in range(l, r + 1):
		if A[j] >= B[k]:
			C[i] = B[k]
			k += 1
		else:
			C[i] = A[j]
			j += 1

def sort_merge(C, l, r):
	if l == r:
		return
	else:
		s = (r + l) // 2
		sort_merge(C, l, s)
		sort_merge(C, s + 1, r)
		merge(C, l, s, r)
(n, l) = list(map(int, input().split(' ')))
C = list(map(int, input().split(' ')))
sort_merge(C, 0, n - 1)
D = [2 * C[0], 2 * (l - C[-1])]
for i in range(len(C) - 1):
	D.append(C[i + 1] - C[i])
sort_merge(D, 0, n)
print(D[-1] / 2)


(a, b) = map(int, input().split())
l = list(map(int, input().split()))
l.sort(reverse=True)
l1 = []
for i in range(a - 1):
	l1.append((l[i] - l[i + 1]) / 2)
v = l.count(0)
mi = 0
mm = 0
if v == 0:
	mi = min(l) - 0
v1 = l.count(b)
if v1 == 0:
	mm = b - max(l)
if l1 != []:
	print('%.10f' % max(mi, mm, max(l1)))
else:
	print('%.10f' % max(mi, mm))


from sys import stdin, stdout
(n, l) = map(int, stdin.readline().split())
arr = list(map(int, stdin.readline().split()))
arr.sort()
if arr[0] != 0:
	m = max(arr[0], l - arr[-1])
else:
	m = l - arr[-1]
for i in range(len(arr) - 1):
	m = max(m, (arr[i + 1] - arr[i]) / 2)
print('{:.10f}'.format(m))


(m, n) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
max_dist = max(a[0], n - a[-1])
for x in range(len(a) - 1):
	max_dist = (a[x + 1] - a[x]) / 2 if (a[x + 1] - a[x]) / 2 > max_dist else max_dist
print(max_dist)


(n, l) = [int(x) for x in input().split()]
ls = sorted([int(x) for x in input().split()])
ls1 = []
if len(ls) != 1:
	for i in range(len(ls) - 1):
		ls1.append(ls[i + 1] - ls[i])
else:
	ls1 = ls
radius = max(ls1) / 2
print('%.10f' % max(radius, max(ls[0] - 0, l - ls[n - 1])))


I = lambda : map(int, input().split())
(n, l) = I()
x = sorted(I())
d = max(x[0], l - x[-1])
if n > 1:
	d = max(max([p[0] - p[1] for p in zip(x[1:], x[:-1])]) / 2, d)
print(d)


s = list(map(int, input().split()))
s1 = list(map(int, input().split()))
s1.sort()
m = 0
if s1[0] != 0:
	m = s1[0] - 0
for i in range(len(s1) - 1):
	m = max(m, (s1[i + 1] - s1[i]) / 2.0)
if s1[-1] != s[1]:
	m = max(s[1] - s1[-1], m)
print('%.7f' % m)


arr1 = str(input())
arr = arr1.split()
n = int(arr[0])
l = int(arr[1])
dist1 = str(input())
dist1 = dist1.split()
dist = []

def check(light, dist, total):
	low = 0
	for i in dist:
		first = i - light
		if first > low:
			return False
		low = i + light
	if low >= total:
		return True
	return False
for i in dist1:
	dist.append(int(i))
dist = sorted(dist)
low = 0
high = int(pow(10, 10))
ans = high
while low <= high:
	mid = (low + high) / 2
	if not check(mid, dist, l):
		low = mid + 0.005
	else:
		ans = mid
		high = mid - 0.005
import math
ceil = math.ceil(ans)
floor = math.floor(ans)
half = floor + 0.5
ceil1 = abs(ceil - ans)
floor1 = abs(floor - ans)
half1 = abs(half - ans)
if ceil1 < floor1 and ceil1 < half1:
	print(ceil)
elif floor1 < ceil1 and floor1 < half1:
	print(floor)
else:
	print(half)


lineL = 0
(points, lineR) = map(int, input().split())
pointX = map(int, input().split())
pointX = sorted(pointX)
leftSpace = pointX[0]
rightSpace = lineR - pointX[-1]
answer = max([(pointX[i + 1] - pointX[i]) / 2 for i in range(points - 1)] + [leftSpace, rightSpace])
print(answer)


(n, l) = map(int, input().split())
location = input().split()
for i in range(n):
	location[i] = int(location[i])
location.sort()
distance = []
for i in range(n - 1):
	distance.append((location[i + 1] - location[i]) / 2)
distance.append(location[0] - 0)
distance.append(l - location[-1])
d = max(distance)
print('%.10f' % d)


p = input().split()
a = int(p[0])
l = int(p[1])
L = []
q = input().split()
i = 0
while i < a:
	L.append(int(q[i]))
	i = i + 1
L.sort()
m = -10
i = 1
while i < a:
	if L[i] - L[i - 1] > m:
		m = L[i] - L[i - 1]
	i = i + 1
x = max(m / 2, l - L[a - 1], L[0] - 0)
print('%.10f' % x)


l1 = [int(i) for i in input().split()]
m = l1[0]
n = l1[1]
l = [int(i) for i in input().split()]
c = 0
d = 0
l.sort()
for i in range(m - 1):
	c = abs(l[i + 1] - l[i]) / 2
	if d < c:
		d = c
o = l[0]
p = n - l[m - 1]
print(max(o, p, d))


from sys import stdin, stdout
(n, l) = map(int, stdin.readline().split())
a = list(map(int, stdin.readline().split()))
a.sort()
d = max(a[0], l - a[-1])
for i in range(1, n):
	d = max(d, 0.5 * (a[i] - a[i - 1]))
stdout.write(str(d))


def bubble(table):
	e = len(table)
	for i in range(e - 1):
		for j in range(i + 1, e):
			if int(table[i]) >= int(table[j]):
				(table[i], table[j]) = (table[j], table[i])
	return table
(n, l) = input().split()
a = input().split()
c = len(a)
b = bubble(a)
d = []
for i in range(c):
	f = (int(b[i]) - int(b[i - 1])) / 2
	d.append(f)
if 0 not in b:
	f = int(b[0])
	d.append(f)
if str(l) not in b:
	f = int(l) - int(b[-1])
	d.append(f)
print(float(max(d)))


first = input().split()
n = first[0]
l = int(first[1])
second = input().split()
for i in range(len(second)):
	second[i] = int(second[i])
second.sort()
maximum = 0
for i in range(len(second) - 1):
	current = second[i + 1] - second[i]
	if current > maximum:
		maximum = current
maximum /= 2
if not 0 in second:
	current = second[0]
	if current > maximum:
		maximum = current
if not l in second:
	current = l - second[len(second) - 1]
	if current > maximum:
		maximum = current
print('{:.10f}'.format(maximum))


(a, b) = input().split()
(a, b) = (int(a), int(b))
lst = [int(i) for i in input().split()]
lst.sort()
lst1 = [lst[0] - 0, b - lst[-1]]
for j in range(1, a):
	lst1.append((lst[j] - lst[j - 1]) / 2)
lst1.sort()
print(lst1[-1])


(n, l) = map(int, input().split())
a = []
a = input().split()
for i in range(n):
	a[i] = int(a[i])
a.sort()
d1 = a[0]
d2 = l - a[n - 1]
d = 0
tmp = 0
for i in range(1, n):
	tmp = (a[i] - a[i - 1]) / 2
	if tmp > d:
		d = tmp
if d1 > d:
	d = d1
if d2 > d:
	d = d2
print(d)


(n, l) = map(int, input().split())
lamps = list((int(i) for i in input().split()))
lamps.sort()
diff = max(lamps[0], l - lamps[n - 1]) * 2
if lamps[0] != 0:
	lamps = [0] + lamps
if lamps[n - 1] != l:
	lapms = lamps + [l]
for i in range(len(lamps) - 1):
	diff = max(diff, lamps[i + 1] - lamps[i])
print(diff / 2)


(count, length) = map(int, input().split())
position = list(map(int, input().split()))
position.sort()
answer = max(position[0], length - position[len(position) - 1])
start = 0
for pos in position:
	distance = (pos - start) / 2
	answer = max(distance, answer)
	start = pos
print('{0:.10f}'.format(answer))


(n, l) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort()
dif_start = a[0]
dif_end = l - a[-1]
max_dif = 0
for i in range(1, n - 1):
	if a[i] - a[i - 1] > max_dif:
		max_dif = a[i] - a[i - 1]
	if a[i + 1] - a[i] > max_dif:
		max_dif = a[i + 1] - a[i]
ans = max_dif / 2
if n == 2 and dif_start == 0 and (dif_end == 0):
	print((a[1] - a[0]) / 2)
elif dif_start > ans or dif_end > ans:
	print(max(dif_start, dif_end))
else:
	print(ans)


(n, l) = [int(i) for i in input('').split(' ')]
a = [int(i) for i in input('').split(' ')]
a.sort()
maxdiff = 0
for i in range(len(a) - 1):
	maxdiff = max(maxdiff, a[i + 1] - a[i])
radius = max(maxdiff / 2, a[0] - 0, l - a[n - 1])
print(radius)


(m, n) = [int(x) for x in input().split()]
l = list(map(int, input().split()))
s = -99999999999
l.sort()
for i in range(m):
	if i == m - 1:
		break
	s = max(s, (l[i + 1] - l[i]) / 2)
	pass
if s < min(l):
	r = min(l) - s
	s += r
if n - s > max(l):
	r = n - max(l) - s
	s += r
print('%.9f' % s)


(n, k) = map(int, input().split())
aa = list(map(int, input().split()))
aa.sort()
cc = 0
for i in range(n - 1):
	cc = max(cc, (aa[i + 1] - aa[i]) / 2)
print(max(aa[0], cc, k - aa[-1]))


(n, l) = map(int, input().split())
a = input()
a = a.split()
for i in range(0, len(a)):
	a[i] = int(a[i])
a = sorted(a)
max1 = 0
for i in range(0, len(a) - 1):
	if a[i + 1] - a[i] > max1:
		max1 = a[i + 1] - a[i]
m = max1 / 2
if 0 not in a and min(a) > m:
	m = min(a)
if l not in a and l - max(a) > m:
	m = l - max(a)
print(m)


(n, l) = [int(x) for x in input().strip().split()]
a = [int(x) for x in input().strip().split()]
a.sort()
maxi = a[0]
for i in range(1, len(a)):
	if abs(a[i] - a[i - 1]) / 2 > maxi:
		maxi = abs(a[i] - a[i - 1]) / 2
if l - a[len(a) - 1] > maxi:
	maxi = l - a[len(a) - 1]
print(maxi)


def to_list(s):
	return list(map(lambda x: int(x), s.split(' ')))

def solve(a, l):
	a = sorted(a)
	min_ = a[0]
	for i in range(1, len(a)):
		if (a[i] - a[i - 1]) / 2 > min_:
			min_ = (a[i] - a[i - 1]) / 2
	if l - a[-1] > min_:
		min_ = l - a[-1]
	return min_
(n, l) = to_list(input())
a = to_list(input())
print(solve(a, l))


(n, l) = (int(i) for i in input().split())
v = [int(i) for i in input().split()]
v.sort()
maxim = 0
for i in range(0, len(v) - 1):
	j = i + 1
	if v[j] - v[i] > maxim:
		maxim = v[j] - v[i]
maxim = maxim / 2
if v[0] > maxim:
	maxim = v[0]
if l - v[n - 1] > maxim:
	maxim = l - v[n - 1]
print(maxim)


(n, k) = map(int, input().split())
a = set(map(int, input().split()))
a = sorted(a)
b = []
for i in range(1, len(a)):
	b.append((a[i] - a[i - 1]) / 2)
try:
	mx = max(b)
except:
	mx = 0
print(max(mx, a[0], k - a[-1]))


len_street = int(input().split(' ')[1])
lights = list(map(int, input().split(' ')))
lights.sort()
max_gap = 0
for i in range(1, len(lights)):
	gap = abs(lights[i] - lights[i - 1])
	if gap > max_gap:
		max_gap = gap
if 0 not in lights or len_street not in lights:
	print(max(max_gap / 2, min(lights), abs(max(lights) - len_street)))
else:
	print(max_gap / 2)


(n, l) = [int(x) for x in input().split()]
L = [int(x) for x in input().split()]
L = sorted(L)
p = L[0]
q = l - L[-1]
t = max(p, q)
num = 0
if n == 1:
	d = max(l - L[0], L[0])
else:
	for i in range(len(L) - 1):
		num = max(0.5 * (L[i + 1] - L[i]), t, num)
	d = num
print('%.10f' % d)


(n, mx) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort()
diff = max(a[0], mx - a[-1])
for i in range(0, len(a) - 1):
	diff = max(diff, (a[i + 1] - a[i]) / 2)
print(diff)


(n, le) = map(int, input().split())
a = [int(i) for i in input().split()]
a.sort()
mi = 0.0
ma = float(le)
j = 0
while j < 100 and mi != ma:
	d = (mi + ma) / 2
	s = False
	if a[0] - d > 0:
		s = True
	else:
		for i in range(1, len(a)):
			if a[i] - d > a[i - 1] + d:
				s = True
				break
		if a[-1] + d < le:
			s = True
	di = ma - mi
	if s:
		mi += di / 2
	else:
		ma -= di / 2
	j += 1
print('{0:.9f}'.format(round((mi + ma) / 2, 9)))


nl = input('')
a = input('')
a_list = a.split(' ')
for i in range(len(a_list)):
	a_list[i] = int(a_list[i])
l = nl.split(' ')
l = int(l[1])
max = 0
a_list.sort()
for i in range(len(a_list) - 1):
	if a_list[i + 1] - a_list[i] > max:
		max = a_list[i + 1] - a_list[i]
max /= 2
if a_list[0] > max:
	max = a_list[0]
if l - a_list[len(a_list) - 1] > max:
	max = l - a_list[len(a_list) - 1]
print(max)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
d = []
a.sort()
d.append(float(a[0] - 0))
d.append(float(m - a[-1]))
for i in range(len(a)):
	if i != len(a) - 1:
		d.append((a[i + 1] - a[i]) / 2)
print(str(max(d)) + '000000000')


(a, b) = map(int, input().split())
doroga = [0] + list(map(int, input().split())) + [b]
doroga.sort()
max2 = max1 = 0
if a == 1:
	if doroga[1] == 0 or doroga[1] == b:
		max2 = b
if doroga[1] != 0 or doroga[a + 1] != b:
	if doroga[1] - doroga[0] > doroga[a + 1] - doroga[a]:
		max1 = doroga[1] - doroga[0]
	else:
		max1 = doroga[a + 1] - doroga[a]
for i in range(a + 1):
	if (doroga[i + 1] - doroga[i]) / 2 > max2:
		max2 = (doroga[i + 1] - doroga[i]) / 2
print(max(max1, max2))


(n, m) = list(map(int, input().split()))
l = sorted(list(map(int, input().split())))
wtf = max(l[0] * 2, (m - l[n - 1]) * 2)
for i in range(1, n):
	wtf = max(wtf, l[i] - l[i - 1])
print(wtf / 2)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
dist = a[0] - 0
if l - a[n - 1] > dist:
	dist = l - a[n - 1]
for i in range(n - 1):
	b = (a[i + 1] - a[i]) / 2
	if b > dist:
		dist = b
print(round(dist, 10))


from sys import stdin
import math
(n, l) = map(int, stdin.readline().rstrip().split(' '))
nums = list(map(int, stdin.readline().rstrip().split(' ')))
nums.sort()
ma = -math.inf
for i in range(len(nums) - 1):
	ma = max(nums[i + 1] - nums[i], ma)
print(max(nums[0], l - nums[-1], ma / 2))


def street_lamps(narr, l):
	narr.sort()
	d = 0
	for i in range(len(narr) - 1):
		cand = candidate(narr[i], narr[i + 1])
		if d < cand:
			d = cand
	d = check_ends(narr, d, l)
	return d

def candidate(a1, a2):
	return (a2 - a1) / 2

def check_ends(narr, d, l):
	if 0 not in narr:
		if d < narr[0]:
			d = narr[0]
	if l not in narr:
		if d < l - narr[-1]:
			d = l - narr[-1]
	return d
(_, l) = map(int, input().split())
narr = list(map(int, input().split()))
print(street_lamps(narr, l))


(x, y) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
b = []
if 0 not in a:
	b.append((a[0] - 0) / 1)
if y not in a:
	b.append(y - a[x - 1] / 1)
for i in range(1, x):
	b.append((a[i] - a[i - 1]) / 2)
print('%.10f' % max(b))


import sys
import math
(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
max = -1
for i in range(len(a) - 1):
	if a[i + 1] - a[i] > max:
		max = a[i + 1] - a[i]
ans = max / 2
if a[0] != 0:
	if a[0] > ans:
		ans = a[0]
if a[len(a) - 1] != l:
	if l - a[len(a) - 1] > ans:
		ans = l - a[len(a) - 1]
print(ans)


(m, k) = (list(map(int, input().split())), list(map(int, input().split())))
(n, l) = (m[0], m[1])
k.sort()
res = 0
lasti = -k[0]
for i in k:
	if i - lasti > res:
		res = i - lasti
	lasti = i
if 2 * (l - k[-1]) > res:
	res = 2 * (l - k[-1])
print(res / 2)


(n, l) = map(int, input().split())
list_x = list(map(int, input().split()))
a1 = min(list_x)
a2 = l - max(list_x)
maxx = 0
list_x.sort()
if n == 1:
	print(max(list_x[0], l - list_x[0]))
else:
	for i in range(n - 1):
		tmp = (list_x[i + 1] - list_x[i]) / 2
		maxx = max(maxx, a1, a2, tmp)
	print(float(maxx))


line = input().split()
(n, l) = (int(line[0]), int(line[1]))
arr = sorted([int(x) for x in input().split()], key=int)
(d, r) = (0, arr[0])
for i in arr:
	r = max(r, (i - d) / 2)
	d = i
r = max(r, l - arr[-1])
print(r)


(n, l) = map(int, input().split())
(a, x, r, q) = (list(map(int, input().split())), 0, 0, 0)
a.sort()
if 0 not in a:
	r = a[0]
if l not in a:
	q = l - max(a)
for i in range(len(a) - 1):
	x = max(x, a[i + 1] - a[i])
print(max(q, r, x / 2))


(n, l) = input().split()
lamp_coordinates = input().split()
lamp_coordinates = sorted([int(x) for x in lamp_coordinates])
max_distance = 0
for i in range(1, len(lamp_coordinates)):
	if lamp_coordinates[i] - lamp_coordinates[i - 1] > max_distance:
		max_distance = lamp_coordinates[i] - lamp_coordinates[i - 1]
if int(l) - lamp_coordinates[len(lamp_coordinates) - 1] > max_distance:
	max_distance = int(l) - lamp_coordinates[len(lamp_coordinates) - 1]
if max_distance / 2 > lamp_coordinates[0] - 0 and max_distance / 2 > int(l) - lamp_coordinates[len(lamp_coordinates) - 1]:
	print(float(max_distance / 2))
else:
	print(float(max(lamp_coordinates[0] - 0, int(l) - lamp_coordinates[len(lamp_coordinates) - 1])))


(n, l) = input('').split()
n = int(n)
l = int(l)
a = list(map(int, input('').strip().split()))[:n]
a.sort()
max_index = -1
max = 0
for i in range(n - 1):
	diff = abs(a[i + 1] - a[i])
	if diff > max:
		max = diff
		max_index = i
start = a[0] - 0
end = l - a[n - 1]
if start >= end and start >= max / 2:
	print('{:.10f}'.format(start))
elif end >= start and end >= max / 2:
	print('{:.10f}'.format(end))
else:
	print('{:.10f}'.format(max / 2))


(n, l) = list(map(int, input().split()))
lst = list(map(int, input().split()))
lst.sort()
f = lst[0]
s = l - lst[-1]
interval = max(f, s)
for i in range(1, n):
	if (lst[i] - lst[i - 1]) / 2 > interval:
		interval = (lst[i] - lst[i - 1]) / 2
print(interval)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
mx = 0
arr = sorted(arr)
for i in range(len(arr)):
	if i + 1 < len(arr):
		mx = max(abs(arr[i] - arr[i + 1]) / 2, mx)
if 0 not in arr:
	mx = max(abs(arr[0]), mx)
if l not in arr:
	mx = max(abs(arr[-1] - l), mx)
print(mx)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
if n != 1:
	a.sort()
	s = [(a[i] - a[i - 1]) / 2 for i in range(1, n)]
	ma = max(s)
else:
	ma = max(a)
p = a[0]
o = l - a[-1]
print('%.9f' % max(ma, p, o))


user_input1 = input()
user_input2 = input()
numberArray = []
user_input1 = user_input1.split(' ')
user_input2 = user_input2.split(' ')
for element in user_input2:
	numberArray.append(int(element))
numberArray.sort()
string = ''
ansArray = []
start_distance = abs(numberArray[0] - 0)
end_distance = abs(numberArray[len(numberArray) - 1] - int(user_input1[1]))
ansArray.append(start_distance)
ansArray.append(end_distance)
max_dist = numberArray[0]
for i in range(len(numberArray) - 1):
	current = numberArray[i]
	next = numberArray[i + 1]
	current_distance = abs(current - next)
	if current_distance > max_dist:
		max_dist = current_distance
ansArray.append(max_dist / 2)
ans = max(ansArray)
print(str.format('{0:.9f}', ans))


(n, l) = map(int, input().split())
list_of_n = sorted(list(map(int, input().split())))
max_diff = 0
for i in range(n - 1):
	if list_of_n[i + 1] - list_of_n[i] > max_diff:
		max_diff = list_of_n[i + 1] - list_of_n[i]
max_diff = max_diff / 2
if list_of_n[0] != 0 and list_of_n[0] > max_diff / 2:
	max_diff = list_of_n[0]
if l - list_of_n[-1] > max_diff:
	max_diff = l - list_of_n[-1]
print('{:.10f}'.format(max_diff))


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		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 math

def fact(x):
	if x == 0:
		return 1
	else:
		return x * fact(x - 1)

def isqrt(n):
	x = n
	y = (x + 1) // 2
	while y < x:
		x = y
		y = (x + n // x) // 2
	return x

def abs(x):
	return x if x >= 0 else -x
for t in range(1):
	(n, l) = list(map(int, input().split()))
	lamps = list(map(int, input().split()))
	lamps.sort()
	diff = -1
	for i in range(n - 1):
		diff1 = abs(lamps[i] - lamps[i + 1])
		diff = max(diff, diff1)
	ans = max(diff / 2, lamps[0] - 0, l - lamps[-1])
	print('%.10f' % ans)


(_, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
d = max((a[i + 1] - a[i] for i in range(len(a) - 1))) / 2 if len(a) > 1 else l / 2
d = max(d, a[0], l - a[-1])
print(d)


(n, l) = input().split()
n = int(n)
l = int(l)
lights = input().split()
initial = True
final = True
for i in range(n):
	lights[i] = int(lights[i])
ordered = []
for i in range(n):
	a = min(lights)
	ordered.append(a)
	lights.remove(a)
radius = -1
for i in range(n + 1):
	if i == 0:
		ray = ordered[i]
	elif i == n:
		ray = l - ordered[n - 1]
	else:
		ray = (ordered[i] - ordered[i - 1]) / 2
	if ray > radius:
		radius = ray
print(radius)


n_l = input()
ai = input()
n_l = n_l.split()
ai = ai.split()
for i in range(2):
	n_l[i] = int(n_l[i])
for i in range(n_l[0]):
	ai[i] = int(ai[i])
ai.sort()
max = -1
for i in range(n_l[0] - 1):
	if ai[i + 1] - ai[i] > max:
		max = ai[i + 1] - ai[i]
max = max / 2
if ai[0] > max:
	max = ai[0]
if n_l[1] - ai[n_l[0] - 1] > max:
	max = n_l[1] - ai[n_l[0] - 1]
print(max)


nl = input().split(' ')
(n, l) = (int(nl[0]), int(nl[1]))
a = list(set(list(map(int, input().split(' ')))))
a.sort()
dis = list()
for i in range(len(a) - 1):
	dis.append((a[i + 1] - a[i]) / 2)
dis.append(a[0])
dis.append(l - a[len(a) - 1])
print(max(dis))


(numboflights, streetlength) = (int(i) for i in input().split())
dictlights = {float(i) for i in input().split()}
spisoklights = []
for i in dictlights:
	spisoklights.append(i)
spisoklights.sort()
minznach = 0
for i in range(len(spisoklights) - 1):
	tekuschznach = (spisoklights[i + 1] - spisoklights[i]) / 2
	if tekuschznach > minznach:
		minznach = tekuschznach
if 0 not in spisoklights:
	tekuschznach = spisoklights[0] - 0
	if tekuschznach > minznach:
		minznach = tekuschznach
if streetlength not in spisoklights:
	tekuschznach = streetlength - spisoklights[len(spisoklights) - 1]
	if tekuschznach > minznach:
		minznach = tekuschznach
print(minznach)


(n, d) = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
arr.sort()
ans = 0
for i in range(1, n):
	diff = arr[i] - arr[i - 1]
	ans = max(ans, diff / 2)
ans = max(ans, arr[0], d - arr[-1])
print(ans)


import math
(n, l) = map(int, input().split())
li = list(map(int, input().split()))
li.sort()
r = li[0]
for i in range(len(li) - 1):
	rad = abs((li[i] - li[i + 1]) / 2)
	r = max(r, rad)
r = max(r, l - li[-1])
print(r)


(n, l) = [int(_) for _ in input().split()]
a = [int(_) for _ in input().split()]
a = list(set(a))
a.sort()
ans = max(a[0], l - a[-1])
for i in range(1, len(a)):
	ans = max(ans, (a[i] - a[i - 1]) * 0.5)
print(ans)


line = input().split(' ')
n = int(line[0])
l = int(line[1])
line = input().split(' ')
lst = []
for item in line:
	lst.append(int(item))
lst.sort()
maxdiff = max(l - lst[n - 1], lst[0]) * 2
for i in range(n - 1):
	diff = lst[i + 1] - lst[i]
	if diff > maxdiff:
		maxdiff = diff
print(str(maxdiff / 2.0))


(n, l) = [int(k) for k in input().split()]
num = [int(k) for k in input().split()]
num.sort()
length = len(num)
m = 0
if length > 1:
	diff = [0] * (length - 1)
	for i in range(length - 1):
		diff[i] = num[i + 1] - num[i]
	diff.sort()
	m = diff[length - 2] / 2.0
left = num[0]
r = l - num[length - 1]
print(max(m, left, r))


inp = lambda : map(int, input().split(' '))
(n, l) = inp()
a = list(inp())
a.sort()
d = [(a[i] - a[i - 1]) / 2 for i in range(1, len(a))]
d1 = l - a[n - 1]
d.append(0)
d2 = max(d)
ans = max(d2, d1, a[0])
print('%.10f' % ans)


(n, l) = map(int, input().split())
c = sorted(map(int, input().split()))
cmin = max(c[0], l - c[-1])
for i in range(n - 1):
	t = (c[i + 1] - c[i]) / 2
	if t > cmin:
		cmin = t
print(cmin)


a = list(map(int, input().strip().split(' ')))
b = list(map(int, input().strip().split(' ')))
b = sorted(b)
diff = 0
for i in b[:-1]:
	x = b[b.index(i) + 1]
	if x - i > diff:
		diff = x - i
y = float(diff) / 2
if b[0] - 0 >= y and b[0] - 0 >= a[1] - b[a[0] - 1]:
	d = float(b[0]) / 1
elif a[1] - b[a[0] - 1] >= y and a[1] - b[a[0] - 1] > b[0] - 0:
	d = float(a[1] - b[a[0] - 1]) / 1
else:
	d = float(y) / 1
print('%.9f' % d)


def main():
	(nim, lens) = map(int, input().split())
	if nim <= 1:
		v = int(input())
		print(max(lens - v, v - 0))
	else:
		arr = list(map(int, input().split()))
		arr.sort()
		maxi = 0
		maxd = 0
		if 0 not in arr:
			maxi = arr[0] - 0
		if lens not in arr:
			maxd = lens - arr[nim - 1]
		line_ovr = max(maxi, maxd)
		quart_ovr = arr[1] - arr[0]
		result = line_ovr
		for i in range(nim - 1):
			div_ovr = abs(arr[i] - arr[i + 1])
			if div_ovr > quart_ovr:
				quart_ovr = div_ovr
		quart_ovr = quart_ovr / 2
		if line_ovr < quart_ovr:
			result = quart_ovr
		print(result)
main()


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
gd = max(a[0], l - a[n - 1]) * 2
for i in range(1, n):
	gd = max(gd, a[i] - a[i - 1])
print('{:.9f}'.format(gd / 2))


line = input()
line = line.split()
n = int(line[0])
l = int(line[1])
lst = input()
lst = lst.split()
for i in range(0, n):
	lst[i] = int(lst[i])
lst.sort()
dist1 = lst[0]
dist2 = l - lst[n - 1]
if dist1 >= dist2:
	maxdist = dist1 * 2
else:
	maxdist = dist2 * 2
for i in range(0, n - 1):
	dist = lst[i + 1] - lst[i]
	if dist > maxdist:
		maxdist = dist
maxdist = float(maxdist / 2)
print(maxdist)


(n, d) = map(lambda x: int(x), input().split(' '))
flashlights = list(map(lambda x: int(x), input().split(' ')))
flashlights.sort()
min_distance = 0
for i in range(len(flashlights) - 1):
	if flashlights[i + 1] - flashlights[i] > min_distance:
		min_distance = flashlights[i + 1] - flashlights[i]
print(max(max(flashlights[0], d - flashlights[-1]), min_distance / 2))


(n, t) = map(int, input().split())
l = [int(x) for x in input().split()]
l.sort()
maxx = float(max(l[0], t - l[n - 1]))
for i in range(1, n):
	if (l[i] - l[i - 1]) / 2 > maxx:
		maxx = float((l[i] - l[i - 1]) / 2)
print(maxx)


string1 = input('')
i = 0
for char in string1:
	if char == ' ':
		n = int(string1[0:i])
		l = int(string1[i + 1:len(string1)])
	i = i + 1
a = [0 for x in range(n)]
a_index = 0
string2 = input('')
string_index = 0
num_index = 0
for char in string2:
	if char == ' ':
		a[a_index] = int(string2[num_index:string_index])
		a_index = a_index + 1
		num_index = string_index + 1
	string_index = string_index + 1
a[a_index] = int(string2[num_index:string_index])
a.sort()
start_dist = a[0]
end_dist = l - a[n - 1]
max = 0
for i in range(n - 1):
	if a[i + 1] - a[i] > max:
		max = a[i + 1] - a[i]
if max / 2 > start_dist:
	if max / 2 > end_dist:
		print(max / 2)
	else:
		print(end_dist)
elif start_dist > end_dist:
	print(start_dist)
elif max / 2 > end_dist:
	print(max / 2)
else:
	print(end_dist)


def sol(a, n, l):
	a.sort()
	ans = max(a[0], l - a[-1])
	for i in range(1, n):
		ans = max(ans, (a[i] - a[i - 1]) / 2)
	return ans
(n, l) = map(int, input().split())
a = [int(i) for i in input().split()]
print(sol(a, n, l))


n = [int(i) for i in input().split(' ')]
L = n[1]
n = n[0]
a = [int(i) for i in input().split(' ')]
distances = []
a.sort()
for i in range(1, len(a)):
	distance = abs(a[i] - a[i - 1]) / 2
	distances.append(distance)
if 0 in a and L not in a:
	distances.append(L - a[-1])
elif L in a and 0 not in a:
	distances.append(a[0])
elif L and 0 not in a:
	distances.append(L - a[-1])
	distances.append(a[0])
print(max(distances))


import sys

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

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def input():
	return sys.stdin.readline().strip()
(n, l) = get_ints()
arr = get_array()
arr.sort()
m = -1
p = []
for i in range(0, n - 1):
	m = arr[i + 1] - arr[i]
	p.append(m / 2)
p.append(arr[0])
p.append(l - arr[n - 1])
print(max(p))


import sys
l1 = sys.stdin.readline().split()
l1 = [int(i) for i in l1]
lanterns = sys.stdin.readline().split()
lanterns = [int(i) for i in lanterns]
lanterns.sort()
m1 = lanterns[0]
m2 = l1[1] - lanterns[l1[0] - 1]
m3 = 0
prev = 0
for i in range(1, len(lanterns)):
	if lanterns[i] - lanterns[i - 1] > m3:
		m3 = lanterns[i] - lanterns[i - 1]
m3 = m3 / 2
print(max(m1, m2, m3))


(n, l) = map(int, input().split())
a = list(map(float, input().strip().split()))
a.sort()
d = max(a[0], l - a[-1])
for i in range(1, n):
	d = max(d, (a[i] - a[i - 1]) / 2)
print(d)


(n, m) = map(int, input().split())
L = list(map(int, input().split()))
L.sort()
ans = max(L[0], m - L[n - 1])
for i in range(n):
	ans = max(ans, (L[i] - L[i - 1]) / 2)
print('%.10lf' % ans)


(n, l) = [int(x) for x in input().split()]
m = list(map(int, input().split()))
m.sort()
maxi = 0
for i in range(len(m) - 1):
	if m[i + 1] - m[i] > maxi:
		maxi = m[i + 1] - m[i]
v = m[0]
w = maxi / 2
ans = max(v, w)
z = l - m[n - 1]
ans = max(z, ans)
print(ans)


(n, l) = map(int, input().split())
items = [int(x) for x in input().split()]
max = 0
for i in range(len(items)):
	for j in range(i + 1, len(items)):
		if items[i] > items[j]:
			(items[i], items[j]) = (items[j], items[i])
for i in range(len(items) - 1):
	gap = items[i + 1] - items[i]
	if gap > max:
		max = gap
max = max / 2
first = items[0] - 0
if first > max:
	max = first
last = l - items[n - 1]
if last > max:
	max = last
print(float(max))


l_lanterns = list()
(_, l) = map(int, input().split())
l_lanterns.append(0)
l_lanterns.append(l)
s_lanterns = set(map(int, input().split()))
l_lanterns.extend(s_lanterns)
l_lanterns.sort()
max_dist = -1
for index in range(len(l_lanterns) - 1):
	num_lanterns = 1 if l_lanterns[index + 1] in s_lanterns else 0
	num_lanterns += 1 if l_lanterns[index] in s_lanterns else 0
	max_dist = max(max_dist, (l_lanterns[index + 1] - l_lanterns[index]) / num_lanterns)
print(max_dist)


(n, l) = map(int, input().split())
l1 = list(map(int, input().split()))
l2 = sorted(l1)
flag = 0
if l > 1 and n > 1:
	max = l2[1] - l2[0]
	for i in range(1, len(l2) - 1):
		if max < l2[i + 1] - l2[i]:
			max = l2[i + 1] - l2[i]
	if l2[0] != 0 and max // 2 <= l2[0] - 0:
		max = l2[0] - 0
		flag = 1
	if flag == 0:
		if l2[n - 1] != l and max // 2 <= l - l2[n - 1]:
			max = l - l2[n - 1]
			flag = 1
	elif l2[n - 1] != l and max < l - l2[n - 1]:
		max = l - l2[n - 1]
		flag = 1
	if flag == 0:
		print(max / 2)
	else:
		print(max)
elif l2[0] == 0 or l2[0] == l:
	print(l)
else:
	print(max(l2[0] - 0, l - l2[0]))


(n, l) = map(int, input().split())
A = list(map(int, input().split()))
B = sorted(A)
C = []
if n == 1:
	print(max(A[0], l - A[0]))
else:
	for i in range(1, n):
		b = B[i] - B[i - 1]
		C.append(b)
	c = max(C)
	d = max(c, 2 * B[0], 2 * (l - B[n - 1]))
	print(float(d / 2))


(n, leng) = (int(_) for _ in input().split())
lanterns = sorted((int(_) for _ in input().split()))
if len(lanterns) == 1:
	print(max(lanterns[0], leng - lanterns[0]))
	exit()
distance = max((l2 - l1 for (l1, l2) in zip(lanterns, lanterns[1:]))) / 2
if lanterns[0] != 0:
	distance = max(distance, lanterns[0])
if lanterns[-1] != leng:
	distance = max(distance, leng - lanterns[-1])
print(distance)


(n, l) = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
cur = 0
max = A[0]
flag = 1
for i in range(1, n):
	cur = A[i] - A[i - 1]
	if max <= cur / 2:
		flag = 0
		max = cur / 2
cur = l - A[n - 1]
if max <= cur:
	max = cur
	flag = 1
print(max)


(n, l) = [int(i) for i in input().split()]
lanterns = list(map(int, input().split()))
d = 0
lanterns = sorted(lanterns)
distances = []
for i in range(n - 1):
	distances.append(lanterns[i + 1] - lanterns[i])
distances = list(map(lambda x: x / 2, distances))
if lanterns[0] != 0:
	distances.insert(0, lanterns[0])
if lanterns[n - 1] != l:
	distances.append(l - lanterns[n - 1])
d = max(distances)
print('{0:.10f}'.format(d))


(n, l) = map(int, input().split())
lanterns = list(map(int, input().split()))
lanterns.sort()
max_distance = max(lanterns[0], l - lanterns[n - 1]) * 2
for i in range(n - 1):
	distance = lanterns[i + 1] - lanterns[i]
	if distance > max_distance:
		max_distance = distance
print(max_distance / 2)


(n, l) = map(int, input().split())
lis = [int(x) for x in input().split()]
lis.sort()
diff = 0
maxdiff = 0
for i in range(len(lis) - 1):
	diff = lis[i + 1] - lis[i]
	if maxdiff < diff:
		maxdiff = diff
ma = max(lis[0], l - lis[len(lis) - 1])
ma = max(ma * 2, maxdiff)
print(ma / 2)


(n, l) = input().split()
loc = input().split()
if len(loc) >= 2:
	for i in range(0, len(loc)):
		loc[i] = int(loc[i])
	coordinates = sorted(loc)
	distance = []
	index = 0
	while int(index) != int(n) - 1:
		x = int(coordinates[index + 1]) - int(coordinates[index])
		index += 1
		distance.append(x)
	if max(distance) / 2 < int(coordinates[0]) and int(coordinates[0]) > int(l) - int(coordinates[-1]):
		print(coordinates[0])
	elif max(distance) / 2 < int(l) - int(coordinates[-1]):
		print(int(l) - int(coordinates[-1]))
	else:
		print(max(distance) / 2)
else:
	if int(loc[0]) <= int(l) / 2:
		print(abs(int(l) - int(loc[0])))
	if int(loc[0]) > int(l) / 2:
		print(int(loc[0]))


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
try:
	diff = max([a[i] - a[i - 1] for i in range(1, n)]) / 2
except ValueError:
	diff = a[0]
diff1 = a[0] - 0
diff2 = l - a[-1]
print(max(diff, diff1, diff2))


(n, l) = [int(a) for a in input().split()]
list1 = [int(a) for a in input().split()]
list1.sort()
max1 = -1
for x in range(n - 1):
	curr = list1[x + 1] - list1[x]
	if curr > max1:
		max1 = curr
max1 = max1 / 2
if list1[0] > max1:
	max1 = list1[0]
if l - list1[-1] > max1:
	max1 = l - list1[-1]
print(max1)


def valid(a, n, l, k):
	if a[0] > k or l - a[n - 1] > k:
		return False
	for i in range(1, n):
		if a[i] - a[i - 1] > 2 * k:
			return False
	return True
(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
left = 0
right = l
ans = l
while right - left > 1e-09:
	m = (left + right) / 2
	if valid(a, n, l, m):
		ans = m
		if right == m:
			break
		right = m
	else:
		if left == m:
			break
		left = m
print('{:0.10f}'.format(ans))


(n, l) = list(map(int, input().strip().split()))
lanterns = sorted(map(int, input().strip().split()))
from itertools import zip_longest
lst = max([y - x for (x, y) in zip_longest(lanterns, lanterns[1:]) if y != None], default=lanterns[0])
val = (l - lanterns[-1], lanterns[0])[lanterns[0] > l - lanterns[-1]]
print((val, lst / 2)[lst / 2 > val])


def evaluate(arr, n, l):
	_max = 0
	arr.sort()
	for i in range(n - 1):
		if arr[i + 1] - arr[i] > _max:
			_max = arr[i + 1] - arr[i]
	if _max < 2 * arr[0]:
		_max = 2 * arr[0]
	if _max < 2 * (l - arr[-1]):
		_max = 2 * (l - arr[-1])
	return _max / 2

def main():
	(n, l) = [int(i) for i in input().split()]
	a = [int(_) for _ in input().split()]
	print(evaluate(a, n, l))
main()


(n, k) = map(int, input().split(' '))
li = list(map(int, input().split(' ', n)[:n]))
li.sort()
mx = 0
if li[0] != 0:
	mx = li[0]
for i in range(1, n):
	if (li[i] - li[i - 1]) / 2 > mx:
		mx = (li[i] - li[i - 1]) / 2
if k - li[n - 1] > mx:
	mx = k - li[n - 1]
print(mx)


(k, final_) = [int(f) for f in input().split()]
data = [int(d) for d in input().split()]
data = sorted(data)
min_ = max(data[0], final_ - data[-1])
index_ = 1
while index_ < len(data):
	var = (data[index_] - data[index_ - 1]) / 2
	if var > min_:
		min_ = var
	index_ += 1
print(min_)


(n, l) = map(int, input().split())
li = list(map(int, input().split()))
li.sort()
d = 0
(d1, d2) = (0, 0)
for i in range(len(li) - 1):
	if (li[i + 1] - li[i]) / 2 > d:
		d = (li[i + 1] - li[i]) / 2
d1 = li[0]
d2 = l - li[-1]
if d1 >= d2 and d1 >= d:
	print('{:.9f}'.format(d1))
elif d2 > d1 and d2 > d:
	print('{:.9f}'.format(d2))
else:
	print('{:.9f}'.format(d))


(n, l) = [int(x) for x in input().split()]
lanternas = [int(x) for x in input().split()]
lanternas.sort()
pares_de_lanternas = []
pares_de_lanternas.append((-lanternas[0], lanternas[0]))
for i in range(1, n):
	anterior = lanternas[i - 1]
	atual = lanternas[i]
	pares_de_lanternas.append((anterior, atual))
pares_de_lanternas.append((lanternas[n - 1], lanternas[n - 1] + 2 * (l - lanternas[n - 1])))

def diferenca(item):
	return abs(item[1] - item[0])
par = max(pares_de_lanternas, key=diferenca)
print('{:.10f}'.format(abs(par[1] - par[0]) / 2))


(n, l) = map(int, input().split())
s = input()
a = [int(num) for num in s.split()]
a.sort()
b = list()
for i in range(0, n - 1):
	b.append(a[i + 1] - a[i])
b.sort()
ans = max(a[0] - 0, l - a[n - 1])
if len(b) > 0:
	ans = max(ans, b[len(b) - 1] / 2)
print('%.10f' % ans)


def Lanterns():
	(n, l) = list(map(int, input().split()))
	a = list(map(int, input().split()))
	a.sort()
	biggestDiff = max(a[0], l - a[-1])
	for i in range(len(a) - 1):
		diff = (a[i + 1] - a[i]) / 2
		biggestDiff = max(biggestDiff, diff)
	print(biggestDiff)
Lanterns()


s1 = input()
s1 = s1.split(' ')
n = int(s1[0])
l = int(s1[1])
s2 = input()
s2 = s2.split(' ')
t = []
for i in range(0, n):
	t.append(int(s2[i]))
t.sort()
a = 0
for j in range(0, n - 1):
	x = t[j + 1] - t[j]
	if x > a:
		a = x
b = t[0] - 0
c = l - t[n - 1]
print(max(a / 2, b, c))


(n, l) = map(int, input().split())
x = list(map(int, input().strip().split()))[:n]
x = sorted(x)
maxx = 0
for i in range(1, len(x)):
	maxx = max(maxx, abs(x[i] - x[i - 1]))
maxx = max(max(x[0], maxx / 2), l - x[-1])
print(maxx)


def min_radius(arr, l):
	pos = set(arr)
	pos = sorted(pos)
	ma = 0
	for i in range(len(pos) - 1):
		x = pos[i + 1] - pos[i]
		if x >= ma:
			ma = x
	r = ma / 2
	if min(pos) > r:
		r = min(pos)
	if l - max(pos) > r:
		r = l - max(pos)
	return r
(n, l) = map(int, input().split())
arr = map(int, input().split())
arr = list(arr)
r = min_radius(arr, l)
print(r)


(n, l) = map(int, input().split())
v = [int(i) for i in input().split()]
v.sort()
dmin = v[0]
for i in range(1, n):
	dmin = max(dmin, (v[i] - v[i - 1]) / 2)
print(max(dmin, l - v[-1]))


(NumLanterns, RoadLen) = input().split()
Lanterns = input().split()
LanternSort = sorted([int(i) for i in Lanterns])
del Lanterns
maxLen = float('-inf')
for i in range(1, len(LanternSort)):
	if i != 0 and (LanternSort[i] - LanternSort[i - 1]) / 2 > maxLen:
		maxLen = (LanternSort[i] - LanternSort[i - 1]) / 2
print(max(maxLen, LanternSort[0], int(RoadLen) - LanternSort[-1]))


import math
import os
import random
import re
import sys
a = list(map(int, input().rstrip().split()))
x = list(map(int, input().rstrip().split()))
x.sort()
(m, m1, m2) = (0, 0, 0)
m1 = x[0]
if a[1] == x[len(x) - 1]:
	m2 = (a[1] - x[len(x) - 2]) / 2
else:
	m2 = a[1] - x[len(x) - 1]
if m1 > m2:
	m = m1
elif m2 > m1:
	m = m2
elif m1 == m2:
	m = m1
for i in range(0, len(x) - 1):
	d = x[i + 1] - x[i]
	if d / 2 > m:
		m = d / 2
print(m)


(number_lanterns, length) = map(int, input().split())
lanterns_list = list(map(int, input().split()))[:number_lanterns]
lanterns_list = sorted(lanterns_list)
res = [lanterns_list[i + 1] - lanterns_list[i] for i in range(len(lanterns_list) - 1)]
if len(res) == 0:
	maximum_res = 0
else:
	maximum_res = max(res)
x = lanterns_list[0] - 0
y = length - lanterns_list[number_lanterns - 1]
answer = max(maximum_res / 2, max(x, y))
print(format(answer, '.10f'))


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
L = sorted(a)
biggestd = 0
for i in range(len(L) - 1):
	if (L[i + 1] - L[i]) / 2 > biggestd:
		biggestd = (L[i + 1] - L[i]) / 2
	if L[0] > biggestd:
		biggestd = L[0]
	if l - L[-1] > biggestd:
		biggestd = l - L[-1]
if L[0] > biggestd:
	biggestd = L[0]
if l - L[-1] > biggestd:
	biggestd = l - L[-1]
print(biggestd)


(n, l) = map(int, input().split())
l1 = [0] + sorted([int(x) for x in input().split()]) + [l]
maxo = l1[1] - l1[0]
for x in range(n):
	if (l1[x + 1] - l1[x]) / 2 > maxo:
		maxo = (l1[x + 1] - l1[x]) / 2
if maxo < l1[-1] - l1[-2]:
	maxo = l1[-1] - l1[-2]
print(maxo)


(n, l) = map(int, input().split())
ar = list(map(int, input().split()))
if n == 1:
	print(max(ar[0] - 0, l - ar[0]))
	exit()
ar.sort()
d = []
d.append(max(ar[0] - 0, (ar[1] - ar[0]) / 2))
for i in range(1, n - 1):
	d.append(max((ar[i] - ar[i - 1]) / 2, (ar[i + 1] - ar[i]) / 2))
d.append(max((ar[n - 1] - ar[n - 2]) / 2, l - ar[n - 1]))
a = max(d)
print(a)


firstLine = [int(x) for x in input().split()]
secondLine = [int(x) for x in input().split()]
secondLine.sort()
startDist = secondLine[0]
endDist = firstLine[1] - secondLine[-1]
distances = []
for i in range(1, len(secondLine)):
	distances.append(secondLine[i] - secondLine[i - 1])
distances.sort()
if len(distances) == 0:
	distances.append(0)
print(max(startDist, endDist, float(distances[-1]) / 2.0))


(n, l) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
line = sorted(a)
radius = line[0]
for k in range(1, n):
	radius = max(radius, (line[k] - line[k - 1]) / 2)
radius = max(radius, l - line[n - 1])
print(radius)


(n, l) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort()
begDistance = float(a[0] - 0)
endDistance = float(l - a[-1])
maxDistanceBetweenLanterns = 0
for i in range(len(a) - 1):
	if (a[i + 1] - a[i]) / 2 > maxDistanceBetweenLanterns:
		maxDistanceBetweenLanterns = (a[i + 1] - a[i]) / 2
ans = max(begDistance, endDistance, maxDistanceBetweenLanterns)
print(ans)


(n, d) = input().split()
lista = list()
for i in map(float, input().split()):
	lista.append(i)
lista.sort()
l = 0.0
r = 10000000010.0
iter = 0
while iter < 100:
	flag = True
	m = (l + r) / 2
	if lista[0] - m > 0:
		flag = False
	if int(n) > 1 and lista[0] + m * 2 < lista[1]:
		flag = False
	for i in range(1, len(lista) - 1):
		if lista[i] + m * 2 < lista[i + 1]:
			flag = False
			break
	if lista[len(lista) - 1] + float(m) < float(d):
		flag = False
	if not flag:
		l = m
	else:
		r = m
	iter = iter + 1
print(l)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
m1 = m2 = 0
if arr[0] != 0:
	m1 = arr[0]
if arr[-1] != l:
	m2 = l - arr[-1]
i = 0
m = max(m1, m2)
while i < n - 1:
	m3 = round((arr[i + 1] - arr[i]) / 2, 10)
	m = max(m, m3)
	i += 1
print(m)


(n, l) = [int(word) for word in input().split()]
arr = [int(word) for word in input().split()]
arr.sort()
da = arr[0]
db = l - arr[-1]
answer = max(da, db)
for i in range(1, n):
	d = arr[i] - arr[i - 1]
	answer = max(answer, d / 2)
print('%.1f' % answer)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
mx = 0
for i in range(n):
	mnl = a[i]
	mnr = l - a[i]
	for j in range(n):
		if j == i:
			continue
		if a[i] > a[j]:
			mnl = min(abs(a[i] - a[j]), mnl)
		elif a[i] < a[j]:
			mnr = min(abs(a[i] - a[j]), mnr)
	if mnl == a[i] and (not 0 in a):
		mnl *= 2
	if mnr == l - a[i] and (not l in a):
		mnr *= 2
	mx = max(mnr, mnl, mx)
print('%.11f' % (mx / 2))


(a, b) = [int(x) for x in input().split(' ')]
c = [int(i) for i in input().split(' ')]
c.sort()
p = c[0]
q = b - c[len(c) - 1]
max = 0
i = 0
while i < len(c) - 1:
	if c[i + 1] - c[i] > max:
		max = c[i + 1] - c[i]
		i += 1
	else:
		i += 1
r = max / 2
if p >= q and p >= r:
	print(float(p))
elif q >= p and q >= r:
	print(float(q))
else:
	print(float(r))


import sys
import math

def main():
	pass

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True

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

def iinp():
	return int(input())

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

def linp():
	return list(map(int, sys.stdin.readline().strip().split()))
(n, l) = ninp()
a = linp()
a.sort()
ans = diff = 0
for i in range(len(a) - 1):
	diff = a[i + 1] - a[i]
	if diff > ans:
		ans = diff
ans = ans / 2
if a[0] - 0 > ans and a[0] != 0:
	ans = a[0]
if l - a[len(a) - 1] > ans and a[len(a) - 1] != l:
	ans = l - a[len(a) - 1]
print(ans)


import math
(n, l) = input().split()
n = int(n)
l = int(l)
lan = list(map(int, input().split()))
diff = -1
lan.sort()
for i in range(n - 1):
	if abs(lan[i] - lan[i + 1]) > diff:
		diff = abs(lan[i] - lan[i + 1])
diff = diff / 2
if l - lan[-1] > diff:
	diff = l - lan[-1]
if lan[0] > diff:
	diff = lan[0]
print(diff)


from sys import stdin, stdout
(lamps_count, length) = [int(x) for x in stdin.readline().rstrip().split()]
lamps = [int(x) for x in stdin.readline().rstrip().split()]
max_distance = 0
lamps.sort()
for i in range(lamps_count - 1):
	if abs(float(lamps[i] - lamps[i + 1]) / 2) > max_distance:
		max_distance = abs(float(lamps[i] - lamps[i + 1]) / 2)
max_distance = max(lamps[0] - 0, length - lamps[-1], max_distance)
stdout.write(str(max_distance))


(n, l) = map(int, input().split())
L = list(map(int, input().split()))
L.sort()
d = [L[0], l - L[-1]]
for i in range(1, n):
	d.append((L[i] - L[i - 1]) / 2)
d.sort()
print('%.10f' % d[-1])


(n, l) = map(int, input().split(' '))
s = input().split(' ')
s = [int(i) for i in s]
s.sort()
t = []
tmax = 0
for i in range(0, n - 1):
	tmax = max(s[i + 1] - s[i], tmax)
temp = 2.0
temp2 = 2.0
temp1 = 2.0
temp2 = tmax / 2.0
temp = s[0] * 1.0
temp1 = (l - s[n - 1]) * 1.0
if temp2 > temp:
	if temp1 > temp2:
		print(str.format('{0:.11f}', temp1))
	else:
		print(str.format('{0:.11f}', temp2))
elif temp > temp1:
	print(str.format('{0:.11f}', temp))
else:
	print(str.format('{0:.11f}', temp1))


(n, le) = [int(x) for x in input().split()]
P = list(set([int(x) for x in input().split()]))
P.sort()
l = P[0]
r = le - P[-1]

def maxvar(P):
	L = 0
	for i in range(0, len(P) - 1):
		if P[i + 1] - P[i] > L:
			L = P[i + 1] - P[i]
	return L
print(f'{max(maxvar(P) / 2, max(l, r)):.9f}')


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
m = max(l[0] - 0, k - l[-1])
a = 0
for i in range(1, n):
	d = l[i] - l[i - 1]
	a = max(d, a)
b = a / 2
ans = max(b, m)
print('{0:.10f}'.format(ans))


(n, m) = map(int, input().split())
l = sorted(list(map(int, input().split())))
a = l[0] / 1
b = (m - l[-1]) / 1
c = []
k = 0
for i in range(n - 1):
	c.append((l[i + 1] - l[i]) / 2)
if len(c) >= 1:
	k = max(c)
if 0 not in l and m not in l:
	print(max(a, b, k), '000000000', sep='')
elif 0 not in l:
	print(max(k, a), '000000000', sep='')
elif m not in l:
	print(max(k, b), '000000000', sep='')
else:
	print(k)


(lamp_amount, street_length) = map(int, input().split(' '))
lamp_coords = sorted([int(x) for x in input().split(' ')])
min_distance = lamp_coords[0]
for (cur_lamp, next_lamp) in zip(lamp_coords, lamp_coords[1:]):
	distance = (next_lamp - cur_lamp) / 2
	if distance > min_distance:
		min_distance = distance
last_lamp_distance = street_length - lamp_coords[-1]
if last_lamp_distance > min_distance:
	min_distance = last_lamp_distance
print(min_distance)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
dif = []
if n == 1:
	if 0 or l in arr:
		dif.append(l)
	else:
		dif.append(l - arr[0])
		dif.append(arr[0])
elif 0 in arr:
	dif.append(arr[1] / 2)
	if l in arr:
		for i in range(1, n - 1):
			dif.append((arr[i + 1] - arr[i]) / 2)
	else:
		for i in range(1, n - 1):
			dif.append((arr[i + 1] - arr[i]) / 2)
		dif.append(l - arr[n - 1])
else:
	dif.append(arr[0])
	if l in arr:
		for i in range(n - 1):
			dif.append((arr[i + 1] - arr[i]) / 2)
	else:
		for i in range(1, n - 1):
			dif.append((arr[i + 1] - arr[i]) / 2)
		dif.append(l - arr[n - 1])
rad = max(dif)
print('%.10f' % rad)


(n, l) = [int(x) for x in input().split()]
L = [int(x) for x in input().split()]
L.sort()
aux = 0
for i in range(n - 1):
	aux = max(aux, float(L[i + 1] - L[i]))
aux = aux / 2
aux = max(aux, max(float(L[0]), float(l - L[n - 1])))
print('{0:.10f}'.format(aux))


(n, l) = input().split()
(n, l) = (int(n), int(l))
road = [int(x) for x in input().split()]
road.sort()
d1 = road[0]
d2 = l - road[-1]
if d2 > d1:
	d1 = d2
i = 1
d3 = 0
while i < n:
	if road[i] - road[i - 1] > d3:
		d3 = road[i] - road[i - 1]
	i = i + 1
if d3 / 2 > d1:
	d1 = d3 / 2
print(d1, sep='', end='')


line = input()
line = line.split()
n = int(line[0])
L = int(line[1])
a = input()
a = a.split()
for i in range(len(a)):
	a[i] = int(a[i])
a.sort()
d = a[0]
for i in range(len(a) - 1):
	r = (a[i + 1] - a[i]) / 2
	if r > d:
		d = r
if L - a[len(a) - 1] > d:
	d = L - a[len(a) - 1]
print(d)


radius = 0
n = list(map(int, input().split()))
count = n[0]
lenn = n[1]
lis = list(map(int, input().split()))
lis = sorted(lis)
li = []
for i in range(-1, len(lis) + 1):
	if 0 not in lis and i == -1:
		li.append(lis[0])
	elif lenn not in lis and len(lis) - 1 == i:
		li.append(lenn - lis[-1])
	elif i != -1 and i != len(lis):
		if i == len(lis) - 1:
			continue
		else:
			li.append((lis[i + 1] - lis[i]) / 2)
print('%0.9f' % max(li))


[n, l] = [int(a) for a in input().split(' ')]
lamps = [int(a) for a in input().split(' ')]
k = len(lamps)
while k > 0:
	count = 0
	while count < len(lamps) - 1:
		lampPoint = lamps[count]
		if lampPoint > lamps[count + 1]:
			a = lamps[count]
			b = lamps[count + 1]
			lamps[count] = b
			lamps[count + 1] = a
		count += 1
	k = k - 1
count = 0
max = lamps[0]
while count < len(lamps) - 1:
	lampPoint = lamps[count]
	r = (lamps[count + 1] - lampPoint) / 2
	if r > max:
		max = r
	count += 1
last = l - lamps[len(lamps) - 1]
if max < last:
	max = last
print(max)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))[:]
c = 0
if l == 1 and n == 1 and (a[0] == 1):
	print(a[0])
elif n == 1:
	p = l - a[0]
	if p > a[0]:
		print(p)
	else:
		print(a[0])
else:
	a.sort()
	for i in range(1, n):
		d = a[i] - a[i - 1]
		if d > c:
			c = d
	c = c / 2
	a[n - 1] = l - a[n - 1]
	if a[0] >= c and a[0] >= a[n - 1]:
		print(a[0])
	elif a[n - 1] >= c and a[n - 1] >= a[0]:
		print(a[n - 1])
	else:
		print(c)


(n, l) = map(int, input().split())
a = map(int, input().split())
a = list(a)
a.sort()
z = 0
k = 0
if a[0] != 0:
	a.insert(0, 0)
	z = 1
x = 0
if a[-1] != l:
	a.append(l)
	k = 1
y = []
for i in a:
	y.append((i - x) / 2)
	x = i
if z == 1:
	b = y[1]
	y.remove(b)
	b = b * 2
	y.insert(1, b)
if k == 1:
	b = y[-1]
	y.remove(b)
	b = b * 2
	y.insert(-1, b)
c = max(y)
print(float(c))


def main():
	line = input().split()
	n = int(line[0])
	l = int(line[1])
	s = input().split()
	lanterns = []
	for i in range(len(s)):
		lanterns.append(int(s[i]))
	lanterns.sort()
	maxi = lanterns[0]
	for i in range(len(lanterns) - 1):
		if (lanterns[i + 1] - lanterns[i]) / 2 > maxi:
			maxi = (lanterns[i + 1] - lanterns[i]) / 2
	if l - lanterns[-1] > maxi:
		maxi = l - lanterns[-1]
	print(maxi)
main()


(n, l) = map(int, input().split())
a = sorted(map(int, input().split()))
c = [a[i + 1] - a[i] for i in range(n - 1)]
print(max(max(c) / 2, a[0], l - a[n - 1]) if n > 1 else max(a[0], l - a[n - 1]))


(n, l) = input().split(' ')
n = int(n)
l = float(l)
lan = input().split(' ')
lan_i = [float(s) for s in lan]
lan_i.sort()
max_distance = 0
for i in range(n - 1):
	if abs(lan_i[i + 1] - lan_i[i]) > max_distance:
		max_distance = abs(lan_i[i + 1] - lan_i[i])
extremes = max(abs(lan_i[0] - 0), abs(lan_i[n - 1] - l))
print(max(max_distance / 2, extremes))


first_row = input().split()
(n, m) = (int(first_row[0]), int(first_row[1]))
numbers = list(map(int, input().split()))
sort = sorted(numbers)
mx = 0
for i in range(1, len(numbers)):
	if sort[i] - sort[i - 1] > mx:
		mx = sort[i] - sort[i - 1]
left = sort[0] - 0
right = m - sort[-1]
dist = float(mx) / 2
print(max(left, right, dist))


z = []
a = []
k = 0
(n, l) = input().split()
x = input().split()
z.append(x)
assert len(z[0]) == float(n)
for i in range(len(z[0])):
	z[0][i] = float(z[0][i])
	a.append(z[0][i])
a.sort()
k = a[0]
if float(l) - a[int(n) - 1] > k:
	k = float(l) - a[int(n) - 1]
for i in range(len(a) - 1):
	if float((a[i + 1] - a[i]) / 2) > k:
		k = float((a[i + 1] - a[i]) / 2)
print(float(k))


def VanyaAndLanterns(n, l, lanternPoints):
	lanternPoints.sort()
	maxDist = 0
	distFromInitialPoint = 0
	distFromFinalPoint = 0
	i = 1
	while i < n:
		d = float('{0:.10f}'.format((lanternPoints[i] - lanternPoints[i - 1]) / 2))
		if d > maxDist:
			maxDist = d
		i += 1
	if lanternPoints[0] != 0 and lanternPoints[0] > maxDist:
		maxDist = lanternPoints[0]
	if lanternPoints[n - 1] != l and l - lanternPoints[n - 1] > maxDist:
		maxDist = l - lanternPoints[n - 1]
	return '{0:.10f}'.format(maxDist)
(n, l) = [int(x) for x in input().split()]
lanternPoints = [int(x) for x in input().split()]
print(VanyaAndLanterns(n, l, lanternPoints))


(n, l) = [int(x) for x in input().split()]
v = list(map(int, input().split()))
v.sort()
distmax = max(2 * v[0], 2 * (l - v[n - 1]))
for i in range(n):
	distmax = max(distmax, v[i] - v[i - 1])
x = distmax / 2.0
print('%.10f' % x)


(a, b) = input().strip().split(' ')
a = int(a)
b = int(b)
ar = input().strip().split(' ')
ar1 = set()
for l in ar:
	ar1.add(int(l))
ar1 = list(ar1)
ar1.sort()
if 0 in ar1 and b in ar1:
	m = -10000000
	for i in range(len(ar1) - 1):
		if ar1[i + 1] - ar1[i] > m:
			m = ar1[i + 1] - ar1[i]
	print(m / 2.0)
elif 0 in ar1:
	m = -10000000
	for i in range(len(ar1) - 2):
		if ar1[i + 1] - ar1[i] > m:
			m = ar1[i + 1] - ar1[i]
	if b - ar1[len(ar1) - 1] > m / 2.0:
		print(b - ar1[len(ar1) - 1])
elif b in ar1:
	m = -10000000
	for i in range(1, len(ar1) - 1):
		if ar1[i + 1] - ar1[i] > m:
			m = ar1[i + 1] - ar1[i]
	if ar1[0] > m / 2.0:
		print(ar1[0])
else:
	m = -10000000
	for i in range(1, len(ar1) - 2):
		if ar1[i + 1] - ar1[i] > m:
			m = ar1[i + 1] - ar1[i]
	if ar1[0] > m / 2.0 and ar1[0] >= b - ar1[len(ar1) - 1]:
		print(ar1[0])
	elif b - ar1[len(ar1) - 1] >= ar1[0] and b - ar1[len(ar1) - 1] > m / 2.0:
		print(b - ar1[len(ar1) - 1])
	else:
		print(m / 2.0)


(n, l) = list(map(int, input().split()))
values = list(map(int, input().split()))
values.sort()
max_ = 0
for i in range(len(values) - 1):
	if max_ < values[i + 1] - values[i]:
		max_ = values[i + 1] - values[i]
print(max(max(max_ / 2, values[0]), l - values[len(values) - 1]))


a = list(map(int, input().split()))
n = a[0]
l = a[1]
b = list(map(int, input().split()))
b.sort()
maxa = 0
for i in range(n - 1):
	yo = b[i + 1] - b[i]
	if b[i + 1] - b[i] > maxa:
		maxa = b[i + 1] - b[i]
maxu = max(maxa / 2, b[0], l - b[n - 1])
print(maxu)


[n, l] = [int(z) for z in input().split()]
lamps = sorted([int(y) for y in input().split()])
prev = lamps[0]
max = lamps[0]
if l - lamps[n - 1] > max:
	max = l - lamps[n - 1]
for i in range(1, n):
	tmp = (lamps[i] - prev) / 2
	if tmp > max:
		max = tmp
	prev = lamps[i]
print(max)


(n, l) = [int(i) for i in input().split(' ')]
L = [int(i) for i in input().split(' ')]
L.sort()
i = 2 * float(max(L[0], l - L[n - 1]))
for j in range(1, n):
	i = float(max(L[j] - L[j - 1], i))
print(float(i) / 2)


(a, b) = map(int, input().split())
l = sorted(list(map(int, input().split())))
m = min(l) if min(l) > b - max(l) else b - max(l)
for i in range(a - 1):
	if (l[i + 1] - l[i]) / 2 > m:
		m = (l[i + 1] - l[i]) / 2
print(m)


a = list(map(int, input().split(' ')))
b = list(map(int, input().split(' ')))
b.sort()
high = 0
for i in range(0, a[0] - 1):
	high = max(high, (b[i + 1] - b[i]) / 2)
high = max(high, b[0], a[1] - b[a[0] - 1])
print(high)


(n, l) = [int(value) for value in input().split(' ')]
positions = [float(value) for value in input().split(' ')]
positions.sort()
pos = 0
start = float(positions[0])
d = start
end = float(l - positions[n - 1])
if d < end:
	d = end
while pos <= n - 2:
	temp = (positions[pos + 1] - positions[pos]) / 2
	if d < temp:
		d = temp
	pos += 1
print(d)


(n, l) = input().split()
(n, l) = [int(n), int(l)]
a = [int(i) for i in input().split()]
a.sort()
i = 1
b = []
while i < n:
	b.append(a[i] - a[i - 1])
	i += 1
if len(b) != 0:
	m = max(b)
	m = m / 2
	print(max(m, a[0], l - a[n - 1]))
else:
	print(max(a[0], l - a[n - 1]))


import sys
(n, length) = list(map(int, sys.stdin.readline().split()))
locations = list(map(int, sys.stdin.readline().split()))
locations.sort()
maxDist = max(locations[0], length - locations[-1]) * 2
for i in range(n - 1):
	maxDist = max(maxDist, locations[i + 1] - locations[i])
print(maxDist / 2)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
md = [a[i + 1] - a[i] for i in range(n - 1)] + [-1 << 31]
res = max(md) / 2
if 0 in a and l in a:
	print(res)
elif 0 in a:
	d = l - a[n - 1]
	print(max(d, res))
elif l in a:
	d = a[0] - 0
	print(max(d, res))
else:
	d = l - a[n - 1]
	dd = a[0] - 0
	print(max(d, dd, res))


s = input().split()
n = int(s[0])
l = int(s[1])
s = input().split()
for i in range(len(s)):
	s[i] = int(s[i])
s.sort()
curr = -s[0]
s.append(l + l - s[-1])
res = 0
for i in s:
	if res < (i - curr) / 2:
		res = (i - curr) / 2
	curr = i
print(res)


(a, b) = [int(x) for x in input().split()]
list1 = [int(x) for x in input().split()]
list2 = sorted(list1)
c = []
for i in range(0, a - 1):
	d = list2[i + 1] - list2[i]
	c.append(d)
if c == []:
	c = list1
e = max(c)
m = list2[0]
n = b - list2[-1]
p = float(e / 2)
print(max(m, n, p))


n = list(map(int, input().rstrip().split()))
arr = list(map(int, input().rstrip().split()))
arr.sort()
arrlen = len(arr)
initial_dist = arr[0] - 0
final_dist = n[1] - arr[-1]
minn = -float('inf')
for i in range(1, arrlen):
	if arr[i] - arr[i - 1] > minn:
		minn = arr[i] - arr[i - 1]
print(max(initial_dist, final_dist, minn / 2))


__author__ = 'valeriy.shevchuk'
(n, l) = map(int, input().split())
data = sorted(list(map(int, input().split())))
max_v = max(data[0], l - data[-1])
for i in range(1, len(data)):
	v = (data[i] - data[i - 1]) / 2
	if v > max_v:
		max_v = v
print(max_v)


(lights, street_length) = list(map(int, input().split()))
pos = sorted(list(map(int, input().split())))
pos = [-pos[0]] + pos + [street_length * 2 - pos[-1]]
print(max([y - x for (x, y) in zip(pos[:-1], pos[1:])]) / 2)


(n, l) = map(int, input().split())
poles = sorted(map(int, input().split()))
if n == 1:
	print(max(poles[0], l - poles[0]))
else:
	spaces = []
	for i in range(1, n):
		spaces.append(poles[i] - poles[i - 1])
	print(max(max(spaces) / 2, poles[0], l - poles[-1]))


(light, leN) = map(int, input().split())
points = [int(n) for n in input().split()]
points.sort()
(lp, lr, rt, lt) = (points[0], 0, leN - points[-1], points[0])
for i in points:
	if abs(i - lp) / 2 > lr:
		lr = abs(i - lp) / 2
	lp = i
if rt > lt:
	print(lr if lr > rt else rt)
else:
	print(lr if lr > lt else lt)


(n, l) = map(int, input().split())
lit = list(map(int, input().split()))[:n]
lit = sorted(lit)
s = []
x = max(lit[0] - 0, l - lit[-1])
if len(lit) == 1:
	if lit[0] != l:
		s.append(x)
	else:
		s.append(l)
else:
	for i in range(n):
		s.append(max((lit[-i] - lit[-i - 1]) / 2, x))
print(format(max(s), '.10f'))


(l, m) = map(int, input().split())
ass = sorted(map(int, input().split()), reverse=True)
(ans, cur_max) = (m - ass[0], ass[0])
for j in range(1, l):
	sep = (cur_max - ass[j]) / 2
	cur_max = ass[j]
	if sep > ans:
		ans = sep
ans = ass[-1] if ass[-1] > ans else ans
print(ans)


(n, l) = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
diff = 0
for i in range(1, n):
	diff = max(diff, a[i] - a[i - 1])
ans = max(a[0], diff / 2, l - a[n - 1])
print('%.10f' % ans)


(n, l) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort()
diff = [0] * (2 * n)
if a[0] == 0 and n > 1:
	diff[0] = (a[1] - a[0]) / 2
else:
	diff[0] = a[0]
maxd = diff[0]
k = 1
for i in range(2, n - 1):
	diff[k] = (a[i] - a[i - 1]) / 2
	maxd = max(maxd, diff[k])
	k += 1
if a[n - 1] == l:
	diff[k] = (l - a[n - 2]) / 2
	maxd = max(maxd, diff[k])
else:
	diff[k] = l - a[n - 1]
	maxd = max(maxd, diff[k])
print(maxd)


[n, l] = [int(i) for i in input().split()]
L = [int(i) for i in input().split()]
L.sort()
maxdistance = 0
for k in range(n - 1):
	if L[k + 1] - L[k] > maxdistance:
		maxdistance = L[k + 1] - L[k]
dmin = max(maxdistance / 2, L[0], l - L[-1])
print(dmin)


(n, l) = map(int, input().split())
ll = list(map(int, input().split()))
ll.sort()
try:
	mx = max([ll[i + 1] - ll[i] for i in range(len(ll) - 1)]) / 2
	print(float(max(ll[0], l - ll[-1], mx)))
except:
	print(float(max(ll[-1] - 0, l - ll[-1])))


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
start = a[0]
b = []
end = m - a[len(a) - 1]
for i in range(n - 1):
	b.append((a[i + 1] - a[i]) / 2)
b.sort()
if n == 1:
	print(max(start, end))
else:
	print(max(start, end, b[len(b) - 1]))


(n, l) = [int(x) for x in input().split()]
x = [int(x) for x in input().split()]
x.sort()
dm = 0
x.insert(0, -1 * x[0])
x.insert(len(x), l + (l - x[-1]))
for i in range(1, len(x)):
	a = x[i]
	b = x[i - 1]
	if a - b > dm:
		dm = a - b
r = dm / 2
print(r)


(n, l) = input().split()
n = int(n)
l = int(l)
p = [int(x) for x in input().split()]
p = sorted(p)
dif = list()
for i in range(n - 1):
	dif.append(p[i + 1] - p[i])
m = float(max(p[0], l - p[n - 1]))
if len(dif) > 0:
	d = float(max(dif) / 2)
else:
	d = m
print(max(m, d))


(n, l) = map(int, input().split())
listOfLanterns = sorted(list(map(int, input().split())))
largestDistance = 0
for i in range(len(listOfLanterns) - 1):
	firstLantern = listOfLanterns[i]
	secondLantern = listOfLanterns[i + 1]
	if secondLantern - firstLantern > largestDistance:
		largestDistance = secondLantern - firstLantern
	else:
		continue
largestDistance = largestDistance / 2
firstVar = min(listOfLanterns)
secondVar = l - max(listOfLanterns)
answer = 0
if largestDistance > firstVar:
	answer = largestDistance
elif largestDistance < firstVar:
	answer = firstVar
else:
	answer = largestDistance
if answer > secondVar:
	answer = answer
else:
	answer = secondVar
print(answer)


(n, m) = map(int, input().split())
l = sorted(list(map(int, input().split())))
c = l[0]
for i in range(n - 1):
	r = (l[i + 1] - l[i]) / 2
	if r > c:
		c = r
y = m - l[-1]
if y > c:
	print(y)
else:
	print(c)


(n, l) = map(int, input().split())
l0 = [int(x) for x in input().split()]
l1 = [0]
for i in l0:
	l1.append(i)
l1.append(l)
l1.sort()
a = max([l1[i + 1] - l1[i] for i in range(n + 1)]) / 2
b = l1[1] - l1[0]
c = l1[n + 1] - l1[n]
print(max([a, b, c]))


(n, l) = list(map(lambda x: int(x), input().split()))
linterns = list(map(lambda x: int(x), input().split()))
linterns.sort()
maxDist = 0
for i in range(1, len(linterns)):
	dist = (linterns[i] - linterns[i - 1]) / 2
	maxDist = max(dist, maxDist)
print(max(maxDist, linterns[0], l - linterns[-1]))


row = input().split()
n = int(row[0])
l = int(row[1])
mat = [int(i) for i in input().split()]
mat.sort()
counter = 0
if 0 not in mat:
	counter = (mat[0] - 0) * 2
if l not in mat:
	if counter < (l - mat[-1]) * 2:
		counter = (l - mat[-1]) * 2
for i in range(1, len(mat)):
	if counter < mat[i] - mat[i - 1]:
		counter = mat[i] - mat[i - 1]
print(counter / 2)


(n, l) = input().split()
m = input().split()
list = []
n = int(n)
l = int(l)
for i in range(n):
	list.append(int(m[i]))
list = sorted(list)
large = 0
for i in range(0, len(list) - 1):
	if abs(list[i] - list[i + 1]) > large:
		large = abs(list[i] - list[i + 1])
a = abs(list[-1] - l)
b = list[0] - 0
large = large / 2
ans = max(large, max(a, b))
if ans == large:
	print(ans)
else:
	print(ans)


(n, l) = [int(x) for x in input().split()]
a = list(set([int(x) for x in input().split()]))
a.sort()
d = [(a[i + 1] - a[i]) / 2 for i in range(len(a) - 1)]
d.append(a[0] - 0)
d.append(l - a[-1])
print('{:.10f}'.format(max(d)))


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
maxdif = 0
if n > 1:
	maxdif = max((abs(a[i] - a[i + 1]) for i in range(n - 1)))
r = max(maxdif / 2, a[0], l - a[n - 1])
print(r)


(n, l) = map(int, input().split(' '))
light = sorted(map(int, input().split(' ')))
mz = light[0]
ml = light[n - 1] - l
mz *= 2
ml *= 2
ml = -ml if ml < 0 else ml
maxD = 0
i = 1
while i < n:
	d = light[i] - light[i - 1]
	if d > maxD:
		maxD = d
	i += 1
maximum = maxD if maxD >= mz and maxD >= ml else ml if ml > mz else mz
print('{0:.10f}'.format(maximum / 2))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
max_dist = 2 * max(a[0], l - a[n - 1])
for i in range(1, n):
	dist = a[i] - a[i - 1]
	if dist > max_dist:
		max_dist = dist
print(max_dist / 2)


(n, l) = input().split()
n = int(n)
l = int(l)
li = list(map(int, input().split()))
li.sort()
m = 0
for i in range(1, n):
	m = max(m, li[i] - li[i - 1])
left = 0
right = 0
if li[0] != 0:
	left = li[0] - 0
if li[n - 1] != l:
	right = l - li[n - 1]
print(max(left, right, m / 2))


(n, l) = [int(s) for s in input().rstrip().split(' ')]
lanterns = [int(s) for s in input().rstrip().split(' ')]
lanterns.sort()
d = max(lanterns[0], l - lanterns[-1])
for i in range(1, len(lanterns)):
	d = max(d, (lanterns[i] - lanterns[i - 1]) / 2)
print(d)


(n, l) = map(int, input().split())
s = list(map(int, input().split()))
k = 0
nach = 0
kon = 0
s.sort()
for i in range(1, n):
	if s[i] - s[i - 1] > k:
		k = s[i] - s[i - 1]
nach = s[0]
kon = l - s[n - 1]
if nach >= kon and nach > k / 2:
	print(float(nach))
elif kon > nach and kon > k / 2:
	print(float(kon))
else:
	print(float(k / 2))


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
max_distance = 0
for lamp_i in range(n - 1):
	if a[lamp_i + 1] - a[lamp_i] > max_distance:
		max_distance = a[lamp_i + 1] - a[lamp_i]
print(max(a[0], l - a[-1], max_distance / 2))


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.append(0)
a.append(l)
n = n + 2
a.sort()
b = []
for i in range(n - 1):
	b.append(a[i + 1] - a[i])
r1 = max(b) / 2
r2 = a[1]
r3 = l - a[-2]
print(max(r1, r2, r3))


from sys import stdin, stdout
(n, l) = map(int, stdin.readline().split())
a = [int(x) for x in stdin.readline().split()]
a.sort()
diff = []
for i in range(0, n - 1):
	diff.append((a[i + 1] - a[i]) / 2)
diff.append(a[0])
diff.append(l - a[n - 1])
stdout.write(str(max(diff)))


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353

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

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def L():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
try:
	sys.stdin = open('input.txt', 'r')
except:
	pass
(n, l) = L()
A = L()
A.sort()
d = []
d.append(A[0])
d.append(l - A[-1])
for i in range(n - 1):
	d.append((A[i + 1] - A[i]) / 2)
print(max(d))
endtime = time.time()


import math
(n, l) = [int(x) for x in input().strip().split()]
a = [int(x) for x in input().strip().split()]
a.sort()
r = -math.inf
if not a[0] == 0:
	r = a[0]
if not a[-1] == l:
	r = max(r, l - a[-1])
for i in range(n - 1):
	r = max(r, (a[i + 1] + a[i]) / 2 - a[i])
print(r)


(n, l) = map(int, input().split())
b = set(map(int, input().split()))
(f1, f2) = (0, 0)
if 0 not in b:
	f1 = 1
	b.add(0)
if l not in b:
	f2 = 1
	b.add(l)
a = sorted(list(b))
ans = -float('inf')
for i in range(1, len(a)):
	if i == 1 and f1 == 1 or (i == len(a) - 1 and f2 == 1):
		if a[i] - a[i - 1] > ans:
			ans = a[i] - a[i - 1]
	elif (a[i] - a[i - 1]) / 2 > ans:
		ans = (a[i] - a[i - 1]) / 2
print(ans)


(n, l) = map(int, input().split())
lst = list(map(int, input().split()))
lst += [0, l]
lst.sort()
lst[0] = -lst[1]
lst[len(lst) - 1] = lst[len(lst) - 1] - lst[len(lst) - 2] + lst[len(lst) - 1]
mx = 0
for i in range(len(lst) - 1):
	if lst[i + 1] - lst[i] > mx:
		mx = lst[i + 1] - lst[i]
print(mx / 2)


(n, l) = [int(x) for x in input().split()]
series = [int(x) for x in input().split()]
series.sort()
diff = series[0] - 0
for i in range(n - 1):
	diff = max((series[i + 1] - series[i]) / 2, diff)
diff = max(diff, l - series[-1])
print(diff)


(n, l) = [int(x) for x in input().split()]
deng = [int(x) for x in input().split()]
deng.sort()
juli = []
for i in range(n):
	if i == 0:
		no = deng[0] - 0
		juli.append(no)
	if i == n - 1:
		no1 = deng[n - 1] - deng[n - 2]
		juli.append(no1 / 2)
		no2 = l - deng[n - 1]
		juli.append(no2)
	else:
		no = deng[i] - deng[i - 1]
		juli.append(no / 2)
print(max(juli))


(n, l) = [int(x) for x in input().split(' ')]
locations = [int(x) for x in input().split(' ')]
locations = sorted(locations)
minimum = 0
a = 0
b = 1
while b < n:
	minimum = max(minimum, (locations[b] - locations[a]) / 2)
	a += 1
	b += 1
minimum = max(minimum, locations[0], l - locations[-1])
print(minimum)


(n, l) = map(int, input().split())
coords = list(map(float, input().split()))
coords.sort()
max_dist = max(coords[0], l - coords[-1])
for i in range(1, len(coords)):
	if (coords[i] - coords[i - 1]) / 2 > max_dist:
		max_dist = (coords[i] - coords[i - 1]) / 2
print(max_dist)


k = lambda : map(int, input().split())
(a, b) = k()
e = []
c = sorted(k())
d = int(1)
while d < a:
	e.append(abs(c[d] - c[d - 1]))
	d = d + 1
if len(e) != 0:
	j = max(e)
else:
	j = 0
print(max(j / 2, b - max(c), c[0]))


(n, r) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
ans = max(arr[0], r - arr[-1])
for i in range(1, len(arr)):
	ans = max(ans, (arr[i] - arr[i - 1]) / 2.0)
print(ans)


(n, l) = tuple(map(int, input().strip().split()))
p = list(map(int, input().strip().split()))
pos = sorted(p)
diff = -1
for i in range(len(pos) - 1):
	d = pos[i + 1] - pos[i]
	if d > diff:
		diff = d
c1 = pos[0] - 0
c2 = l - pos[n - 1]
min_d = max(diff / 2, c1, c2)
l = 10 ** (-12)
ans = min_d + l
print(ans)


(n, w) = map(int, input().split())
l = list(map(int, input().split()))
if n == 1:
	print(max(l[0], w - l[0]))
else:
	dif = []
	l.sort()
	for i in range(1, n):
		dif.append((l[i] - l[i - 1]) / 2)
	if l[0] != 0:
		dif.append(l[0])
	if l[-1] != w:
		dif.append(w - l[-1])
	print(max(dif))


(n, l) = [int(x) for x in input().split(' ')]
lst = sorted([float(x) for x in input().split(' ')])
m = max(abs(lst[0]), abs(lst[-1] - l))
for i in range(1, n):
	m = max(abs(lst[i] - lst[i - 1]) / 2, m)
print(m)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
count = 0
summa = 0
a.sort()
for i in range(len(a) - 1):
	count = abs(a[i] - a[i + 1])
	if count > summa:
		summa = count
mini = min(a) - 0
maxi = l - max(a)
if mini >= maxi and mini >= summa / 2:
	print(mini)
elif maxi >= mini and maxi >= summa / 2:
	print(maxi)
else:
	print(summa / 2)


nl = input().split()
n = int(nl[0])
l = int(nl[1])
c = sorted(list(map(int, input().split())))
d = [0] * (n + 1)
d[0] = 2 * c[0]
for i in range(1, n):
	d[i] = c[i] - c[i - 1]
d[n] = 2 * (l - c[n - 1])
print(max(d) / 2)


(n, l) = tuple(map(int, input().split()))
array = sorted(list(map(int, input().split())))
i = 0
max = 0
while i < n:
	if i == n - 1:
		pos = l - array[i]
	else:
		pos = abs(array[i + 1] - array[i])
	if max < pos:
		max = pos
	i += 1
s = array[0] - 0
e = l - array[n - 1]
if s < e:
	s = e
if float(s) > max / 2:
	print(float('{:.9f}'.format(s)))
else:
	print(float('{:.9f}'.format(max / 2)))


l = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort()
d = a[0]
for i in range(len(a) - 1):
	if (a[i + 1] - a[i]) / 2 > d:
		d = (a[i + 1] - a[i]) / 2
if l[1] - a[l[0] - 1] > d:
	d = l[1] - a[l[0] - 1]
print('%.10f' % d)


(n, l) = map(int, input().split())
s = [int(s) for s in input().split()]
s.sort()
d = []
if n > 1:
	for i in range(n - 1):
		if i < n:
			d.append(s[i + 1] - s[i])
else:
	d.append(0)
y = max(max(d) / 2, s[0], l - s[n - 1])
print(y)


def max_d(a):
	a.sort()
	if not 0 in a:
		d = a[0]
	else:
		d = 0
	for i in range(len(a) - 1):
		curr_d = (a[i + 1] - a[i]) / 2
		if curr_d > d:
			d = curr_d
	if not l in a:
		d = max(l - a[-1], d)
	return float(d)
std = input()
std2 = input()
(n, l) = map(int, std.split())
a = list(map(int, std2.split()))
print(max_d(a))


(n, l) = map(int, input().split())
k = list(map(int, input().split()))
k.sort()
k1 = [k[0], l - k[-1]]
for i in range(1, len(k)):
	k1.append((k[i] - k[i - 1]) / 2)
print(max(k1))


(n, l) = map(int, input().split())
lans = list(map(int, input().split()))
lans.sort()
d = max(lans[0], l - lans[-1])
for i in range(n - 1):
	d = max(d, abs(lans[i] - lans[i + 1]) / 2)
print(d)


(n, m) = map(int, input().split())
n1 = sorted(list(map(int, input().split())))
ld = 0
for i in range(len(n1) - 1):
	if ld < n1[i + 1] - n1[i]:
		ld = n1[i + 1] - n1[i]
print('{0:.10f}'.format(max(max(n1[0] - 0, m - n1[n - 1]), ld / 2)))


(n, l) = [int(x) for x in input().split()]
lan = sorted([int(x) for x in input().split()])
m = 0
for i in range(len(lan) - 1):
	if (lan[i + 1] - lan[i]) / 2 > m:
		m = (lan[i + 1] - lan[i]) / 2
if lan[0] == 0 and lan[-1] != l:
	m = max(m, l - lan[-1])
elif lan[0] != 0 and lan[-1] == l:
	m = max(m, lan[0])
else:
	m = max(m, lan[0], l - lan[-1])
print(format(m, '.11f'))


def solve(n, l, arr):
	brr = []
	arr.sort()
	brr.append(abs(arr[0] - 0))
	for i in range(n - 1):
		brr.append((arr[i + 1] - arr[i]) / 2)
	ans = max(max(brr), abs(arr[n - 1] - l))
	print(ans)
(n1, l1) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
solve(n1, l1, a)


(n, l) = map(float, input().split())
a = list(map(float, input().split()))
a.sort()
f1 = False
f2 = False
min_value = 0.0
if a[0] == 0.0:
	f1 = True
if a[int(n - 1.0)] == l:
	f2 = True
for i in range(1, int(n)):
	if a[i] - a[i - 1] > min_value:
		min_value = a[i] - a[i - 1]
min_value /= 2.0
if not f1:
	if a[0] > min_value:
		min_value = a[0]
if not f2:
	if l - a[int(n) - 1] > min_value:
		min_value = l - a[int(n) - 1]
print(min_value)


from decimal import Decimal
(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
max_dist = 2 * max(a[0], l - a[n - 1])
for i in range(1, n):
	dist = a[i] - a[i - 1]
	if dist > max_dist:
		max_dist = dist
d = Decimal(max_dist / 2)
print(round(d, 10))


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
min_d = a[0]
for i in range(n - 1):
	min_d = max(min_d, (a[i + 1] - a[i]) / 2)
min_d = max(min_d, l - a[-1])
print(f'{min_d:.9f}')


(n, l) = map(int, input().split())
m = map(int, input().split())
f = sorted(list(m))
if n == 1:
	print('{:.9f}'.format(max(f[0], l - f[0])))
else:
	v = []
	for i in range(len(f) - 1):
		d = f[i + 1] - f[i]
		v.append(d)
	b = max(v) / 2
	if b <= min(f) and b <= l - max(f):
		print('{:.9f}'.format(max(min(f), l - max(f))))
	elif b <= min(f) and b > l - max(f):
		print('{:.9f}'.format(min(f)))
	elif b > min(f) and b <= l - max(f):
		print('{:.9f}'.format(l - max(f)))
	else:
		print('{:.9f}'.format(b))


def solve(arr, n, l):
	max_dist = -1
	arr.sort()
	for i in range(1, len(arr)):
		max_dist = max(max_dist, arr[i] - arr[i - 1])
	ans = max(max_dist / 2, max(arr[0], l - arr[n - 1]))
	print(str.format('{0:.10f}', ans))
(n, l) = map(int, input().split())
arr = [int(i) for i in input().split()]
solve(arr, n, l)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
a.append(l * 2 - a[n - 1])
a.insert(0, -a[0])
res = 0
for i in range(1, n + 2):
	res = max(res, a[i] - a[i - 1])
print(res / 2)


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
if m == 1:
	print(1)
else:
	l.sort()
	high = l[0]
	for i in range(1, n):
		high = max(high, (l[i] - l[i - 1]) / 2)
	high = max(high, l[0], m - l[n - 1])
	print(high)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
newarr = [arr[0]]
for i in range(1, len(arr)):
	newarr += [arr[i] - arr[i - 1]]
newarr.append(l - arr[-1])
maxi = max(newarr) / 2
if maxi > newarr[0] and maxi > newarr[-1]:
	res = maxi
else:
	res = max(newarr[0], newarr[-1])
print('%.10f' % res)


string = str(input()).split()
n = string[0]
l = string[1]
string = str(input()).split()
string2 = []
count = 0
for i in string:
	string2.append(int(string[count]))
	count += 1
string2 = sorted(string2, reverse=True)
x = 0
max = 0
for i in string2:
	x += 1
	if i != string2[-1]:
		if i - string2[x] > max:
			max = i - string2[x]
if int(l) - int(string2[0]) < int(string2[-1]):
	max2 = int(string2[-1])
else:
	max2 = int(l) - int(string2[0])
if max / 2 > max2:
	print(max / 2)
else:
	print(max2)


(l, n) = map(int, input().rstrip().split())
lists = sorted(list(map(int, input().rstrip().split())))
maxi = 0
for i in range(len(lists) - 1):
	maxi = max(maxi, abs(lists[i + 1] - lists[i]))
maxi = maxi / 2
if maxi < lists[0]:
	maxi = lists[0]
if n - lists[-1] > maxi:
	maxi = n - lists[-1]
print(maxi)


(n, l) = map(int, input().split())
ls = list(map(int, input().split()))
ls.sort()
mx = 0
for i in range(1, n):
	tmp = ls[i] - ls[i - 1]
	if tmp > mx:
		mx = tmp
mx /= 2
if ls[0] > mx:
	mx = ls[0]
if l - ls[n - 1] > mx:
	mx = l - ls[n - 1]
print(mx)


(n, theLength) = map(int, input().split())
myList = list(map(int, input().split()))

def binary_search(a_list, target):
	inicio = 0
	final = len(a_list) - 1
	while inicio <= final:
		median = int((inicio + final) / 2)
		if target == a_list[median]:
			return True
		elif target > a_list[median]:
			inicio = median + 1
		else:
			final = median - 1
	return False

def findMinimiumRadio(totalLength, arrayLanterns):
	arrayLanterns.sort()
	newArray = []
	if binary_search(arrayLanterns, 0) == True and binary_search(arrayLanterns, totalLength) == True:
		for i in range(0, len(arrayLanterns) - 1):
			val = (arrayLanterns[i + 1] - arrayLanterns[i]) / 2
			newArray.append(val)
	else:
		for i in range(1, len(arrayLanterns) - 2):
			val = (arrayLanterns[i + 1] - arrayLanterns[i]) / 2
			newArray.append(val)
		if binary_search(arrayLanterns, 0) == False:
			newArray.append(arrayLanterns[0])
		if binary_search(arrayLanterns, totalLength) == False:
			newArray.append(totalLength - arrayLanterns[len(arrayLanterns) - 1])
	valMax = format('%.10f' % max(newArray))
	return valMax
print(findMinimiumRadio(theLength, myList))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.insert(0, 0)
a.append(l)
a.sort()
gaps = [(a[i + 1] - a[i]) / 2 for i in range(0, len(a) - 1)]
if 0 in a:
	gaps[0] *= 2
if l in a:
	gaps[-1] *= 2
print('%.10f' % max(gaps))


c = input().split()
n = int(c[0])
l = int(c[1])
k = input().split()
s = []
for e in k:
	s.append(int(e))
s.sort()
b = s[0] - 0
o = l - s[n - 1]
e = []
for i in range(n - 1):
	e.append((s[i + 1] - s[i]) / 2)
e.append(b)
e.append(o)
print(max(e))


(n, l) = map(int, input().split())
lis = list(map(int, input().split()))
lis.sort()
prev = -1 * lis[0]
ans = -1
for i in lis:
	ans = max(ans, (i - prev) / 2)
	prev = i
ans = max(ans, l - lis[-1])
print('{0:.10f}'.format(ans))


import os
import sys
import math
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		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')
SML = 1e-10
(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()

def check(d):
	i = 0
	while i < n:
		if i != 0:
			x = (a[i] - a[i - 1]) / 2.0
			if d < x and math.fabs(d - x) > SML:
				return -1
		i += 1
	return 1
st = 0.0
i = 0
while i < n:
	if i == 0:
		en = a[i]
	else:
		en = max(en, a[i] - a[i - 1])
	i += 1
en = max(en, l - a[n - 1])
d = 0
i = 0
while i <= 200:
	mid = (st + en) / 2.0
	if check(mid) == 1:
		d = mid
		en = mid
	else:
		st = mid
	i += 1
d = max(d, max(l - a[n - 1], a[0]))
print('%.9f' % d)


a = list(map(int, input().split()))
(n, m) = (a[0], a[1])
b = list(map(int, input().split()))
b = [i for i in set(b)]
b.sort()
em = 0
if m - b[len(b) - 1] > b[0]:
	em = m - b[len(b) - 1]
else:
	em = b[0]
for i in range(1, len(b)):
	if (b[i] - b[i - 1]) / 2 >= em:
		em = (b[i] - b[i - 1]) / 2
print(em)


(l, n) = [int(x) for x in input().split()]
lista = [int(x) for x in input().split()]
lista.sort()
maxi = 0
for i in range(l - 1):
	maxi = max(maxi, (lista[i + 1] - lista[i]) / 2)
maxi = float(max(maxi, lista[0], n - lista[-1]))
print(maxi)


(n, l) = map(int, input().split())
lanterns = list(map(int, input().split()))
lanterns = sorted(lanterns)
first = lanterns[0] - 0
last = l - lanterns[n - 1]
distance = 0
for i in range(n - 1):
	if lanterns[i + 1] - lanterns[i] > distance:
		distance = lanterns[i + 1] - lanterns[i]
print(max(first, last, distance / 2))


line = input().split(' ')
(n, l) = [int(i) for i in line]
lights = list(map(int, input().split(' ')))
lights.sort()
max_dist = lights[0] * 2
for light in range(1, len(lights)):
	if lights[light] - lights[light - 1] > max_dist:
		max_dist = lights[light] - lights[light - 1]
if (l - lights[n - 1]) * 2 > max_dist:
	max_dist = (l - lights[n - 1]) * 2
print(max_dist / 2)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
m = 0
for i in range(0, n - 1):
	if a[i + 1] - a[i] > m:
		m = a[i + 1] - a[i]
r = a[0]
s = m / 2
x = l - a[n - 1]
print(max(x, max(r, s)))


from decimal import *
getcontext().prec = 9
(n, m) = input().split()
n = int(n)
m = int(m)
arr = list(map(int, input().split()))
arr.sort(key=int)
ma = int(-1)
for i in range(1, n):
	ma = max(ma, abs(arr[i] - arr[i - 1]))
if arr[0] == 0 and arr[n - 1] == m:
	print(Decimal(ma) / Decimal(2))
else:
	ma = max(ma, 2 * max(abs(arr[n - 1] - m), arr[0]))
	print(Decimal(ma) / Decimal(2))


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
(x, y, max_count) = (l[0], m - l[-1], 0)
for i in range(1, n):
	a = l[i] - l[i - 1]
	if a > max_count:
		max_count = a
print(max(max_count / 2, y, x))


(n, l) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
d1 = float(a[0])
d2 = float(l - a[n - 1])
d = 0
for i in range(n - 1):
	d = max(d, float((a[i + 1] - a[i]) / 2))
dma = max(d1, d2, d)
print(dma)


nl = list(map(int, input().split()))
n = nl[0]
l = nl[1]
lis = list(map(int, input().split()))
lis.sort()
ans = max(l - lis[n - 1], lis[0] - 0)
for i in range(1, n):
	ans = max(ans, (lis[i] - lis[i - 1]) / 2)
ans = '%.10f' % ans
print(ans)


(m, n) = list(map(int, input().split()))
l = list(map(int, input().split()))
l.sort()
min_d = 0
if 0 not in l or n not in l:
	if l[0] * 1 > n - l[m - 1]:
		min_d = l[0]
	else:
		min_d = n - l[m - 1]
for i in range(len(l) - 1):
	if (l[i + 1] - l[i]) / 2 > min_d:
		min_d = (l[i + 1] - l[i]) / 2
print(min_d)


(n, l) = map(int, input().split())
l1 = input().split()
for i in range(len(l1)):
	l1[i] = int(l1[i])
l1.sort()
m = 0
for i in range(1, len(l1)):
	if l1[i] - l1[i - 1] > m:
		m = l1[i] - l1[i - 1]
if max(l1[0], l - l1[len(l1) - 1]) > m / 2:
	print(max(l1[0], l - l1[len(l1) - 1]))
else:
	print(m / 2)


(n, l) = map(int, input().split())
md = 0
p = list(map(int, input().split()))
p.sort()
for i in range(n - 1):
	md = max(md, p[i + 1] - p[i])
md = max(md, p[0] * 2, (l - p[-1]) * 2)
print(md / 2)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
maxdist = 0
for i in range(1, n):
	if arr[i] - arr[i - 1] > maxdist:
		maxdist = arr[i] - arr[i - 1]
ans1 = max(arr[0] - 0, l - arr[n - 1])
ans2 = maxdist / 2.0
print(max(ans1, float(ans2)))


(n, l) = (int(x) for x in input().split())
positions = [int(x) for x in input().split()]
positions.sort()
dst = [0]
for i in range(1, len(positions)):
	dst.append(positions[i] - positions[i - 1])
print(max(max(dst) / 2, l - max(positions), min(positions)))


(n, l) = map(int, input().split())
f = list(map(int, input().split()))
f.sort()
max_dist = 0
if 1 <= n <= 1000 and 1 <= l <= 10 ** 9 and (len(f) == n):
	for i in range(len(f)):
		if f[i] - f[i - 1] > max_dist:
			max_dist = f[i] - f[i - 1]
	d = max(max_dist / 2, max(f[0] - 0, l - f[n - 1]))
print(d)


n = input().split()
num = int(n[0])
length = int(n[1])
light = input().split()
l = []
flag = 0
flag1 = 0
for i in range(num):
	l.append(int(light[i]))
l.sort()
ans = 0
if int(light[0]) != 0:
	flag = 1
if l[i] != length:
	flag1 = 1
for i in range(0, num - 1):
	ans = max(ans, l[i + 1] - l[i])
print(max(round(ans / 2, 9), max(l[0], length - l[num - 1])))


def solve(n, l, arr):
	arr.sort()
	arr.append(l)
	arr.insert(0, 0)
	diff = 0
	for i in range(1, n + 1):
		if arr[i] - arr[i - 1] > diff:
			diff = arr[i] - arr[i - 1]
	if arr[1] - arr[0] > diff / 2:
		diff = 2 * (arr[1] - arr[0])
	if arr[-1] - arr[-2] > diff / 2:
		diff = 2 * (arr[-1] - arr[-2])
	diff /= 2
	return '{0:.10f}'.format(diff)
(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
print(solve(n, l, arr))


(n, l) = (int(x) for x in input().split())
a = list((int(x) for x in input().split()))
a.sort()
d = 0
for i in range(n - 1):
	d = max(d, (a[i + 1] - a[i]) / 2)
if 0 not in a or l not in a:
	d = max(d, a[0], l - a[-1])
print('{0:.10f}'.format(d))


def main():
	(n, l) = list(map(int, input().split()))
	n_list = list(map(int, input().split()))
	n_list = sorted(n_list)
	mi = max(n_list[0] - 0, l - n_list[-1])
	for index in range(len(n_list) - 1):
		if (n_list[index + 1] - n_list[index]) / 2 > mi:
			mi = (n_list[index + 1] - n_list[index]) / 2
	print(mi)
main()


def merge(lst1, lst2):
	i = 0
	j = 0
	arr = []
	while i < len(lst1) and j < len(lst2):
		if lst1[i] < lst2[j]:
			arr.append(lst1[i])
			i += 1
		else:
			arr.append(lst2[j])
			j += 1
	while i < len(lst1):
		arr.append(lst1[i])
		i += 1
	while j < len(lst2):
		arr.append(lst2[j])
		j += 1
	return arr

def mergeSort(lst):
	if len(lst) <= 1:
		return lst
	mid = int(len(lst) / 2)
	left = mergeSort(lst[0:mid])
	right = mergeSort(lst[mid:])
	return merge(left, right)

def maxdiff(lst):
	max = 0
	i = 0
	while i < len(lst) - 1:
		diff = lst[i + 1] - lst[i]
		if diff > max:
			max = diff
		i += 1
	return max
(x, y) = input().split()
x = int(x)
y = int(y)
lst = list(map(int, input().split()))
lst = mergeSort(lst)
maxdiff = maxdiff(lst)
last = len(lst) - 1
zeroCounter = lst[0]
lengthCounter = y - lst[last]
maximum = maxdiff / 2
if maximum < zeroCounter:
	maximum = zeroCounter
if maximum < lengthCounter:
	maximum = lengthCounter
print(maximum)


__author__ = 'Ekaterina'
from decimal import Decimal
(n, l) = (int(m) for m in input().split())
l = Decimal(l)
lights = [Decimal(light) for light in input().split()]
lights.sort()
d = lights[0]
for i in range(n - 1):
	if (lights[i + 1] - lights[i]) / Decimal(2) > d:
		d = (lights[i + 1] - lights[i]) / Decimal(2)
if l - lights[-1] > d:
	d = l - lights[-1]
	print(d)
else:
	print(d)


(n, l) = map(int, input().split())
arr = sorted(map(int, input().split()))
res = max(arr[0], l - arr[-1])
from math import inf
for i in range(1, len(arr)):
	res = max(res, (arr[i] - arr[i - 1]) / 2)
print(res)


(n, k) = map(int, input().split(' '))
lanterns = list(map(int, input().split(' ')))
lanterns.sort()
god = 0
for i in range(1, len(lanterns)):
	god = max(lanterns[i] - lanterns[i - 1], god)
nxt = k - lanterns[-1]
nxt2 = lanterns[0]
print(max(nxt, nxt2, god / 2))


import math
x = [int(x) for x in input().split()]
y = [int(x) for x in input().split()]
y.sort()
yolo = []
for i in range(x[0] - 1):
	yolo.append(abs(y[i] - y[i + 1]) / 2)
yolo.sort()
if len(y) == 1:
	print(float(max(y[0], x[1] - y[x[0] - 1])))
else:
	print(float(max(yolo[x[0] - 2], y[0], x[1] - y[x[0] - 1])))


(light_count, street_len) = [int(x) for x in input().split()]
lights = set([int(x) for x in input().split()])
lights = list(lights)
lights.sort()

def count_distance(x):
	try:
		the_next_number = lights[lights.index(x) + 1]
	except:
		return 0
	return the_next_number - x
distances = list(map(count_distance, lights))
if 0 not in lights:
	distances.append((lights[0] - 0) * 2)
else:
	pass
if street_len not in lights:
	distances.append((street_len - lights[-1]) * 2)
else:
	pass
max_distant = max(distances)
print('{:.10f}'.format(max_distant / 2))


def get_light_radius(light_positions, street_length):
	light_positions.sort()
	current_light_radius = max(light_positions[0], street_length - light_positions[-1])
	for index in range(0, len(light_positions) - 1):
		first_light_position = light_positions[index]
		second_light_position = light_positions[index + 1]
		distance_lights = second_light_position - first_light_position
		if 2 * current_light_radius < distance_lights:
			current_light_radius = distance_lights / 2
	return current_light_radius

def solve():
	line = input()
	street_length = int(line.split()[1])
	line = input()
	light_positions = [int(num) for num in line.split()]
	radius = get_light_radius(light_positions, street_length)
	print(radius)
solve()


(num_of_lights, length_of_street) = list(map(int, input().split()))
locations = list(map(int, input().split()))
locations.sort()
distance = []
distance.append(locations[0])
distance.append(length_of_street - locations[num_of_lights - 1])
for i in range(num_of_lights - 1):
	distance.append((locations[i + 1] - locations[i]) / 2)
print('{0:.10f}'.format(max(distance)))


(n, l) = [int(n) for n in input().split()]
arr = list(map(int, input().strip().split()))[:n]
s = sorted(arr)
d = 0
for i in range(n - 1):
	f = s[i + 1] - s[i]
	if f >= d:
		d = f
	else:
		pass
g = d / 2
h = l - s[n - 1]
if s[0] == 0 and s[n - 1] == l:
	print(g)
elif s[0] > g and s[0] >= h:
	print(s[0])
elif h > g and h >= s[0]:
	print(h)
else:
	print(g)


def find_min_diameter(postions, stop):
	postions = sorted(list(set(postions)))
	curr_max = 0
	for i in range(len(postions) - 1):
		if postions[i + 1] > stop:
			break
		if (postions[i + 1] - postions[i]) / 2 > curr_max:
			curr_max = (postions[i + 1] - postions[i]) / 2
	return max(postions[0], stop - postions[-1], curr_max)
(num_of_lamp, len_street) = list(map(int, input().split()))
pos_array = list(map(int, input().split()))
print(find_min_diameter(pos_array, len_street))


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
if n == 1:
	M = max(arr[0] - 0, l - arr[0])
	print(M)
else:
	arr1 = []
	for i in range(1, n):
		arr1.append(arr[i] - arr[i - 1])
	m = max(arr1)
	M = max(arr[0] - 0, m / 2, l - arr[n - 1])
	print(M)


import sys
(n, l) = map(int, input().split())
k = []
s = sorted(list(map(int, input().split())))
if n == 1:
	p = max(s[0] - 0, l - s[-1])
	print('%.10f' % p)
	sys.exit(0)
for i in range(n - 1):
	k.append((s[i + 1] - s[i]) / 2)
p = max(max(k), max(s[0] - 0, l - s[-1]))
print('%.10f' % p)


(n, l) = [int(x) for x in input().split()]
lanterns = [int(x) for x in input().split()]
lanterns = sorted(lanterns)
maxDistance = 0
for i in range(1, n):
	if maxDistance < lanterns[i] - lanterns[i - 1]:
		maxDistance = lanterns[i] - lanterns[i - 1]
d = maxDistance / 2
if d < lanterns[0]:
	d = lanterns[0]
if d < l - lanterns[n - 1]:
	d = l - lanterns[n - 1]
print(d)


(n, l) = map(int, input().split())
l1 = [int(l1) for l1 in input().split()]
l1.sort()
z = 0
k = []
if len(l1) != 1:
	for i in range(n - 1):
		k.append(l1[i + 1] - l1[i])
else:
	k.append(l1[0])
p = l
if 0 not in l1 or p not in l1:
	j = max(k) / 2
	if l1[0] > j or l - l1[n - 1] > j:
		print(max(l1[0], l - l1[n - 1]))
	else:
		print(j)
else:
	print(max(k) / 2)


firstLine = list(map(int, input().split()))
n = firstLine[0]
l = firstLine[1]
a = list(map(int, input().split()))
e = a.copy()
e.sort()
max = e[0]
if l - e[n - 1] > max:
	max = l - e[n - 1]
for i in range(n - 1):
	if (e[i + 1] - e[i]) / 2 > max:
		max = abs(e[i + 1] - e[i]) / 2
print(max)


(lantern_number, street_length) = (int(x) for x in input().split())
lantern_locations = [0]
lantern_locations.extend(sorted([int(x) for x in input().split()]))
lantern_locations.append(street_length)
lantern_locations[0] -= lantern_locations[1]
lantern_locations[-1] += lantern_locations[-1] - lantern_locations[-2]
d = []
for i in range(1, lantern_number + 2):
	d.append(lantern_locations[i] - lantern_locations[i - 1])
print(max(d) / 2)


def fun():
	(p, q) = input().split()
	arr = input().split()
	arr = [int(i) for i in arr]
	arr.sort()
	p = int(p)
	q = int(q)
	if p == 1:
		m = max(arr[0], q - arr[0])
		print('%.10f' % m)
	else:
		arr2 = [0] * (p - 1)
		for i in range(p - 2, -1, -1):
			arr2[i] = arr[i + 1] - arr[i]
			m = max(max(arr2) / 2, max(arr[0], q - arr[p - 1]))
		print('%.10f' % m)
fun()


(n, l) = map(int, input().split())
lantern = [int(x) for x in input().split()]
lantern.sort()
dmax = 0
for i in range(len(lantern) - 1):
	if lantern[i + 1] - lantern[i] > dmax:
		dmax = lantern[i + 1] - lantern[i]
dmax = max(lantern[0], l - lantern[n - 1], dmax / 2)
print('{:.10f}'.format(dmax))


[n, l] = [int(it) for it in input().split(' ')]
lanterns = [int(it) for it in input().split(' ')]
max_distance = 0
lanterns.sort()
for i in range(0, n - 1):
	max_distance = max(max_distance, abs(lanterns[i] - lanterns[i + 1]))
d = max(max(max_distance / 2, abs(l - lanterns[len(lanterns) - 1])), max(max_distance / 2, abs(0 - lanterns[0])))
print(d)


(n, l) = [int(k) for k in input().split()]
s = [int(k) for k in input().split()]
s.sort()
res = max(s[0], l - s[-1])
for i in range(1, n):
	res = max((s[i] - s[i - 1]) / 2, res)
print(res)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
fasele = 0
a.sort()
for i in range(1, n):
	fasele = max(a[i] - a[i - 1], fasele)
fasele = fasele / 2
fasele = max(fasele, a[0], l - a[-1])
fasele = fasele + 1e-11
fasele = format(fasele, '.9f')
print(fasele)


from math import inf
(n, l) = [int(x) for x in input().split()]
lanterns = [float(x) for x in input().split()]
lanterns.sort()
maxlen = -inf
for i in range(n - 1):
	d = lanterns[i + 1] - lanterns[i]
	if d > maxlen:
		maxlen = d
if lanterns[0] > maxlen / 2:
	if l - lanterns[-1] > lanterns[0]:
		print(l - lanterns[-1])
	else:
		print(lanterns[0])
elif l - lanterns[-1] > maxlen / 2:
	print(l - lanterns[-1])
else:
	print(maxlen / 2)


(n, l) = map(int, input().split())
lanterns = [int(x) for x in input().split()]
lanterns.sort()
le = len(lanterns)
ma = lanterns[0]
for i in range(1, le):
	ma = max(ma, (lanterns[i] - lanterns[i - 1]) / 2)
print(max(ma, l - lanterns[-1]))


nl = list(map(int, input().rstrip().split()))
(n, l) = nl
a = list(map(int, input().rstrip().split()))
a.sort()
diff = 0
for i in range(n - 1):
	d = a[i + 1] - a[i]
	if d > diff:
		diff = d
maxi = diff / 2
a_begin = a[0]
a_end = a[n - 1]
street = l - a_end
answer = max(maxi, a_begin, street)
print('%.10f' % answer)


(a, b) = map(int, input().split())
lista = list(set(map(int, input().split())))
lista.sort()
mayor = lista[0]
for i in range(len(lista) - 1):
	c = (lista[i + 1] - lista[i]) / 2
	if c > mayor:
		mayor = c
c = max(mayor, b - lista[len(lista) - 1])
print(round(c, 10))


i = input
(n, l) = map(int, i().split())
a = list(map(int, i().split()))
a.sort()
if a[0] != 0:
	a.insert(0, -a[0])
a.append(l + (l - a[-1]))
d = 0
for i in range(len(a) - 1):
	tmp = a[i + 1] - a[i]
	if d < tmp:
		d = tmp
print(d / 2)


from math import *
lst = input().split()
(n, l) = (lst[0], lst[1])
s = input().split()
ss = [int(i) for i in s]
ss.sort()
maxi = 0
for i in range(len(ss) - 1):
	maxi = max(maxi, ss[i + 1] - ss[i])
maxi = max(maxi / 2, ss[0])
print(max(maxi, int(l) - ss[len(s) - 1]))


(n, l) = map(int, input().split())
a = list(map(int, input().strip().split()))
maximum = 0
maximum_1 = 0
a.sort()

def BinarySearch(start, end, val, a):
	if start == end:
		if val == a[start]:
			return True
		else:
			return False
	else:
		mid = int((start + end) / 2)
		if val < a[mid]:
			BinarySearch(start, mid, val, a)
		if val > a[mid]:
			BinarySearch(mid + 1, end, val, a)
		if val == a[mid]:
			return True
b = BinarySearch(0, n - 1, 0, a)
if b == True:
	if len(a) > 1:
		maximum = abs(a[0] - a[1]) / 2
	else:
		maximum = abs(a[0]) / 2
else:
	maximum = abs(a[0])
b = BinarySearch(0, n - 1, l, a)
if b == True:
	maximum_1 = abs(a[n - 1] - a[n - 2]) / 2
else:
	maximum_1 = abs(a[n - 1] - l)
maximum_2 = max(maximum, maximum_1)
for i in range(0, n - 1):
	if maximum_2 < abs(a[i] - a[i + 1]) / 2:
		maximum_2 = abs(a[i] - a[i + 1]) / 2
print(maximum_2)


(n, l) = map(int, input().split())
sh = sorted(map(int, input().split()))
ans = 0
for i in range(1, n):
	t = (sh[i] - sh[i - 1]) / 2
	if t > ans:
		ans = t
if sh[0] != 0 and sh[0] > ans:
	ans = sh[0]
if sh[-1] != l and l - sh[-1] > ans:
	ans = l - sh[-1]
print(ans)


(n, l) = [int(i) for i in input().split()]
lanterns = sorted([int(i) for i in input().split()])
res = lanterns[0] - 0
for i in range(1, n):
	aux = (lanterns[i] - lanterns[i - 1]) / 2
	if aux > res:
		res = aux
aux = l - lanterns[n - 1]
if aux > res:
	res = aux
print(str(res))


(n, l) = list(map(int, input().split()))
co = list(map(int, input().split()))
co.sort()
b = 0
for ind in range(n - 1):
	if (co[ind + 1] - co[ind]) / 2 > b:
		b = (co[ind + 1] - co[ind]) / 2
if 0 not in co:
	if b < min(co):
		b = min(co)
if l not in co:
	if b < l - max(co):
		b = l - max(co)
print(b)


(n, m) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
ma = 0
for i in range(n - 1):
	var = arr[i + 1] - arr[i]
	if var > ma:
		ma = var
m1 = max(ma / 2, max(arr[0] - 0, m - arr[n - 1]))
print(format(m1, '.10f'))


(n, l) = map(int, input().split())
m = [int(i) for i in input().split()]
m.sort()
s = []
for i in range(1, len(m)):
	s.append(m[i] - m[i - 1])
if n == 1:
	print(max(l - m[0], abs(0 - m[0])))
else:
	t1 = l - m[len(m) - 1]
	t2 = m[0] - 0
	print(max(max(s) / 2, t1, t2))


def rex():
	s = input().split(' ')
	n = int(s[0])
	l = int(s[1])
	x = input().split(' ')
	for i in range(n):
		x[i] = int(x[i])
	x = sorted(x)
	ref = max(x[0], l - x[n - 1])
	for i in range(1, n):
		temp = (x[i] - x[i - 1]) / 2
		if ref < temp:
			ref = temp
	return ref
print(rex())


(n, l) = [int(x) for x in input().split()]
s = [int(x) for x in input().split()]
s.sort()
p = []
if n > 1:
	for i in range(1, n):
		p.append(s[i] - s[i - 1])
	print(max(s[0], l - s[n - 1], max(p) / 2))
else:
	print(max(s[0], l - s[0]))


(n, l) = tuple(map(int, input().split()))
l1 = list(map(int, input().split()))
l1.sort()
ma = 0
if l1[0] != 0:
	ma = l1[0] * 2
if l1[n - 1] != l and (l - l1[n - 1]) * 2 > ma:
	ma = (l - l1[n - 1]) * 2
for i in range(1, n):
	if l1[i] - l1[i - 1] > ma:
		ma = l1[i] - l1[i - 1]
		inde = i
print('{:.10f}'.format(ma / 2))


(n, k) = map(int, input().split())
list1 = list(map(int, input().split()))
list1.sort()
max1 = 0
for i in range(1, len(list1)):
	if abs(list1[i - 1] - list1[i]) > max1:
		max1 = abs(list1[i - 1] - list1[i]) + 0
max1 = max1 / 2
p = list1[0] - 0
q = k - list1[n - 1]
ans = max(max1, p, q)
print(ans)


(a, b) = input().strip().split()
a = int(a)
b = int(b)
diff = 0
l = list(map(int, input().split()))
l = sorted(l)
for i in range(1, len(l)):
	if l[i] - l[i - 1] > diff:
		diff = l[i] - l[i - 1]
q = min(l)
e = b - max(l)
this = max(q, e)
print('{0:.15f}'.format(max(this, diff / 2)))


(n, l) = map(int, input().split())
lanterns = list(map(int, input().split()))
lanterns.sort()
max_dist = 0
for i in range(len(lanterns) - 1):
	loc = lanterns[i + 1] - lanterns[i]
	if loc > max_dist:
		max_dist = loc
d = max_dist / 2
s = max(lanterns[0], l - lanterns[len(lanterns) - 1])
if s > d:
	d = s
print(d)


(n, l) = input().split()
temp = input().split()
a = []
for i in range(int(n)):
	a.append(int(temp[i]))
a = sorted(a)
max_length = a[0]
for i in range(len(a) - 1):
	if (a[i + 1] - a[i]) / 2 > max_length:
		max_length = (a[i + 1] - a[i]) / 2
if max_length < int(l) - a[len(a) - 1]:
	print(int(l) - a[len(a) - 1])
else:
	print(max_length)


(light_num, len_street) = map(int, input().split())
lights = sorted(list(map(int, input().split())))
lights.insert(0, lights[0] - lights[0] - lights[0])
lights.append(len_street - lights[-1] + (len_street - lights[-1]) + lights[-1])
counter = 0
radius = 0
for light in lights[1:]:
	radius = max(radius, (light - lights[counter]) / 2)
	counter += 1
print(radius)


(n, m) = map(int, input().split())
list1 = list(map(int, input().split()))
list1.sort()
dd = 0
for i in range(1, n):
	d = list1[i] - list1[i - 1]
	if d > dd:
		dd = d
dd = dd / 2
dd = max(dd, list1[0] - 0, m - list1[-1])
print(dd)


from math import *
from decimal import getcontext, Decimal
getcontext().prec = 9
(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
count = 0
for i in range(1, n):
	dif = a[i] - a[i - 1]
	count = max(count, dif)
print(Decimal(max(float(count / 2), float(a[0] - 0), float(l - a[n - 1]))))


(n, l) = list(map(int, input().split()))
lt = list(map(int, input().split()))
lt.sort()
length = len(lt)
d = float(lt[0])
for i in range(length - 1):
	if lt[i + 1] - lt[i] > d * 2:
		d = (lt[i + 1] - lt[i]) / 2
if l - lt[length - 1] > d:
	d = l - lt[length - 1]
print('%.10f' % d)


(a, b) = map(int, input().split())
lantern = list(map(int, input().split()))
lantern.sort()
radius = []
for i in range(1, a):
	radius.append(0.5 * (lantern[i] - lantern[i - 1]))
radius.append(lantern[0])
radius.append(b - lantern[-1])
print('%.10f' % max(radius))


import sys
import io
import os
total = 0
failed = 0

def debug(*args):
	if 'LOCALTEST' in os.environ:
		print(*args, file=sys.stderr)

def run(test, res):
	x = io.StringIO()
	with io.StringIO(test) as sys.stdin:
		with x as sys.stdout:
			work()
			z = x.getvalue().strip()
	sys.stdout = sys.__stdout__
	print('Passed?', z == res)
	print('Expected: ', res)
	print('Actual  : ', z)
	global total, failed
	total += 1
	failed += 1 if z != res else 0

def work():
	(n, l) = map(int, input().split())
	f = list(map(int, input().split()))
	f.sort()
	debug(f)
	z = 0.0 + max(f[0], l - f[n - 1 if n > 1 else 0])
	for i in range(n - 1):
		z = max(z, (f[i + 1] - f[i]) / 2)
	print(z)

def test():
	run('1 1\n1', '1')
	run('2 555\n200 300', '255')
	run('7 15\n15 5 3 7 9 14 0', '2.5000000000')
	run('2 5\n2 5', '2.0000000000')
if 'LOCALTEST' in os.environ:
	test()
	print('\n Result: %s (%d total, %d failed)' % ('FAILED' if failed > 0 else 'PASSED', total, failed))
else:
	work()


(n, l) = map(int, input().split())
lst = sorted(list(map(int, input().split())))
lst2 = list(lst)
lst2.append(0)
lst2.append(l)
lst2 = sorted(lst2)
q = []
if 0 in lst and l in lst:
	for i in range(len(lst2)):
		try:
			q.append(lst2[i + 1] - lst2[i])
		except IndexError:
			pass
if 0 not in lst or l not in lst:
	for i in range(len(lst)):
		if i > 0:
			q.append(lst[i] - lst[i - 1])
	q.append(2 * lst[0])
	q.append(2 * (l - lst[-1]))
print(max(q) / 2)


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
arr = inlt()
lamps = inlt()
lamps.sort()
(N, L) = (arr[0], arr[1])
dist = 0
dist = max(dist, lamps[0])
dist = max(dist, L - lamps[-1])
prev = lamps[0]
for i in range(1, N):
	dist = max(dist, (lamps[i] - prev) / 2)
	prev = lamps[i]
print(dist)


import math
from collections import defaultdict, Counter, deque
INF = float('inf')

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def isPrime(n):
	if n <= 1:
		return False
	i = 2
	while i ** 2 <= n:
		if n % i == 0:
			return False
		i += 1
	return True

def primeFactor(n):
	if n % 2 == 0:
		return 2
	i = 3
	while i ** 2 <= n:
		if n % i == 0:
			return i
		i += 1
	return n

def vars():
	return map(int, input().split())

def array():
	return list(map(int, input().split()))

def main():
	(n, d) = vars()
	arr = array()
	arr.insert(0, 0)
	arr.append(d)
	arr.sort()
	max_diff = 0
	s = arr[1] - arr[0]
	l = arr[-1] - arr[-2]
	for i in range(1, len(arr)):
		max_diff = max(max_diff, arr[i] - arr[i - 1])
	print(max(s, max_diff / 2, l))
t = 1
for _ in range(t):
	main()


a = [int(x) for x in input().split(' ')]
b = [int(x) for x in input().split(' ')]
c = []
b.sort()
for i in range(a[0] - 1):
	c.append((b[i + 1] - b[i]) / 2)
c.sort()
c.append(a[1] - max(b))
c.append(min(b))
c.sort()
print(max(c))


(n, l) = map(int, input().split())
ls = []
l1 = sorted(list(map(int, input().split())))
if len(l1) < 2:
	ls.extend(l1)
else:
	for i in range(1, n):
		ls.append(l1[i] - l1[i - 1])
		if len(l1) < 2:
			ls.extend(l1)
print(max(max(ls) / 2, max(l1[0] - 0, l - l1[n - 1])))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
b = 0
c = []
a.sort()
for i in range(n):
	b = a[i] - a[i - 1]
	c.append(b)
x = max(c)
j = l - max(a)
k = x / 2
l = min(a)
m = max(j, k, l)
print('%.10f' % m)


(n, l) = map(int, input().split())
v = [int(x) for x in input().split()]
v.sort()
max_dist = -1
for i in range(n - 1):
	max_dist = max(max_dist, abs(v[i] - v[i + 1]))
min_radius = max(max_dist / 2, v[0], l - v[-1])
print(min_radius)


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
max_gap = 0
for i in range(n - 1):
	temp = arr[i + 1] - arr[i]
	max_gap = max(max_gap, temp)
if 0 not in arr or l not in arr:
	m1 = max(max_gap / 2, arr[0])
	m2 = max(max_gap / 2, l - arr[-1])
	print(max(m1, m2))
else:
	print(max_gap / 2)


(n, k) = map(int, input().split())
a = list(sorted(map(int, input().split())))
md = 0
for i in range(1, n):
	md = max(md, a[i] - a[i - 1])
print('%.10f' % max(a[0], md / 2, k - a[-1]))


import math
(n, l) = [int(y) for y in input().split()]
a = [int(y) for y in input().split()]
mx = -1
a.sort()
for i in range(n - 1):
	if a[i + 1] - a[i] > mx:
		mx = a[i + 1] - a[i]
if mx / 2 - mx // 2 > 0.999999999:
	print(max(math.ceil(mx / 2), a[0], l - a[-1]))
else:
	print(max(mx / 2, a[0], l - a[-1]))


n = input()
n = n.split()
for i in range(len(n)):
	n[i] = int(n[i])
s = input()
s = s.split()
mylist = []
for i in range(len(s)):
	s[i] = int(s[i])
s.sort()
if 0 not in s:
	mylist.append(s[0])
if n[1] not in s:
	mylist.append(n[1] - s[len(s) - 1])
for i in range(len(s)):
	if i == len(s) - 1:
		break
	else:
		j = (s[i + 1] - s[i]) / 2
		mylist.append(j)
mylist.sort()
print(mylist[len(mylist) - 1])


x = list(map(int, input().split(' ')))
y = list(map(int, input().split(' ')))
st = []
y.sort()
for i in range(len(y) - 1):
	st.append(y[i + 1] - y[i])
start = y[0]
end = x[1] - y[len(y) - 1]
m = max(start, end)
if len(y) != 1:
	ms = max((x for x in st))
	mm = max(ms / 2, m)
else:
	mm = m
print('%.10f' % mm)


(n, l) = map(int, input().split())
s = list(map(int, input().split()))
d1 = min(s)
d2 = l - max(s)
s.sort()
d3_list = []
if n == 1:
	print('%.10f' % max(d1, d2))
else:
	for i in range(1, n):
		d3 = s[i] - s[i - 1]
		d3_list.append(d3)
	d3 = max(d3_list) / 2
	print('%.10f' % max(d1, d2, d3))


(n, l) = map(int, input().split())
lights_points = list(map(int, input().split()))
lights_points.sort(reverse=False)
distances = []
for light in lights_points:
	if light != lights_points[-1]:
		p = lights_points.index(light)
		d = lights_points[p + 1] - light
		distances.append(d)
	else:
		break
distances.append(2 * lights_points[0])
distances.append(2 * (l - lights_points[-1]))
print(max(distances) / 2)


n = input()
m = [int(i) for i in n.split()]
l = int(m[1])
s = input()
t = [0] + [int(i) for i in s.split()] + [l]
t.sort()
ans = t[1] - t[0]
for i in range(1, len(t)):
	if (t[i] - t[i - 1]) / 2 > ans:
		ans = (t[i] - t[i - 1]) / 2
if t[len(t) - 1] - t[len(t) - 2] > ans:
	ans = t[len(t) - 1] - t[len(t) - 2]
print('{0:.10f}'.format(ans))


(n, l) = input().split()
lan = input().split()
n = int(n)
l = int(l)
for h in range(len(lan)):
	lan[h] = float(lan[h])
lan.sort()
ans = 0
if lan[0] - 0 > ans:
	ans = lan[0] - 0
if l - lan[n - 1] > ans:
	ans = l - lan[n - 1]
for i in range(1, n):
	if (lan[i] - lan[i - 1]) / 2 > ans:
		ans = (lan[i] - lan[i - 1]) / 2
print(ans)


(n, l) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
ds = min(a)
de = l - max(a)
if n == 1:
	t = [ds, de]
else:
	d = []
	for i in range(n - 1):
		d.append(a[i + 1] - a[i])
	t = [ds, de, max(d) / 2]
print(max(t))


(n, l) = input().split()
lnts = [float(i) for i in input().split()]
distmax = -1.0
lnts.sort()
for i in range(1, len(lnts)):
	distmax = max(distmax, (lnts[i] - lnts[i - 1]) / 2)
print(max(max(lnts[0] - 0.0, float(l) - lnts[len(lnts) - 1]), distmax))


(n, l) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
maxi = -1
st_max = 0
ed_max = 0
if arr[0] != 0:
	st_max = arr[0]
if arr[-1] != l:
	ed_max = l - arr[-1]
for i in range(len(arr) - 1):
	if maxi < (arr[i + 1] - arr[i]) / 2:
		maxi = (arr[i + 1] - arr[i]) / 2
print(max(maxi, st_max, ed_max))


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
if n == 1:
	print(max(a[0], l - a[0]))
	exit()
max_between = max([(a[i + 1] - a[i]) / 2 for i in range(len(a) - 1)])
max_all = max(max_between, a[0], l - a[-1])
print(max_all)


(n, l) = map(int, input().split(' '))
lant = list(map(int, input().split(' ')))
lant.sort()
inter = 0
for i in range(n - 1):
	i = lant[i + 1] - lant[i]
	if i > inter:
		inter = i
inter /= 2
if lant[0] > inter:
	inter = lant[0]
if l - lant[n - 1] > inter:
	inter = l - lant[n - 1]
print(inter)


(n, l) = map(int, input().split())
nl = sorted(list(map(int, input().split())))
le = set()
for i in range(n - 1):
	le.add((nl[i + 1] - nl[i]) / 2)
le.add(nl[0])
le.add(l - nl[-1])
print(max(le))


(n, l) = input().split()
(n, l) = (int(n), int(l))
lamp = [int(i) for i in input().split()]
lamp.sort()
max_diff = 0
left = lamp[0]
right = l - lamp[n - 1]
for i in range(len(lamp) - 1):
	diff = lamp[i + 1] - lamp[i]
	if diff > max_diff:
		max_diff = diff
print(max(max(left, right), max_diff / 2))


def main():
	(n, l) = map(int, input().split())
	arr = list(sorted(map(int, input().split())))
	d = 0
	for i in range(n - 1):
		temp = arr[i + 1] - arr[i]
		d = max(temp, d)
	print(max(d / 2, max(arr[0] - 0, l - arr[-1])))
main()


(_, l) = map(int, input().split())
a = sorted(map(int, input().split()))
print(max([(a2 - a1) / 2 for (a1, a2) in zip(a[:-1], a[1:])] + [a[0], l - a[-1]]))


enel = input().split()
n = int(enel[0])
l = int(enel[1])
lanterns = input().split()
lanterns = [int(x) for x in lanterns]
lanterns.sort()
x = lanterns[0]
y = l - lanterns[-1]
max_dist = 0
for i in range(len(lanterns) - 1):
	if lanterns[i + 1] - lanterns[i] > max_dist:
		max_dist = lanterns[i + 1] - lanterns[i]
d = max(max_dist / 2, max(x, y))
print(d)


(n, m) = map(int, input().split())
l = [int(x) for x in input().split()]
l.sort()
num = len(l)
new = []
for i in range(num):
	if l[0] != 0 and i == 0:
		new.append(l[0] * 2)
	if l[-1] != m and i == num - 1:
		new.append((m - l[-1]) * 2)
	if i != num - 1:
		new.append(l[i + 1] - l[i])
new.sort()
print(new[-1] / 2)


(a, b) = map(int, input().split())
c = [int(i) for i in input().split()]
c.sort()
mi = 0
start = c[0]
fin = b - c[-1]
for i in range(1, len(c)):
	m = c[i] - c[i - 1]
	if m > mi:
		mi = m
if start > mi / 2 or fin > mi / 2:
	if start > fin:
		print(float(start))
	else:
		print(float(fin))
else:
	print(mi / 2)


(lant, ls) = map(int, input().split())
loc = list(map(int, input().split()))
loc.sort()
rad = 0
for i in range(lant - 1):
	if loc[i + 1] - loc[i] > rad:
		rad = loc[i + 1] - loc[i]
if rad / 2 > loc[0] and rad / 2 > ls - loc[-1]:
	print(rad / 2)
else:
	print(max(loc[0], ls - loc[-1]))


def lanterns(l, str1):
	l = int(l.split(' ')[1])
	positions = [int(i) for i in str1.split(' ')]
	p = sorted(positions)
	min_ = p[0]
	if min_ < l - p[-1]:
		min_ = l - p[-1]
	for i in range(len(p) - 1):
		if min_ < (p[i + 1] - p[i]) / 2:
			min_ = (p[i + 1] - p[i]) / 2
	return min_
print(lanterns(input(), input()))


(n, s) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
maxDistance = max(a[0], s - a[-1])
for i in range(1, n):
	if a[i] != a[i - 1] and (a[i] - a[i - 1]) / 2 > maxDistance:
		maxDistance = (a[i] - a[i - 1]) / 2
print(maxDistance)


def main():
	(n, l) = map(int, input().split())
	a = map(int, input().split())
	a = list(a)
	a.sort()
	max_d = 0
	for (a0, a1) in zip(a[:-1], a[1:]):
		if a1 - a0 > max_d:
			max_d = a1 - a0
	max_d = max_d / 2
	if a[0] > max_d:
		max_d = a[0]
	if l - a[-1] > max_d:
		max_d = l - a[-1]
	print(max_d)
main()


import math
(n, l) = map(int, input().split())
maxi = 0
li = list(map(int, input().split()))
li = sorted(li)
for i in range(1, n):
	maxi = max(maxi, li[i] - li[i - 1])
print(max(maxi / 2, max(li[0], l - li[n - 1])))


(n, l) = [int(x) for x in input().split()]
cdn = list(map(int, input().split()))
cdn.sort()
num = [cdn[0]]
for i in range(1, len(cdn)):
	d = (cdn[i] - cdn[i - 1]) / 2
	num.append(d)
num.append(l - cdn[-1])
s = max(num)
print('%.10f' % s)


import typing
import math

def ri(*args) -> typing.Iterator:
	(func, funcs) = (int, (int, float, str))
	sep = ' '
	for a in args:
		if a in funcs:
			func = a
		elif isinstance(a, str):
			sep = a
	return map(func, input().strip().split(sep))

def main():
	(n, l) = ri()
	xs = sorted(ri())
	min_d = 0
	min_d = max(min_d, xs[0])
	min_d = max(min_d, l - xs[-1])
	for i in range(1, len(xs)):
		min_d = max(min_d, (xs[i] - xs[i - 1]) / 2)
	print(min_d)
main()


((l, s), p) = (list(map(int, input().split())), sorted(list(map(int, input().split()))))
p = [-p[0]] + p + [s * 2 - p[-1]]
print(max([y - x for (x, y) in zip(p[:-1], p[1:])]) / 2)


(n, l) = map(int, input().strip().split(' '))
lanterns = [int(n) for n in input().split(' ')]

def solution(lanterns):
	differences = []
	for i in range(len(lanterns) - 1):
		element = lanterns[i + 1] - lanterns[i]
		differences.append(element)
	return differences
lanterns = sorted(lanterns)
if lanterns[0] != 0 and lanterns[-1] != l:
	lanterns.insert(0, 0)
	lanterns.append(l)
	differences = solution(lanterns)
	d1 = differences[0]
	d2 = differences[-1]
	Dif = sorted(differences)
	if d1 >= d2 and d1 > Dif[-1] / 2:
		print(d1)
	elif d2 >= d1 and d2 > Dif[-1] / 2:
		print(d2)
	else:
		print(Dif[-1] / 2)
elif lanterns[0] == 0 and lanterns[-1] != l:
	lanterns.append(l)
	differences = solution(lanterns)
	d3 = differences[-1]
	Dif = sorted(differences)
	if d3 > Dif[-1] / 2:
		print(d3)
	else:
		print(Dif[-1] / 2)
elif lanterns[0] != 0 and lanterns[-1] == l:
	lanterns.insert(0, 0)
	differences = solution(lanterns)
	d4 = differences[0]
	Dif = sorted(differences)
	if d4 > Dif[-1] / 2:
		print(d4)
	else:
		print(Dif[-1] / 2)
elif lanterns[0] == 0 and lanterns[-1] == l:
	differences = solution(lanterns)
	Dif = sorted(differences)
	print(Dif[-1] / 2)
else:
	sys.exit


(n, l) = map(int, input().split())
lant = sorted(list(map(int, input().split())))
x = lant[0]
y = l - lant[len(lant) - 1]
max_dist = 0
for i in range(len(lant)):
	j = i + 1
	if j == len(lant):
		break
	if lant[i] + max_dist < lant[j] - max_dist:
		max_dist = (lant[j] - lant[i]) / 2
print('%.10f' % max(x, y, max_dist))


from functools import reduce
(n, l) = map(int, input().split())
li = [int(x) for x in input().split()]
li.sort()
ans = 0
for i in range(1, len(li)):
	ans = max(ans, (li[i] - li[i - 1]) / 2)
print(max(ans, li[0], l - li[-1]))


s = input().split(' ')
(n, l) = (int(s[0]), float(s[1]))
a = [float(k) for k in input().split(' ')]
a.sort()
mind = 0.0
for i in range(1, n):
	mind = max(mind, (a[i] - a[i - 1]) / 2)
mind = max(mind, a[0], l - a[n - 1])
print(mind)


l = int(input().split()[1])
t = sorted(list(map(int, input().split())))
mini = 0
for x in range(1, len(t)):
	if mini < t[x] - t[x - 1]:
		mini = t[x] - t[x - 1]
print(max([mini / 2, t[0], l - t[len(t) - 1]]))


(_, length) = [int(x) for x in input().strip().split()]
point_list = sorted(set((int(x) for x in input().strip().split())))
dis_list = []
for x in range(len(point_list) - 1):
	dis_list.append(point_list[x + 1] - point_list[x])
print(max(point_list[0], length - point_list[-1]) if not dis_list else max(max(dis_list) / 2, point_list[0], length - point_list[-1]))


(N, l) = [int(i) for i in input().strip().split()]
lights = [int(i) for i in input().strip().split()]
lights.sort()
min_d = max(lights[0], l - lights[N - 1])
for i in range(1, N):
	if min_d * 2 < lights[i] - lights[i - 1]:
		min_d = (lights[i] - lights[i - 1]) / 2
print(min_d)


(n, l) = input().split()
(n, l) = (int(n), int(l))
pos = sorted([int(x) for x in input().split()])
ans = 0
for i in range(1, n):
	if pos[i] - pos[i - 1] > ans:
		ans = pos[i] - pos[i - 1]
print(max(max(ans / 2, pos[0]), l - pos[n - 1]))


(m, n) = [int(x) for x in input().split()]
point = [int(x) for x in input().split()]
point = sorted(point)
list = [point[0], n - point[-1]]
for i in range(m - 1):
	list = list + [(point[i + 1] - point[i]) / 2]
print(max(list))


y = float(input().split()[1])
se = sorted(set(map(float, input().split())))
x = -1
for i in range(1, len(se)):
	x = max(se[i] - se[i - 1], x)
mi = min(se)
ma = max(se)
print(max(x / 2, max(mi - 0, y - ma)))


(n, l) = map(int, input().split())
m = [int(x) for x in input().split()]
m.sort()
SB = 0
for i in range(n - 1):
	if m[i + 1] - m[i] > SB:
		SB = m[i + 1] - m[i]
a = max(l - max(m), min(m))
if SB / 2 > a:
	print(SB / 2)
else:
	print(a)


n = lambda : map(int, input().split())
(a, b) = n()
m = sorted(n())
print(max((r - b for (b, r) in zip([-m[0]] + m, m + [2 * b - m[-1]]))) / 2)


(n, l) = input().split()
n = int(n)
l = int(l)
Ar = []
for x in input().split():
	Ar.append(int(x))
Ar.sort()
Max = Ar[n - 1] - Ar[n - 2]
for i in range(n - 1):
	p = Ar[i + 1] - Ar[i]
	if Max < p:
		Max = p
q1 = Ar[0] - 0
q2 = l - Ar[n - 1]
A = [q1, q2, Max / 2]
print(format(max(A), '.10f'))


(a, b) = map(int, input().split())
c = [int(s) for s in input().split()]
c.sort()
max = max(c[0], b - c[a - 1])
for k in range(1, len(c)):
	if (c[k] - c[k - 1]) / 2 > max:
		max = (c[k] - c[k - 1]) / 2
print(max)


(n, l) = map(int, input().split())
lst = list(map(int, input().split()))
lst.sort()
d = lst[0]
i = 0
while i + 1 < len(lst):
	m = lst[i] + d
	n = lst[i + 1] - d
	if n > m:
		d = (lst[i + 1] - lst[i]) / 2
		i += 1
	else:
		i += 1
if lst[-1] + d < l:
	val = l - lst[-1]
	print(d + abs(val - d))
else:
	print(d)


s = [int(x) for x in input().split()]
m = s[0]
n = s[1]
t = [int(x) for x in input().split()]
t.sort()
a = t[0]
b = n - t[-1]
x = max(a, b)
for i in range(m - 1):
	x = max(x, (t[i + 1] - t[i]) / 2)
print('%.10f' % x)


(amount, length) = map(int, input().split())
data = [int(i) for i in input().split()]
data.sort()
if len(data) == 1:
	print(max(data[0] - 0, length - data[0]))
else:
	sub = []
	for i in range(1, len(data)):
		sub.append(data[i] - data[i - 1])
	left = data[0] - 0
	right = length - data[amount - 1]
	temp = max(left, right)
	print(max(max(sub) / 2, temp))


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
d = 0
Max = -float('inf')
for i in range(0, n - 1):
	d = (a[i + 1] - a[i]) / 2
	if d > Max:
		Max = d
if a[0] != 0 or a[-1] != l:
	ans = [Max, a[0] / 1, (l - a[-1]) / 1]
	print(max(ans))
else:
	print(Max)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
r = [a[0], l - a[-1]]
for i in range(1, len(a)):
	r.append((a[i] - a[i - 1]) / 2)
r.sort()
print(r[-1])


(n, l) = map(int, input().split(' '))
lant = list(map(int, input().split(' ')))
lant.sort()
(pre, larg) = (0, 0)
first = lant[0]
for i in lant:
	x = i - pre
	pre = i
	if x > larg:
		larg = x
last = l - lant[-1]
ans = max(first, last, larg / 2)
print(ans)


(z, x) = map(int, input().split())
c = list(sorted(map(int, input().split())))
v = 0
for i in range(1, z):
	if c[i] - c[i - 1] > v:
		v = c[i] - c[i - 1]
print(max(v / 2, max(c[0], x - c[-1])))


(n, l) = map(int, input().split())
MAX = 0
check = 0
answer = 0
lights = sorted([int(i) for i in input().split()])
for i in range(1, n):
	check = lights[i] - lights[i - 1]
	if check > MAX:
		MAX = check
answer = MAX / 2
if answer < lights[0] - 0:
	answer = lights[0] - 0
if answer < l - lights[len(lights) - 1]:
	answer = l - lights[len(lights) - 1]
print(answer)


a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
b.sort()
d = 0
for i in range(a[0] - 1):
	d = max(b[i + 1] - b[i], d)
print(max(b[0], d / 2, a[1] - b[-1]))


(n, l) = map(int, input().split())
x = list(map(int, input().split()))
x.sort()
maxx = 0
for i in range(n - 1):
	m = x[i + 1] - x[i]
	if m > maxx:
		maxx = m
print(max(maxx / 2, l - x[-1], x[0] - 0))


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
(N, L) = map(int, input().split())
A = [int(x) for x in input().split()]
A = list(set(A))
A.sort()
N = len(A)

def check(r):
	if r < A[0] or r < L - A[N - 1]:
		return False
	for i in range(1, N):
		if A[i] - A[i - 1] > 2 * r:
			return False
	return True
lo = 0
hi = 10 ** 10
for i in range(120):
	m = (lo + hi) / 2
	if check(m):
		hi = m
	else:
		lo = m
print(lo)


(n, l) = map(int, input().split())
a = list(map(int, input().rstrip().split()))
a.sort()
b = []
for _ in range(len(a) - 1):
	b.append(abs(a[_] - a[_ + 1]))
if len(b) == 0:
	print('{0:.10f}'.format(max(a[0], l - a[0])))
else:
	x = max(b) / 2
	if 0 in a and l in a:
		print('{0:.10f}'.format(x))
	elif 0 in a and l not in a:
		if x < l - max(a):
			print('{0:.10f}'.format(l - max(a)))
		else:
			print('{0:.10f}'.format(x))
	elif 0 not in a and n in a:
		if x < min(a):
			print('{0:.10f}'.format(min(a)))
		else:
			print('{0:.10f}'.format(x))
	else:
		print('{0:.10f}'.format(max(x, l - max(a), min(a))))


(n, l) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort()
a.insert(0, 0)
a.append(l)
b = []
b.append(a[1] - a[0])
for i in range(2, len(a) - 1):
	b.append((a[i] - a[i - 1]) / 2)
b.append(a[-1] - a[-2])
print(max(b))


a = input()
num = list(map(int, a.split()))
totalLaterns = num[0]
streetLength = num[1]
b = input()
lanterns = list(map(int, b.split()))
lanterns.sort()
dMax = lanterns[0]
flag = 1
if streetLength - lanterns[totalLaterns - 1] > dMax:
	dMax = streetLength - lanterns[totalLaterns - 1]
	flag = 1
	if lanterns[totalLaterns - 1] == streetLength:
		flag = 0
		dMax = dMax / 2
if lanterns[0] == 0:
	for i in range(1, totalLaterns):
		if (lanterns[i] - lanterns[i - 1]) / 2 > dMax:
			dMax = (lanterns[i] - lanterns[i - 1]) / 2
			flag = 0
else:
	for i in range(2, totalLaterns):
		if (lanterns[i] - lanterns[i - 1]) / 2 > dMax:
			dMax = (lanterns[i] - lanterns[i - 1]) / 2
			flag = 0
print(dMax)


__author__ = 'Rakshak.R.Hegde'
(n, l) = map(int, input().split())
a = sorted(map(int, input().split()))
r = 0.0
for i in range(n - 1):
	r = max(r, (a[i + 1] - a[i]) / 2.0)
r = max(r, a[0], l - a[-1])
print(r)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))[:n]
a.sort()
r = []
if a[n - 1] != k:
	r.append(k - a[n - 1])
if a[0] == 0:
	for i in range(n):
		if i + 1 <= n - 1:
			k = a[i + 1] - a[i]
			re = k / 2
			r.append(re)
	print(max(r))
else:
	r.append(a[0])
	for i in range(1, n):
		if i + 1 <= n - 1:
			k = a[i + 1] - a[i]
			re = k / 2
			r.append(re)
	print(max(r))


(n, l) = map(int, input().split())
lis = []
[lis.append(int(i)) for i in input().split()]
lis.sort()
num = []
num.append((l - lis[n - 1]) * 2)
num.append(lis[0] * 2)
for j in range(len(lis) - 1):
	num.append(lis[j + 1] - lis[j])
print('%.10f' % (max(num) / 2))


(n, l) = [int(x) for x in input().strip().split()]
A = sorted([int(x) for x in input().strip().split()])
max_dist = 0
for i in range(1, len(A)):
	dist = abs(A[i - 1] - A[i])
	if max_dist * 2 < dist:
		max_dist = dist / 2
if A[0] > max_dist:
	max_dist = A[0]
if l - A[-1] > max_dist:
	max_dist = l - A[-1]
print(max_dist)


from collections import *
from bisect import *
from math import *
from heapq import *
from fractions import *
import sys
input = sys.stdin.readline
t = 1

def r(a):
	return a * (a - 1) // 2
while t:
	t -= 1
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	a.sort()
	a.append(k)
	s = a[0]
	ip = 0
	for i in range(n):
		d = abs(a[i] - a[i + 1])
		if d / 2 > s:
			s = d / 2
	s = max(s, abs(k - a[-2]))
	print(s)


def main():
	(n, l) = map(int, input().split())
	a = sorted([int(i) for i in input().split()])
	ans = max(l - a[n - 1], a[0])
	for i in range(n - 1):
		ans = max((a[i + 1] - a[i]) / 2, ans)
	print(ans)
main()


(n, l) = [int(p) for p in input().split()]
arr = sorted([int(p) for p in input().split()])
maxDiff = -float('inf')
for i in range(len(arr) - 1):
	maxDiff = max(maxDiff, (arr[i + 1] - arr[i]) / 2)
maxDiff = max(maxDiff, arr[0] - 0)
maxDiff = max(maxDiff, l - arr[-1])
print(maxDiff)


(n, l) = list(map(int, input().split()))
a = list(map(int, input().rstrip().split()))
a.sort()
if n == 1:
	print(max(a[0], l - a[0]))
	exit()
diff = []
for i in range(1, n):
	diff.append(a[i] - a[i - 1])
d = max(diff)
ans = max(d / 2, a[0], l - a[n - 1])
print(ans)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
mx = -1
for i in range(len(a) - 1):
	if a[i + 1] - a[i] > mx:
		mx = a[i + 1] - a[i]
if mx / 2 > a[0] and mx / 2 > l - a[-1]:
	print(mx / 2)
elif a[0] > mx / 2 and a[0] > l - a[-1]:
	print(a[0])
else:
	print(l - a[-1])


(n, l) = map(int, input().split())
a = list(map(int, input().split()))

def mergesort(alist):
	if len(alist) > 1:
		mid = len(alist) // 2
		lefthalf = alist[:mid]
		righthalf = alist[mid:]
		mergesort(lefthalf)
		mergesort(righthalf)
		i = 0
		j = 0
		k = 0
		while i < len(lefthalf) and j < len(righthalf):
			if lefthalf[i] < righthalf[j]:
				alist[k] = lefthalf[i]
				i = i + 1
			else:
				alist[k] = righthalf[j]
				j = j + 1
			k = k + 1
		while i < len(lefthalf):
			alist[k] = lefthalf[i]
			i = i + 1
			k = k + 1
		while j < len(righthalf):
			alist[k] = righthalf[j]
			j = j + 1
			k = k + 1
mergesort(a)
start = a[0]
end = l - a[-1]
if start >= end:
	d = start
else:
	d = end
for i in range(len(a) - 1):
	diff = (a[i + 1] - a[i]) / 2
	if diff > d:
		d = diff
print(d)


(n, l) = map(int, input().split())
lanterns = list(map(int, input().split()))
lanterns.append(-min(lanterns))
lanterns.append(2 * l - max(lanterns))
lanterns.sort()
best = 0
for index in range(len(lanterns) - 1):
	current = lanterns[index + 1] - lanterns[index]
	if current > best:
		best = current
print(best / 2, end='')


(n, l) = [int(x) for x in input().split(' ')]
lmps = sorted([int(x) for x in input().split(' ')])
d = max(lmps[0], l - lmps[-1])
for i in range(1, n):
	d2 = (lmps[i] - lmps[i - 1]) / 2
	if d2 > d:
		d = d2
print(d)


(n, l) = map(int, input().split())
s = list(map(int, input().split()))
s = sorted(s)
s1 = [s[i + 1] - s[i] for i in range(n - 1)]
s1.append(s[0] * 2)
s1.append((l - s[n - 1]) * 2)
p = max(s1) / 2
print('%.9f' % p)


(n, l) = list(map(int, input().strip().split()))
lan = sorted(set(list(map(int, input().strip().split()))))
if len(lan) == 1:
	print(float(max(lan[0], l - lan[-1])))
else:
	diffs = [lan[i + 1] - lan[i] for i in range(len(lan) - 1)]
	print(float(max(lan[0], l - lan[-1], max(diffs) / 2)))


(n, l) = input().split()
n = int(n)
l = int(l)
street = []
street += [int(i) for i in input().split()]
street.sort()
distance = [street[0]]
for j in range(1, n):
	distance.append((street[j] - street[j - 1]) / 2)
distance.append(l - street[n - 1])
d = float(max(distance))
print('{:.10f}'.format(d))


s = input().split()
l = [int(x) for x in input().split()]
l.sort()
p = []
for i in range(1, len(l)):
	p.append(l[i] - l[i - 1])
p.append(2 * (int(s[1]) - l[-1]))
p.append(2 * (l[0] - 0))
m = max(p) / 2
print('%.10f' % m)


(n, l) = map(int, input().split())
di = list(map(int, input().split()))
di = sorted(di)
maximum = 0
for i in range(n - 1):
	if di[i + 1] - di[i] > maximum:
		maximum = di[i + 1] - di[i]
if float(maximum) / 2 > di[0] and float(maximum) / 2 > l - di[-1]:
	if maximum % 2 == 0:
		print(maximum // 2, end='.0000000000')
	else:
		print(maximum // 2, end='.5000000000')
elif l - di[-1] > di[0]:
	print(l - di[-1], end='.0000000000')
else:
	print(di[0], end='.0000000000')


(n, l) = [int(x) for x in input().split()]
lan = [int(x) for x in input().split()]
lan.sort()
x = lan[0]
y = l - lan[-1]
dist = -1
for i in range(len(lan) - 1):
	if abs(lan[i] - lan[i + 1]) > dist:
		dist = abs(lan[i] - lan[i + 1])
d = max(x, y)
d = max(dist / 2, d)
print(d, end='')


(n, l) = input().split()
n = int(n)
l = int(l)
arr = list(map(int, input().split()))
arr.sort()
a = arr[0] - 0
b = l - arr[n - 1]
i = 0
c = 0
while i < n - 1:
	if arr[i + 1] - arr[i] > c:
		c = arr[i + 1] - arr[i]
	i = i + 1
print(round(max(a, b, c / 2), 10))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
mx = a[0]
for i in range(n - 1):
	d = (a[i + 1] - a[i]) / 2
	if d > mx:
		mx = d
ld = l - a[len(a) - 1]
if ld > mx:
	mx = ld
print('%0.10f' % mx)


(n, l) = [int(x) for x in input().strip().split()]
lights = [int(x) for x in input().strip().split()]
begin = 0
end = 0
if len(lights) == 1:
	print(max(lights[0], l - lights[0]))
else:
	lights.sort()
	if lights[0] != 0:
		begin = 2 * lights[0]
	if lights[-1] != l:
		end = 2 * (l - lights[-1])
	diff = [0] * (n - 1)
	for i in range(n - 1):
		diff[i] = lights[i + 1] - lights[i]
	maxi = max(diff)
	maxi = max(maxi, begin, end)
	print(maxi / 2)


(n, l) = map(int, input().split())
lst = [int(x) for x in input().split()]
lst.sort()
if lst[0] == 0:
	ress = 0
	s = set()
	for i in range(n):
		if i < n - 1:
			s.add((lst[i + 1] - lst[i]) / 2)
	if l not in lst:
		s.add(l - lst[-1])
else:
	ress = 0
	s = set()
	s.add(lst[0])
	for i in range(n):
		if i < n - 1:
			s.add((lst[i + 1] - lst[i]) / 2)
	if l not in lst:
		s.add(l - lst[-1])
print(max(s))


import sys
from math import ceil, log2
(n, l) = map(int, sys.stdin.readline().split())
lis = sorted(map(int, sys.stdin.readline().split()))
d = 0
for i in range(1, n):
	d = max(d, lis[i] - lis[i - 1])
f = float(lis[0])
l = float(l - lis[-1])
print(max(f, l, d / 2))


(a, b) = map(int, input().split())
c = sorted(list(map(int, input().split())))
try:
	print(max(c[0], b - c[-1], max(((c[i + 1] - c[i]) / 2 for i in range(a - 1)))))
except:
	print(max(1, c[0], b - c[-1]))


(n, l) = map(int, input().split())
a = input()
a = [int(x) for x in a.split()]
a.sort()
(maximum, b, c) = (0, 0, 0)
if a[0] != 0:
	b = a[0]
if a[-1] != l:
	c = l - a[-1]
a.sort()
for i in range(1, n):
	if a[i] - a[i - 1] > maximum:
		maximum = a[i] - a[i - 1]
print(max(maximum / 2, b, c))


(n, l) = map(int, input().split())
maxm = 0
x = [int(p) for p in input().split()]
x.sort()
for i in range(len(x) - 1):
	maxm = max(maxm, (x[i + 1] - x[i]) / 2)
print(max(maxm, x[0], abs(l - x[-1])))


(n, L) = map(int, input().split())
p = [int(a) for a in input().split()]
(ct0, ctl) = (0, 0)
for i in p:
	if i == 0:
		ct0 = 1
	if i == L:
		ctl = 1
if len(p) == 1:
	d = 1
else:
	p.sort()
	max_diff = p[1] - p[0]
	for x in range(1, len(p) - 1):
		if p[x + 1] - p[x] > max_diff:
			max_diff = p[x + 1] - p[x]
	d = float(max_diff / 2)
if ct0 == 0:
	if p[0] > d:
		d = float(p[0])
if ctl == 0:
	if L - p[len(p) - 1] > d:
		d = float(L - p[len(p) - 1])
print(d)


(n, t) = map(int, input().split())
l = list(map(int, input().split()))
l = sorted(l)
if n == 1:
	p = l[0]
	ost = t - l[0]
	ma = max(p, ost)
	print('%.9f' % ma)
else:
	S = [(l[i + 1] - l[i]) / 2 for i in range(n - 1)]
	ma = max(S)
	p = l[0]
	ost = t - l[-1]
	print('%.9f' % max(ma, p, ost))


figures = list(map(int, input('').split()))
nums = list(map(int, input('').split()))
nums.sort()
max_space = 0
i = 0
while i < len(nums) - 1:
	if nums[i + 1] - nums[i] > max_space:
		max_space = nums[i + 1] - nums[i]
	i += 1
print(max(max(nums[0], max_space / 2), figures[1] - nums[-1]))


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
x = maxdist = 0
for i in range(0, n - 1):
	if abs(a[x] - a[x + 1]) > maxdist:
		maxdist = abs(a[x] - a[x + 1])
	x += 1
mindist1 = maxdist / 2
maxdist1 = max(abs(a[0] - 0), abs(l - a[n - 1]))
ans = max(maxdist1, mindist1)
t = str(float(ans))
while len(t) < 12:
	t += '0'
print(t)


(n, l) = [int(x) for x in input().split()]
d = []
d = [int(x) for x in input().split()]
p = []
p = d
d = sorted(d, key=int, reverse=True)
d.insert(0, l)
d.append(0)
f = []
for i in range(0, len(d) - 1):
	f.append(d[i] - d[i + 1])
f.append(min(p) - 0)
m = min(p)
mp = l - max(p)
c = max(f) / 2
if m > c and m > mp:
	print(min(p))
elif mp > c:
	print(mp)
else:
	print(max(f) / 2)


import sys

def main(arr, l):
	arr.sort()
	d = max(arr[0], l - arr[-1])
	for i in range(len(arr) - 1):
		d = max(d, (arr[i + 1] - arr[i]) / 2.0)
	print(d)
for (e, line) in enumerate(sys.stdin.readlines()):
	if e == 0:
		(_, l) = map(int, line.strip().split())
		continue
	arr = list(map(int, line.strip().split()))
main(arr, l)


(n, l) = input().split(' ')
n = int(n)
l = int(l)
arr = []
for _ in input().split():
	arr.append(int(_))
arr.sort()
m = -1
i = 0
while i < n - 1:
	d = arr[i + 1] - arr[i]
	d = d / 2
	m = max(m, d)
	i += 1
if arr[0]:
	m = max(arr[0], m)
if arr[n - 1] != l:
	m = max(l - arr[n - 1], m)
print(m)


(k, l) = map(int, input().split())
lights = list(map(int, input().split()))
lights.sort()
ans = 0
for i in range(1, k):
	if (lights[i] - lights[i - 1]) / 2 > ans:
		ans = (lights[i] - lights[i - 1]) / 2
if k == 2:
	if (lights[1] - lights[0]) / 2 > ans:
		ans = (lights[1] - lights[0]) / 2
if lights[0] > ans:
	ans = lights[0]
if l - lights[-1] > ans:
	ans = l - lights[-1]
print('{0:.10f}'.format(ans))


def mi():
	return map(int, input().split(' '))
(n, l) = mi()
li = [int(x) for x in input().split(' ')]
li.sort()
newli = [0] + li
newli.append(l)
ran = len(newli)
mini = 0
for i in range(0, ran - 2):
	mini = max(mini, (newli[i + 1] - newli[i]) / 2)
if ran == 2:
	ans = (-newli[0] + newli[1]) / 2
ans = mini
if 0 not in li:
	ans = max(ans, newli[1])
if l not in li:
	ans = max(ans, newli[ran - 1] - newli[ran - 2])
print(ans)


from sys import stdin, stdout
(num_lights, len_road) = map(int, stdin.readline().split())
if num_lights == len_road:
	print(num_lights)
else:
	lights = [int(i) for i in stdin.readline().split()]
	if len(lights) == 1:
		if lights[0] > len_road / 2:
			print(lights[0])
		else:
			print(len_road - lights[0])
	else:
		lights.sort()
		abss = []
		X = []
		for i in range(num_lights - 1):
			abss.append(lights[i + 1] - lights[i])
		X.append(lights[0])
		X.append(len_road - lights[-1])
		X.append(max(abss) / 2)
		stdout.write(str(float(max(X))))


(n, k) = map(int, input().split())
maxdist = 0
n1 = list(map(int, input().split()))
n1.sort()
maxdist = 2 * max(n1[0], k - n1[n - 1])
for i in range(0, n - 1):
	maxdist = max(maxdist, n1[i + 1] - n1[i])
print('{0:.10f}'.format(maxdist / 2))


s = input().split()
n = int(s[0])
l = int(s[1])
a = list(map(int, input().split()))
a.sort()
d = 0.0
if a[0] / 2 > d:
	d = float(a[0])
for i in range(n - 1):
	x = a[i + 1] - a[i]
	if x / 2 > d:
		d = float(x / 2)
if l - a[n - 1] > d:
	d = float(l - a[n - 1])
print('%.10f' % d)


nAndl = list(map(int, input().split()))
n = nAndl[0]
l = nAndl[1]
a = list(map(int, input().split()))
array = []
a.sort()
if n == 1:
	print(max(a[0] - 0, l - a[0]))
else:
	for i in range(n - 1):
		array.append((a[i + 1] - a[i]) / 2)
	else:
		print(max(a[0] - 0, l - a[-1], max(array)))


(n, l) = map(int, input().split())
a = sorted(list(map(int, input().split())))
maxDist = -1
for i in range(1, len(a)):
	maxDist = max(maxDist, a[i] - a[i - 1])
maxDist = max(maxDist, 2 * (a[0] - 0), 2 * (l - a[-1]))
print('{:.10f}'.format(maxDist / 2))


q = list(map(int, input().split()))
w = sorted(list(map(int, input().split())))
e = 0
for i in range(q[0] - 1):
	e = max(e, w[i + 1] - w[i])
if min(w) - 0 <= e / 2 and q[1] - max(w) <= e / 2:
	print(e / 2)
else:
	print(max(min(w) - 0, q[1] - max(w)))


(n, l) = map(int, input().split())
seq = list(map(int, input().split()))
j = 0
seq.sort()
for i in range(n - 1):
	m = seq[i + 1] - seq[i]
	if m > j:
		j = m
t = seq[0] - 0
f = max(t, l - seq[-1])
j = j / 2
if f > j:
	print('%.10f' % f)
else:
	print('%.10f' % j)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
start = 0
end = l
d = 0
for i in range(n - 1):
	x = a[i + 1] - a[i]
	if x > d:
		d = x
d /= 2
if start not in a or end not in a:
	if start not in a:
		if a[0] > d:
			d = a[0]
	if end not in a:
		if end - a[n - 1] > d:
			d = end - a[n - 1]
print(d)


nums = [int(i) for i in input().split()]
nLants = nums[0]
lenSt = nums[1]
nums = [int(i) for i in input().split()]
nums.sort()
i = 1
maxLen = nums[0]
while i < nLants:
	currLen = nums[i] - nums[i - 1]
	if currLen / 2 > maxLen:
		maxLen = currLen / 2
	i += 1
if nLants > 0:
	if lenSt - nums[i - 1] > maxLen:
		maxLen = lenSt - nums[i - 1]
print(maxLen)


import sys

def get_ints():
	return map(int, sys.stdin.readline().strip().split())
(n, l) = get_ints()
lanterns = [int(x) for x in input().split()]
lanterns.sort()
d = max(lanterns[0] - 0, l - lanterns[-1])
for x in range(len(lanterns) - 1):
	d = max(d, (lanterns[x + 1] - lanterns[x]) / 2)
print(d)


import itertools
import math
x = lambda : map(int, input().split())
mega = lambda d: d + 1000000000.0

def main():
	(n, r) = x()
	a = list(x())
	a.sort()
	d = (a[0] > 0) * a[0]
	for i in range(1, n):
		d = max((a[i] - a[i - 1]) / 2, d)
	d = max(d, (a[n - 1] < r) * (r - a[n - 1]))
	print(d)
main()


s1 = input()
(n, l) = s1.split()
n = int(n)
l = int(l)
s = input().split()
lst = []
lst1 = []
for i in s:
	lst.append(int(i))
lst.sort()
maxdis = 0
for i in range(n - 1):
	d = abs(lst[i] - lst[i + 1])
	d = d / 2
	if d > maxdis:
		maxdis = d
if lst[0] != 0:
	d = lst[0]
	if maxdis < d:
		maxdis = d
if lst[-1] != l:
	d = abs(l - lst[-1])
	if maxdis < d:
		maxdis = d
print(maxdis)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
k = 0
for i in range(n - 1):
	if a[i + 1] - a[i] > k:
		k = a[i + 1] - a[i]
if k / 2 < a[0] or k / 2 < l - a[n - 1]:
	if a[0] > l - a[n - 1]:
		print(a[0])
	else:
		print(l - a[n - 1])
else:
	print(k / 2)


(a, b) = map(int, input().split())
lamps = list(map(int, input().split()))
lamps.sort()
Anslist = []
k = len(lamps) - 1
for i in range(len(lamps) - 1):
	c = (lamps[i + 1] - lamps[i]) / 2
	Anslist.append(c)
if lamps[0] != 0:
	Anslist.append(lamps[0])
else:
	pass
if lamps[k] != b:
	Anslist.append(b - lamps[k])
else:
	pass
print('%.10f' % max(Anslist))


(n, l) = list(map(lambda n: int(n), input().split()))
a = list(map(lambda n: int(n), input().split()))
a.sort()
maximum_dist = 0
if n == 1:
	print(max(a[0] - 0, l - a[0]))
else:
	for i in range(len(a) - 1):
		diff = a[i + 1] - a[i]
		if diff > maximum_dist:
			maximum_dist = diff
	print(max(maximum_dist / 2, a[0] - 0, l - a[n - 1]))


n = input()
n = n.split()
ca = int(n[1])
f = input()
f = f.split()
for y in range(len(f)):
	f[y] = int(f[y])
mayor = 0
pf = 0
f.sort()
for n in range(len(f)):
	t = f[n] - pf
	if t > mayor:
		mayor = t
	pf = f[n]
if ca - pf > mayor:
	print(ca - pf)
elif f[0] >= mayor:
	print(f[0])
elif mayor / 2 < ca - pf or mayor / 2 < f[0]:
	if ca - pf > f[0]:
		print(ca - pf)
	else:
		print(f[0])
else:
	print(mayor / 2)


str1 = input().split()
n = int(str1[0])
l = int(str1[1])
s = input()
a = [int(x) for x in s.split()]
a.append(l)
a.append(0)
a.sort()
max = 0
if a[1] > max:
	max = a[1]
if l - a[n] > max:
	max = l - a[n]
for x in range(1, n):
	if (a[x + 1] - a[x]) / 2 > max:
		max = (a[x + 1] - a[x]) / 2
print(max)