def examA():
    C = SI()
    ans = chr(ord(C)+1)
    print(ans)
    return

def examB():
    N,K,M = LI()
    A = LI()
    ans = N*M-sum(A)
    if ans>K:
        ans = -1
    elif ans<0:
        ans = 0
    print(ans)
    return

def examC():
    N, M = LI()
    ansT = 0; ansP = 0
    d = defaultdict(bool)
    WA = [0]*(N+1)
    for i in range(M):
        S, P = LSI()
        S = int(S)
        if P=="WA":
            WA[S] +=1
        elif P=="AC":
            if d[S]:
                continue
            else:
                d[S] = True
                ansT +=1
                ansP +=WA[S]
    print(ansT,ansP)
    return


def bfs_grid(h,w,s,maze):
    distance = [[-1]*w for _ in range(h)]
    def bfsg():
        queue = deque()
        queue.append(s)
        distance[s[0]][s[1]] = 0
        while len(queue):
            y, x = queue.popleft()
            for i in range(4):
                nx, ny = x + [1, 0, -1, 0][i], y + [0, 1, 0, -1][i]
                if (0<= nx <w and 0<= ny <h and maze[ny][nx] != '#'):
                    if distance[ny][nx]<=distance[y][x]+1 and distance[ny][nx]!=-1:
                        continue
                    queue.append((ny, nx))
                    distance[ny][nx] = distance[y][x] + 1
        return distance
    return bfsg()
def examD():
    H,W = LI()
    S = [SI() for _ in range(H)]
    ans = 0
    for i in range(H):
        for j in range(W):
            if S[i][j]=="#":
                continue
            D = bfs_grid(H, W, [i, j], S)
#            print(D)
            cur = 0
            for d in D:
                cur = max(cur,max(d))
            ans = max(ans,cur)
    print(ans)
    return

class combination():
    # 素数のmod取るときのみ　速い
    def __init__(self, n, mod):
        self.n = n
        self.fac = [1] * (n + 1)
        self.inv = [1] * (n + 1)
        for j in range(1, n + 1):
            self.fac[j] = self.fac[j - 1] * j % mod

        self.inv[n] = pow(self.fac[n], mod - 2, mod)
        for j in range(n - 1, -1, -1):
            self.inv[j] = self.inv[j + 1] * (j + 1) % mod

    def comb(self, n, r, mod):
        if r > n or n < 0 or r < 0:
            return 0
        return self.fac[n] * self.inv[n - r] * self.inv[r] % mod
def examE():
    N, K = LI()
    A = LI(); A.sort()
    maxN = 0; minN = 0
    C = combination(N,mod)
    d = defaultdict(int)
    dL = defaultdict(int)
    for i,a in enumerate(A):
        d[a] +=1
        if d[a]==1:
            dL[a] = i
    for key,i in d.items():
        cur = dL[key]+d[key]
#        print(cur)
        maxN += (C.comb(cur,K,mod)-C.comb(cur-d[key],K,mod))*key
        cur = N-dL[key]
        minN += (C.comb(cur,K,mod)-C.comb(cur-d[key],K,mod))*key
        maxN %=mod
        minN %=mod
#        print(maxN,minN)
    ans = (maxN - minN +mod)%mod
    print(ans)
    return
def C_R(x1,y1,x2,y2):
    return ((x1-x2)**2+(y1-y2)**2)**0.5
def C_R2(x1,y1,x2,y2):
    return ((x1-x2)**2-(y1-y2)**2)
def examF():
    N = I()
    XY = [LI() for _ in range(N)]
    ans = inf
    for i in range(N):
        x1 = XY[i][0]; y1 = XY[i][1]
        for j in range(i+1,N):
#            print(ans)
            x2 = XY[j][0]; y2 = XY[j][1]
            cur = C_R(x1,y1,x2,y2)
            curx = (x1+x2)/2; cury = (y1+y2)/2
            flag = True
            for l in range(N):
                now = 2*C_R(XY[l][0],XY[l][1],curx,cury)
                if now>cur+10**(-8):
                    flag = False
                    break
            if flag:
                ans = min(ans,cur)

            for k in range(j+1,N):
                x3 = XY[k][0]; y3 = XY[k][1]
                Da = C_R(x1,y1,x2,y2)
                Db = C_R(x2,y2,x3,y3)
                Dc = C_R(x3,y3,x1,y1)
                if abs((Da+Db+Dc)*(Da+Db-Dc)*(Da+Dc-Db)*(Db+Dc-Da))>10**(-9):
                    D = 2*(Da*Db*Dc)/((Da+Db+Dc)*(Da+Db-Dc)*(Da+Dc-Db)*(Db+Dc-Da))**0.5
                    a = x1-x2; b = y1-y2; c = x2-x3; d = y2-y3
                    if abs(a*d-b*c)<10**(-9):
                        continue
                    curx = (C_R2(x1,y1,x2,y2)*d-C_R2(x2,y2,x3,y3)*b)/2/(a*d-b*c)
                    cury = (-C_R2(x1,y1,x2,y2)*c+C_R2(x2,y2,x3,y3)*a)/2/(a*d-b*c)
                    flag = True
                    for l in range(N):
                        now = 2*C_R(XY[l][0], XY[l][1], curx, cury)
                        if now > D+10**(-8):
                            flag = False
                            break
                    if flag:
                        ans = min(ans, D)
    print(ans/2)
    return

def examF2():
    def minimum_bounding_circle(n,ps):
        random.shuffle(ps)
        #print(ps)
        def in_circle(p,c):
            return c is not None and math.hypot(p[0] - c[0], p[1] - c[1]) < c[2] + _ep

        def make_circle_2(a,b):
            c = [0]*2
            for i in range(2):
                c[i] = (a[i]+b[i])/2
            r2 = ((a[1]-c[1])**2 + (a[0]-c[0])**2)**0.5
            return (c[0],c[1],r2)

        def make_circle_3(p0, p1, p2):
            # Mathematical algorithm from Wikipedia: Circumscribed circle
            ax = p0[0]; ay = p0[1]
            bx = p1[0]; by = p1[1]
            cx = p2[0]; cy = p2[1]
            d = (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by)) * 2.0
            if d == 0.0:
                return None
            x = ((ax * ax + ay * ay) * (by - cy) + (bx * bx + by * by) * (cy - ay) + (cx * cx + cy * cy) * (
                        ay - by)) / d
            y = ((ax * ax + ay * ay) * (cx - bx) + (bx * bx + by * by) * (ax - cx) + (cx * cx + cy * cy) * (
                        bx - ax)) / d
            return (x, y, math.hypot(x - ax, y - ay))

        c = make_circle_2(ps[0],ps[1])

        for i in range(2,n):
            if not in_circle(ps[i], c):
                c = make_circle_2(ps[0], ps[i])
                for j in range(i):
                    if not in_circle(ps[j], c):
                        c = make_circle_2(ps[i], ps[j])
                        for k in range(j):
                            if not in_circle(ps[k], c):
                                c = make_circle_3(ps[i], ps[j], ps[k])
        return c
    N = I()
    P = [[]for _ in range(N)]
    for i in range(N):
        x, y = LI()
        P[i] = [x,y]
    ans = minimum_bounding_circle(N,P)
    print(ans[2])
    return

import sys,copy,bisect,itertools,heapq,math,random
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

if __name__ == '__main__':
    examF2()


Measured memory_bytes: 4844