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: interview

Starter code:

Solutions:
n, l = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()

result = 0
for i in range(1, n):
    result = max(result, (a[i] - a[i - 1]) / 2)
result = max(result, a[0])
result = max(result, l - a[-1])
print(result)


__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)

n,l=list(map(int,input().split()))
a=sorted(map(int,input().split()))
d=max(a[0],l-a[-1])
for i in range(n-1):
  if (a[i+1]-a[i] > 2*d):
    d = (a[i+1]-a[i])/2
print(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))
        


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

print(ans / 2)


n, m = list(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 = list(map(int, input().split()))
a = list(map(int, input().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)    


b = input().split()
n = int(b[0])
l = int(b[1])

a = input().split()

for i in range(n):
    a[i] = int(a[i])

a = sorted(a)
answer = 0
for i in range(n-1):
    if a[i+1]-a[i] > answer:
        answer = a[i+1]-a[i]

print(max(answer/2,a[0],l-a[-1]))


n, l = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
res = 0
d = [0] * (n + 1)

a.sort()

d[0] = a[0]
d[n] = l - a[n - 1]
for i in range(1, n):
    d[i] = (a[i] - a[i - 1]) / 2

for i in range(n + 1):
    res = max(res, d[i])

print(res)


__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)

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 = list(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)


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])

#print(ans/float(2))
if max(ans/float(2), min(distances)- 0, length- max(distances))== ans/float(2):
    #print(ans/float(2), min(distances)- 0, length- max(distances))
    print(ans/ float(2))
else:
    print(max(min(distances)- 0, length- max(distances)))

__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, l = [int(i) for i in input().strip().split()]

lights = [int(i) for i in input().strip().split()]

lights.sort()
#print lights

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

#if min_d < l-lights[N-1]:
#	min_d = (l-ligts[N-1])*1.0

print (min_d)


from sys import stdin


def main():
    n, l = list(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())


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))


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())
a = sorted(map(int, input().split()))

ans = max(a[0], l - a[-1])
if len(a) > 1:
	ans = max(ans, max((a[i + 1] - a[i]) / 2 for i in range(n - 1)))

print(ans)

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 = map(int, input(). split())
a = [int(i) for i in input(). split()]
a.sort(); a += [l]
d = a[0]
for i in range(1, n + 1):
    x = a[i] - a[i - 1]
    if i != n: x /= 2
    d = max(d, x)
print(d)

n,l=[int(x) for x in input().split(' ')]
locations=[int(x) for x in input().split(' ')]
locations=sorted(locations)
# print(locations)
minimum=0
a=0
b=1
while b<n:
    # print(minimum)
    minimum=max(minimum,(locations[b]-locations[a])/2)
    # print(" became ",minimum)
    a+=1
    b+=1
minimum=max(minimum,locations[0],l-locations[-1])
print(minimum)


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))


'''
import sys
def Calc(N):
    return(N*((N+1)*.5))
N=int(input())
C=0
for I in range(1000000000000000000):
    C+=Calc(I)
    if C==N:
        print(I)
        return
    elif C>N:
        print(I-1)
        return
'''
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)


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])]
    else:
        if abs(pair[0] - pair[1])/2 > MAX[1]:
            MAX = [pair, abs(pair[0] - pair[1])/2]

print(MAX[1])