Given are N points (x_i, y_i) in a two-dimensional plane.

Find the minimum radius of a circle such that all the points are inside or on it.

Constraints

* 2 \leq N \leq 50
* 0 \leq x_i \leq 1000
* 0 \leq y_i \leq 1000
* The given N points are all different.
* The values in input are all integers.

Input

Input is given from Standard Input in the following format:


N
x_1 y_1
:
x_N y_N


Output

Print the minimum radius of a circle such that all the N points are inside or on it.

Your output will be considered correct if the absolute or relative error from our answer is at most 10^{-6}.

Examples

Input

2
0 0
1 0


Output

0.500000000000000000


Input

3
0 0
0 1
1 0


Output

0.707106781186497524


Input

10
10 9
5 9
2 0
0 0
2 7
3 3
2 5
10 0
3 7
1 9


Output

6.726812023536805158
N = int(input())
xy = [list(map(int, input().split())) for _ in range(N)]
import math
def dist(x0, y0, x1, y1):
    return ((x0-x1)**2+(y0-y1)**2)**0.5
ans = 10**18
eps = 10**(-7)
for i in range(N):
    for j in range(i):
        for k in range(j):
            xi, yi = xy[i]
            xj, yj = xy[j]
            xk, yk = xy[k]
            a = xi
            b = yi
            c = xj
            d = yj
            e = xk
            f = yk

            aa = a * a
            bb = b * b
            cc = c * c
            dd = d * d
            ee = e * e
            ff = f * f
            
            if (2 * (e - a)*(b - d) - 2 * (c - a) * (b - f)) == 0 or (2 * (e - a)) == 0:
                continue
            py = ((e - a) * (aa + bb - cc - dd) - (c - a) * (aa + bb - ee- ff)) / (2 * (e - a)*(b - d) - 2 * (c - a) * (b - f))

            px = (2 * (b - f) * py - aa - bb + ee + ff) / (2 * (e - a))\
            if (c == a) else (2 * (b - d) * py - aa - bb + cc + dd) / (2 * (c - a))

            r = math.hypot(px - a, py - b)
            flag = True
            for l in range(N):
                xl, yl = xy[l]
                if math.hypot(xl-px, yl-py)<=r+eps:
                    continue
                flag = False
            if flag:
                ans = min(ans, r)
for i in range(N):
    for j in range(i):
        xi, yi = xy[i]
        xj, yj = xy[j]
        px, py = (xi+xj)/2, (yi+yj)/2
        r = dist(xi, yi, xj, yj)/2
        flag = True
        for l in range(N):
            xl, yl = xy[l]
            if math.hypot(xl-px, yl-py)<=r+eps:
                continue
            flag = False
        if flag:
            ans = min(ans, r)
print(ans)





