#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    def f2(x,y):
        return max([(x-px)**2+(y-py)**2 for (px,py) in p])

    def minf2(x):
        l = 0
        r = 1000
        while r-l > 1e-6:
            c1 = (2*l+r)/3
            c2 = (l+2*r)/3
            if f2(x,c1) < f2(x,c2):
                r = c2
            else:
                l = c1
        return f2(x,l)

    n = I()
    p = LIR(n)
    l = 0
    r = 1000
    while r-l > 1e-6:
        c1 = (2*l+r)/3
        c2 = (l+2*r)/3
        if minf2(c1) < minf2(c2):
            r = c2
        else:
            l = c1
    print(minf2(l)**0.5)

    """
    ans = float("inf")
    for i in range(n):
        x,y = p[i]
        q = [(p[j],(x-p[j][0])**2+(y-p[j][1])**2) for j in range(n) if j != i]
        q.sort(key = lambda x:-x[1])
        rx,ry = q[0][0]
        r2 = q[0][1]/4
        mx,my = (x+rx)/2,(y+ry)/2
        for P,D in q:
            s,t = P
            d2 = (s-mx)**2+(t-my)**2
            if d2 > r2+1e-6:
                break
        else:
            r = r2**0.5
            if r < ans:
                ans = r
    for i in range(n):
        ax,ay = p[i]
        for j in range(i):
            bx,by = p[j]
            sb,tb = ax-bx,ay-by
            mbx,mby = (ax+bx)/2,(ay+by)/2
            for k in range(j):
                cx,cy = p[k]
                l = -100000000
                r = 100000000
                while r-l > 1e-6:
                    m = (l+r)/2
                    mx,my = mbx-tb*m,mby+sb*m
                    d1 = (ax-mx)**2+(ay-my)**2
                    d2 = (cx-mx)**2+(cy-my)**2
                    if d1 < d2:
                        l = m
                    else:
                        r = m
                if r == 100000000:
                    l = -100000000
                    r = 100000000
                    while r-l > 1e-6:
                        m = (l+r)/2
                        mx,my = mbx-tb*m,mby+sb*m
                        d1 = (ax-mx)**2+(ay-my)**2
                        d2 = (cx-mx)**2+(cy-my)**2
                        if d1 < d2:
                            r = m
                        else:
                            l = m
                mx,my = mbx-tb*m,mby+sb*m
                r2 = (ax-mx)**2+(ay-my)**2
                for l in range(n):
                    if l in (i,j,k):
                        continue
                    s,t = p[l]
                    d2 = (s-mx)**2+(t-my)**2
                    if d2 > r2+1e-6:
                        break
                else:
                    r = r2**0.5
                    if r < ans:
                        ans = r

    print(ans)
    """
    return

#Solve
if __name__ == "__main__":
    solve()


Measured memory_bytes: 43612