AtCoder Beginner Contest 151 - Enclose All

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}.

-----Sample Input-----
2
0 0
1 0

-----Sample Output-----
0.500000000000000000

Both points are contained in the circle centered at (0.5,0) with a radius of 0.5.

Difficulty: MEDIUM_HARD

Starter code:

Solutions:
import math

def get_circle_center_and_radius(x1, y1, x2, y2, x3, y3):
	d = 2 * ((y1 - y3) * (x1 - x2) - (y1 - y2) * (x1 - x3))
	x = ((y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)) / d
	y = ((x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)) / -d
	r = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
	return (x, y, r)
n = int(input())
l = []
ans = float('inf')
for i in range(n):
	l.append([int(_) for _ in input().split()])
for i in range(0, n - 1):
	for j in range(i + 1, n):
		x = (l[i][0] + l[j][0]) / 2
		y = (l[i][1] + l[j][1]) / 2
		r = math.sqrt((l[i][0] - l[j][0]) ** 2 + (l[i][1] - l[j][1]) ** 2) / 2
		flag = 1
		for k in range(n):
			if k != i and k != j:
				if (x - l[k][0]) ** 2 + (y - l[k][1]) ** 2 > r ** 2:
					flag = 0
		if flag == 1:
			ans = min(r, ans)
for i in range(0, n - 2):
	for j in range(i + 1, n - 1):
		for k in range(i + 2, n):
			try:
				(x, y, r) = get_circle_center_and_radius(l[i][0], l[i][1], l[j][0], l[j][1], l[k][0], l[k][1])
				flag = 1
				for p in range(n):
					if p != i and p != j and (p != k):
						if (x - l[p][0]) ** 2 + (y - l[p][1]) ** 2 > r ** 2:
							flag = 0
				if flag == 1:
					ans = min(r, ans)
			except:
				continue
print(ans)


import numpy as np
EPS = 1e-12

class MinEnclosingCircle:

	def __init__(self, pts):
		self.pts = pts
		self.center = None
		self.radius = None

	def fit(self):
		self.center = (self.pts[0] + self.pts[1]) / 2
		self.radius = np.linalg.norm(self.pts[0] - self.pts[1]) / 2 + EPS
		for i in range(2, len(self.pts)):
			distance = np.linalg.norm(self.pts[i] - self.center)
			if distance >= self.radius:
				(self.center, self.radius) = self.find_second_point(i)

	def find_second_point(self, i):
		center = (self.pts[0] + self.pts[i]) / 2
		radius = np.linalg.norm(self.pts[0] - self.pts[i]) / 2 + EPS
		for j in range(1, i):
			distance = np.linalg.norm(self.pts[j] - center)
			if distance >= radius:
				(new_center, new_radius) = self.find_third_point(i, j)
				if new_radius > 0:
					center = new_center
					radius = new_radius
		return (center, radius)

	def find_third_point(self, i, j):
		center = (self.pts[j] + self.pts[i]) / 2
		radius = np.linalg.norm(self.pts[j] - self.pts[i]) / 2 + EPS
		for k in range(j):
			distance = np.linalg.norm(self.pts[k] - center)
			if distance >= radius:
				(new_center, new_radius) = self.find_circle_3pts(i, j, k)
				if new_radius > 0:
					center = new_center
					radius = new_radius
		return (center, radius)

	def find_circle_3pts(self, i, j, k):
		v1 = self.pts[j] - self.pts[i]
		v2 = self.pts[k] - self.pts[i]
		mid_point1 = (self.pts[j] + self.pts[i]) / 2
		c1 = np.dot(mid_point1, v1)
		mid_point2 = (self.pts[k] + self.pts[i]) / 2
		c2 = np.dot(mid_point2, v2)
		det = np.cross(v1, v2)
		if abs(det) <= EPS:
			d1 = np.sum(v1 * v1)
			d2 = np.sum(v2 * v2)
			d3 = np.sum((v1 - v2) ** 2)
			radius = np.sqrt(max(d1, d2, d3)) / 2 + EPS
			if d1 >= d2 and d1 >= d3:
				center = (self.pts[i] + self.pts[j]) / 2
			elif d2 >= d1 and d2 >= d3:
				center = (self.pts[i] + self.pts[k]) / 2
			else:
				center = (self.pts[j] + self.pts[k]) / 2
		else:
			center = np.zeros_like(v1)
			center[0] = c1 * v2[1] - c2 * v1[1]
			center[1] = v1[0] * c2 - v2[0] * c1
			center = center / det
			radius = np.linalg.norm(center - self.pts[i]) + EPS
		return (center, radius)
n = int(input())
point = [np.array(input().split(), dtype=int) for _ in range(n)]
mec = MinEnclosingCircle(point)
mec.fit()
print(mec.radius)


import math
from itertools import combinations
n = int(input())
p = [list(map(int, input().split())) for i in range(n)]

def enclose(points):
	a = points[0]
	b = points[1]
	c = points[2]
	d = points[3]
	e = points[4]
	f = points[5]
	aa = a * a
	bb = b * b
	cc = c * c
	dd = d * d
	ee = e * e
	ff = f * f
	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)
	return (px, py, r)
ans = 1000000
if n >= 3:
	for (i, j, k) in combinations(range(n), 3):
		points = []
		points.extend(p[i])
		points.extend(p[j])
		points.extend(p[k])
		try:
			(px, py, r) = enclose(points)
		except:
			continue
		flag = 1
		for l in range(n):
			if (px - p[l][0]) ** 2 + (py - p[l][1]) ** 2 > r ** 2 + 1e-07:
				flag = 0
				break
		if flag == 1:
			ans = min(ans, r)
for (i, j) in combinations(range(n), 2):
	px = (p[i][0] + p[j][0]) / 2
	py = (p[i][1] + p[j][1]) / 2
	r = ((p[i][0] - px) ** 2 + (p[i][1] - py) ** 2) ** (1 / 2)
	flag = 1
	for l in range(n):
		if (px - p[l][0]) ** 2 + (py - p[l][1]) ** 2 > r ** 2 + 1e-07:
			flag = 0
			break
	if flag == 1:
		ans = min(ans, r)
print(ans)


Point = complex
(N, *XY) = map(int, open(0).read().split())
P = [Point(x, y) for (x, y) in zip(*[iter(XY)] * 2)]

def max_distance(center):
	return max((abs(center - p) for p in P))

def ternary_search(f, left, right, MAX_ITER=100):
	for _ in range(MAX_ITER):
		m1 = (left * 2 + right) / 3
		m2 = (left + right * 2) / 3
		if f(m1) < f(m2):
			right = m2
		else:
			left = m1
	return f(left)

def g(x):
	return ternary_search(lambda y: max_distance(Point(x, y)), -1000, 1000)
print(ternary_search(g, -1000, 1000))


import math
import itertools
N = int(input())
l = [tuple(map(int, input().split())) for _ in range(N)]
if N == 2:
	(x1, y1) = l[0]
	(x2, y2) = l[1]
	print(0.5 * math.hypot(x1 - x2, y1 - y2))
else:
	ans = float('INF')
	l_ = itertools.combinations(l, 3)
	for points in l_:
		(a, b) = points[0]
		(c, d) = points[1]
		(e, f) = points[2]
		if (e - a) * (b - d) == (c - a) * (b - f):
			continue
		else:
			aa = a * a
			bb = b * b
			cc = c * c
			dd = d * d
			ee = e * e
			ff = f * f
			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) + 10 ** (-7)
		flag = 1
		for point in l:
			if flag:
				(s, t) = point
				if math.hypot(px - s, py - t) > r:
					flag = 0
		if flag:
			ans = min(r, ans)
	l_ = itertools.combinations(l, 2)
	for points in l_:
		(a, b) = points[0]
		(c, d) = points[1]
		(px, py) = ((a + c) / 2, (b + d) / 2)
		r = math.hypot(px - a, py - b) + 10 ** (-7)
		flag = 1
		for point in l:
			if flag:
				(s, t) = point
				if math.hypot(px - s, py - t) > r:
					flag = 0
		if flag:
			ans = min(r, ans)
	print(ans)


from math import sqrt
import itertools
N = int(input())
P = []
for i in range(N):
	P.append(list(map(int, input().split())))

def dist(P, Q):
	return sqrt((P[0] - Q[0]) ** 2 + (P[1] - Q[1]) ** 2)

def isFound(R):
	for (i, j) in itertools.combinations(list(range(N)), 2):
		if dist(P[i], P[j]) >= 2 * R:
			continue
		(x1, y1) = P[i]
		(x2, y2) = P[j]
		PM = dist(P[i], P[j]) / 2
		(xm, ym) = ((x1 + x2) / 2, (y1 + y2) / 2)
		(x_ev, y_ev) = (y2 - y1, x1 - x2)
		norm_ev = sqrt(x_ev ** 2 + y_ev ** 2)
		(x_ev, y_ev) = (x_ev / norm_ev, y_ev / norm_ev)
		MM = sqrt(R ** 2 - PM ** 2)
		P1 = [xm + x_ev * MM, ym + y_ev * MM]
		P2 = [xm - x_ev * MM, ym - y_ev * MM]
		for v in [P1, P2]:
			flg = False
			for p in P:
				if dist(v, p) > R + 1e-07:
					flg = True
					break
			if flg:
				continue
			else:
				return True
	return False
(l, r) = (0, 1001)
for i in range(100):
	m = (l + r) / 2
	if isFound(m):
		r = m
	else:
		l = m
print(m)


n = int(input())
C = []
for i in range(n):
	(x, y) = list(map(int, input().split()))
	C.append(complex(x, y))

def calc_kyori(O, C):
	res = 0
	for i in range(n):
		temp = abs(O - C[i])
		res = max(temp, res)
	return res

def sannbunn_first(x, my, MY):
	cnt = 100
	while cnt > 0:
		y1 = (2 * my + MY) / 3
		y2 = (my + 2 * MY) / 3
		v1 = calc_kyori(complex(x, y1), C)
		v2 = calc_kyori(complex(x, y2), C)
		if v2 < v1:
			my = y1
		else:
			MY = y2
		cnt -= 1
	return my

def sannbunn_second(mx, MX, my, MY):
	cnt = 100
	while cnt > 0:
		x1 = (2 * mx + MX) / 3
		x2 = (mx + 2 * MX) / 3
		yy1 = sannbunn_first(x1, my, MY)
		v1 = calc_kyori(complex(x1, yy1), C)
		yy2 = sannbunn_first(x2, my, MY)
		v2 = calc_kyori(complex(x2, yy2), C)
		if v2 < v1:
			mx = x1
		else:
			MX = x2
		cnt -= 1
	return (mx, yy1, v1)
if n == 2:
	ans = abs(C[0] - C[1]) / 2
else:
	(rx, ry, ans) = sannbunn_second(0, 1000, 0, 1000)
print(ans)


from math import hypot
N = int(input())
pts = [tuple(map(int, input().split())) for _ in range(N)]
EPS = 10 ** (-10)

def isLE(a, b):
	return not a > b + EPS

def getIntersectionLCs_L(a, b, c, xC, yC, r):
	e = a * xC + b * yC + c
	ab2 = a ** 2 + b ** 2
	v = r ** 2 * ab2 - e ** 2
	if v < 0:
		return []
	elif v == 0:
		xP = xC + -a * e / ab2
		yP = yC + -b * e / ab2
		return [(xP, yP)]
	else:
		v = v ** 0.5
		xP1 = xC + (-a * e + b * v) / ab2
		yP1 = yC + (-b * e - a * v) / ab2
		xP2 = xC + (-a * e - b * v) / ab2
		yP2 = yC + (-b * e + a * v) / ab2
		return [(xP1, yP1), (xP2, yP2)]

def getIntersectionCCs(x1, y1, r1, x2, y2, r2):
	(xC, yC) = (x2 - x1, y2 - y1)
	c = -(xC ** 2 + yC ** 2 + r1 ** 2 - r2 ** 2) / 2
	intCCs = getIntersectionLCs_L(xC, yC, c, 0, 0, r1)
	intCCs = [(x1 + x, y1 + y) for (x, y) in intCCs]
	return intCCs

def isOK(r):
	for i in range(N):
		(x1, y1) = pts[i]
		for j in range(i + 1, N):
			(x2, y2) = pts[j]
			intCCs = getIntersectionCCs(x1, y1, r, x2, y2, r)
			for (xC, yC) in intCCs:
				dist = max([hypot(x - xC, y - yC) for (x, y) in pts])
				if isLE(dist, r):
					return True
	return False
(ng, ok) = (0, 2000)
while abs(ok - ng) > 10 ** (-12):
	mid = (ng + ok) / 2
	if isOK(mid):
		ok = mid
	else:
		ng = mid
print(ok)


import sys

def I():
	return int(sys.stdin.readline().rstrip())

def LI():
	return list(map(int, sys.stdin.readline().rstrip().split()))
N = I()
xy = [LI() for i in range(N)]
ans = []

def distance(A, B):
	(x1, y1) = A
	(x2, y2) = B
	return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
for i in range(N - 1):
	for j in range(i + 1, N):
		(x1, y1) = xy[i]
		(x2, y2) = xy[j]
		(x, y) = ((x1 + x2) / 2, (y1 + y2) / 2)
		r = distance((x, y), (x1, y1))
		for k in range(N):
			if k == i or k == j:
				continue
			elif distance(xy[k], (x, y)) > r + 10 ** (-8):
				break
		else:
			ans.append(r)

def gaishin(A, B, C):
	(x1, y1) = A
	(x2, y2) = B
	(x3, y3) = C
	a = 2 * ((x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1))
	b = x2 ** 2 - x1 ** 2 + y2 ** 2 - y1 ** 2
	c = x3 ** 2 - x1 ** 2 + y3 ** 2 - y1 ** 2
	if a == 0:
		return (10000, 10000)
	else:
		x = ((y3 - y1) * b - (y2 - y1) * c) / a
		y = (-(x3 - x1) * b + (x2 - x1) * c) / a
	return (x, y)
for i in range(N - 2):
	for j in range(i + 1, N - 1):
		for k in range(j + 1, N):
			(x, y) = gaishin(xy[i], xy[j], xy[k])
			if x == 10000 and y == 10000:
				continue
			else:
				r = distance((x, y), xy[i])
				for l in range(N):
					if l == i or l == j or l == k:
						continue
					elif distance(xy[l], (x, y)) > r + 10 ** (-8):
						break
				else:
					ans.append(r)
print(min(ans))


EPS = 10 ** (-10)
N = int(input())
points = [list(map(float, input().split())) for _ in range(N)]

def dist(p0, p1):
	(x0, y0) = p0
	(x1, y1) = p1
	return ((x1 - x0) ** 2 + (y1 - y0) ** 2) ** 0.5

def canMakeRectangle(p0, p1, p2):
	(x0, y0) = p0
	(x1, y1) = p1
	(x2, y2) = p2
	if abs((y1 - y0) * (x2 - x0) - (y2 - y0) * (x1 - x0)) < EPS:
		return False
	else:
		return True

def circumcircle(p0, p1, p2):
	(x0, y0) = p0
	(x1, y1) = p1
	(x2, y2) = p2
	(l0, l1, l2) = (dist(p1, p2), dist(p2, p0), dist(p0, p1))
	r = l0 * l1 * l2 / ((l0 + l1 + l2) * (-l0 + l1 + l2) * (l0 - l1 + l2) * (l0 + l1 - l2)) ** 0.5
	a = (l0 ** 2 * (l1 ** 2 + l2 ** 2 - l0 ** 2) * x0 + l1 ** 2 * (l2 ** 2 + l0 ** 2 - l1 ** 2) * x1 + l2 ** 2 * (l0 ** 2 + l1 ** 2 - l2 ** 2) * x2) / (l0 ** 2 * (l1 ** 2 + l2 ** 2 - l0 ** 2) + l1 ** 2 * (l2 ** 2 + l0 ** 2 - l1 ** 2) + l2 ** 2 * (l0 ** 2 + l1 ** 2 - l2 ** 2))
	b = (l0 ** 2 * (l1 ** 2 + l2 ** 2 - l0 ** 2) * y0 + l1 ** 2 * (l2 ** 2 + l0 ** 2 - l1 ** 2) * y1 + l2 ** 2 * (l0 ** 2 + l1 ** 2 - l2 ** 2) * y2) / (l0 ** 2 * (l1 ** 2 + l2 ** 2 - l0 ** 2) + l1 ** 2 * (l2 ** 2 + l0 ** 2 - l1 ** 2) + l2 ** 2 * (l0 ** 2 + l1 ** 2 - l2 ** 2))
	return (r, a, b)

def circle(p0, p1):
	(x0, y0) = p0
	(x1, y1) = p1
	r = dist(p0, p1) / 2
	a = (x1 - x0) / 2 + x0
	b = (y1 - y0) / 2 + y0
	return (r, a, b)

def check(c, P):
	(r, a, b) = c
	for p in P:
		if dist((a, b), p) > r + EPS:
			return False
	return True
ans = float('inf')
for i in range(N - 2):
	for j in range(i + 1, N - 1):
		for k in range(j + 1, N):
			if canMakeRectangle(points[i], points[j], points[k]):
				(r, a, b) = circumcircle(points[i], points[j], points[k])
				if check((r, a, b), points):
					ans = min(ans, r)
for i in range(N - 1):
	for j in range(i + 1, N):
		(r, a, b) = circle(points[i], points[j])
		if check((r, a, b), points):
			ans = min(ans, r)
print(ans)


def circum(A, B, C):
	(Ax, Ay) = A
	(Bx, By) = B
	(Cx, Cy) = C
	a = (Bx - Cx) ** 2 + (By - Cy) ** 2
	b = (Cx - Ax) ** 2 + (Cy - Ay) ** 2
	c = (Ax - Bx) ** 2 + (Ay - By) ** 2
	s = a * (b + c - a)
	t = b * (c + a - b)
	u = c * (a + b - c)
	Ux = (s * Ax + t * Bx + u * Cx) / (s + t + u)
	Uy = (s * Ay + t * By + u * Cy) / (s + t + u)
	return (Ux, Uy)

def dist2(a, b):
	(ax, ay) = a
	(bx, by) = b
	return (ax - bx) ** 2 + (ay - by) ** 2
n = int(input())
P = [tuple(map(int, input().split())) for i in range(n)]
eps = 10 ** (-7)
if n == 2:
	r = dist2(P[0], P[1]) ** 0.5 / 2
	print(r)
	return
for i in range(n - 2):
	for j in range(i + 1, n - 1):
		for k in range(j + 1, n):
			(a, b, c) = (P[i], P[j], P[k])
			(ax, ay) = a
			(bx, by) = b
			(cx, cy) = c
			if dist2(a, b) + dist2(b, c) <= dist2(c, a):
				p = ((cx + ax) / 2, (cy + ay) / 2)
				r2 = dist2(a, p)
			elif dist2(b, c) + dist2(c, a) <= dist2(a, b):
				p = ((ax + bx) / 2, (ay + by) / 2)
				r2 = dist2(b, p)
			elif dist2(c, a) + dist2(a, b) <= dist2(b, c):
				p = ((bx + cx) / 2, (by + cy) / 2)
				r2 = dist2(c, p)
			else:
				p = circum(a, b, c)
				r2 = dist2(a, p)
			if all([dist2(p, q) <= r2 + eps for q in P]):
				print(r2 ** 0.5)
				return


from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
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 check(X, Y, r2, err=1e-06):
		for (x, y) in p:
			if (x - X) ** 2 + (y - Y) ** 2 > r2 + err:
				return 0
		return 1
	n = I()
	p = LIR(n)
	ans = float('inf')
	for i in range(n):
		(xi, yi) = p[i]
		for j in range(i + 1):
			(xj, yj) = p[j]
			X = (xi + xj) / 2
			Y = (yi + yj) / 2
			r2 = (xi - X) ** 2 + (yi - Y) ** 2
			if ans > r2 and check(X, Y, r2):
				ans = r2
			(x, y) = (xj - xi, yj - yi)
			for k in range(j):
				(xk, yk) = p[k]
				(a, b) = (xk - xi, yk - yi)
				deno = 2 * (a * y - b * x)
				if deno == 0:
					continue
				X = (y * (a ** 2 + b ** 2) - b * (x ** 2 + y ** 2)) / deno + xi
				Y = (a * (x ** 2 + y ** 2) - x * (a ** 2 + b ** 2)) / deno + yi
				r2 = (xi - X) ** 2 + (yi - Y) ** 2
				if ans > r2 and check(X, Y, r2):
					ans = r2
	print(ans ** 0.5)
	return
solve()


import sys
from math import sqrt
input = sys.stdin.readline
N = int(input())
ps = [tuple(map(int, input().split())) for _ in range(N)]
rang = 0
for t in ps:
	rang = max(rang, abs(t[0]), abs(t[1]))

def calc(x, y):
	res = 0
	for t in ps:
		(u, v) = t
		res = max(res, sqrt((x - u) ** 2 + (y - v) ** 2))
	return res
x0 = -1000
x3 = 1000
x1 = (x0 * 2 + x3) / 3
x2 = (x0 + x3 * 2) / 3
res = float('inf')
xl = 0
yl = 0
for i in range(0, rang * 2 + 1, 10):
	u = i - rang
	for j in range(0, rang * 2 + 1, 10):
		v = j - rang
		if calc(xl, yl) > calc(u, v):
			xl = u
			yl = v
x0 = xl - 10
x3 = xl + 10
while x3 - x0 > 0.1 ** 12:
	x1 = (x0 * 2 + x3) / 3
	x2 = (x0 + x3 * 2) / 3
	cc1 = 0
	cc2 = 0
	y0 = yl - 10
	y3 = yl + 10
	y1 = (y0 * 2 + y3) / 3
	y2 = (y0 + y3 * 2) / 3
	while y3 - y0 > 0.1 ** 12:
		y1 = (y0 * 2 + y3) / 3
		y2 = (y0 + y3 * 2) / 3
		c1 = calc(x1, y1)
		c2 = calc(x1, y2)
		if c1 < c2:
			y3 = y2
		else:
			y0 = y1
	cy1 = y1 + 0
	y0 = yl - 10
	y3 = yl + 10
	y1 = (y0 * 2 + y3) / 3
	y2 = (y0 + y3 * 2) / 3
	while y3 - y0 > 0.1 ** 12:
		y1 = (y0 * 2 + y3) / 3
		y2 = (y0 + y3 * 2) / 3
		c1 = calc(x2, y1)
		c2 = calc(x2, y2)
		if c1 < c2:
			y3 = y2
		else:
			y0 = y1
	cy2 = y1 + 0
	cc1 = calc(x1, cy1)
	cc2 = calc(x2, cy2)
	if cc1 < cc2:
		x3 = x2
	else:
		x0 = x1
	res = min(cc1, cc2)
print(res)


import math

def all_points(x, y):
	return max((one_point(x, y, _x, _y) for (_x, _y) in points))

def one_point(x0, y0, x1, y1):
	return math.pow(x0 - x1, 2) + math.pow(y0 - y1, 2)

def two():
	for i in range(N):
		for j in range(i + 1, N):
			yield (points[i], points[j])

def three():
	for i in range(N):
		for j in range(i + 1, N):
			for k in range(j + 1, N):
				yield (points[i], points[j], points[k])

def process_two():
	minimum = 1e+18
	for ((a, b), (c, d)) in two():
		(x, y) = ((a + c) / 2, (b + d) / 2)
		minimum = min(minimum, all_points(x, y))
	return minimum

def process_three():
	minimum = 1e+18
	for ((a, b), (c, d), (e, f)) in three():
		try:
			if b == d == f:
				continue
			if d == b:
				(a, b, c, d, e, f) = (e, f, a, b, c, d)
			if f == b:
				(a, b, c, d, e, f) = (c, d, e, f, a, b)
			(m0x, m0y) = ((a + c) / 2, (b + d) / 2)
			m0 = -(c - a) / (d - b)
			b0 = m0y - m0 * m0x
			(m1x, m1y) = ((a + e) / 2, (b + f) / 2)
			m1 = -(e - a) / (f - b)
			b1 = m1y - m1 * m1x
			x = (b1 - b0) / (m0 - m1)
			y = m0 * x + b0
			minimum = min(minimum, all_points(x, y))
		except ZeroDivisionError:
			continue
	return minimum
N = int(input())
points = []
for i in range(N):
	(x, y) = map(int, input().split())
	points.append((x, y))
print(math.sqrt(min(process_two(), process_three())))


import sys

def solve():
	input = sys.stdin.readline
	N = int(input())
	P = [[int(x) for x in input().split()] for _ in range(N)]
	eps = 1e-09
	minR = 10 ** 10
	if N == 2:
		r = (P[1][0] - P[0][0]) ** 2 + (P[1][1] - P[0][1]) ** 2
		r = r ** 0.5 / 2
		print(r)
		return 0
	for i in range(N - 2):
		for j in range(i + 1, N - 1):
			(a, b) = P[i]
			(c, d) = P[j]
			(x, y) = ((a + c) / 2, (b + d) / 2)
			rd = (x - a) ** 2 + (y - b) ** 2
			for l in range(N):
				if l != i and l != j:
					if (P[l][0] - x) ** 2 + (P[l][1] - y) ** 2 - rd > eps:
						break
			else:
				minR = min(minR, rd)
			for k in range(j + 1, N):
				if (P[j][1] - P[i][1]) * (P[k][0] - P[j][0]) == (P[j][0] - P[i][0]) * (P[k][1] - P[j][1]):
					continue
				(e, f) = P[k]
				if c == a:
					y = (d + b) / 2
					if d == f:
						x = (d + f) / 2
					else:
						x = (e + c) / 2 + ((d + f) / 2 - y) * (f - d) / (e - c)
				elif e == c:
					y = (d + f) / 2
					if d == b:
						x = (d + b) / 2
					else:
						x = (a + c) / 2 + ((b + d) / 2 - y) * (d - b) / (c - a)
				elif d == b:
					x = (a + c) / 2
					y = (d + f) / 2 + ((e + c) / 2 - x) * (e - c) / (f - d)
				elif f == d:
					x = (c + e) / 2
					y = (b + d) / 2 + ((c + a) / 2 - x) * (c - a) / (d - b)
				else:
					x = ((c ** 2 - a ** 2) / (2 * (d - b)) - (e ** 2 - c ** 2) / (2 * (f - d)) - (f - b) / 2) * ((d - b) * (f - d) / ((c - a) * (f - d) - (e - c) * (d - b)))
					y = (d + f) / 2 + ((e + c) / 2 - x) * (e - c) / (f - d)
				rd = (x - a) ** 2 + (y - b) ** 2
				for l in range(N):
					if l != i and l != j and (l != k):
						if (P[l][0] - x) ** 2 + (P[l][1] - y) ** 2 - rd > eps:
							break
				else:
					minR = min(minR, rd)
	print(minR ** 0.5)
	return 0

def __starting_point():
	solve()
__starting_point()


import itertools
import math

def get_circle_center_and_radius(x1, y1, x2, y2, x3, y3):
	d = 2 * ((y1 - y3) * (x1 - x2) - (y1 - y2) * (x1 - x3))
	if d == 0:
		return (0, 0, 0)
	x = ((y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)) / d
	y = ((x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)) / -d
	r = (x - x1) ** 2 + (y - y1) ** 2
	return (x, y, r)

def get_circle_center_and_radius_two(x1, y1, x2, y2):
	x = (x1 + x2) / 2
	y = (y1 + y2) / 2
	r = (x - x1) ** 2 + (y - y1) ** 2
	return (x, y, r)

def check_if_all_included(x, y, r, points, v):
	for point in points:
		if point in v:
			continue
		dist = (x - point[0]) ** 2 + (y - point[1]) ** 2
		if dist > r:
			break
	else:
		return True
	return False
n = int(input())
points = []
for i in range(n):
	points.append(list(map(int, input().split())))
r_min = 1000000
for v in itertools.combinations(points, 2):
	(x1, y1, x2, y2) = (v[0][0], v[0][1], v[1][0], v[1][1])
	(x, y, r) = get_circle_center_and_radius_two(x1, y1, x2, y2)
	if check_if_all_included(x, y, r, points, v) and r < r_min:
		r_min = r
for v in itertools.combinations(points, 3):
	(x1, y1, x2, y2, x3, y3) = (v[0][0], v[0][1], v[1][0], v[1][1], v[2][0], v[2][1])
	(x, y, r) = get_circle_center_and_radius(x1, y1, x2, y2, x3, y3)
	if r == 0:
		continue
	if check_if_all_included(x, y, r, points, v) and r < r_min:
		r_min = r
print(math.sqrt(r_min))


import itertools
import math
N = int(input())
p = []
for i in range(N):
	(x, y) = map(int, input().split())
	p.append([x, y])
ans = 10000
if len(p) >= 3:
	S = list(itertools.combinations(p, 3))
	for X in S:
		ok = True
		a = X[0][0]
		b = X[0][1]
		c = X[1][0]
		d = X[1][1]
		e = X[2][0]
		f = X[2][1]
		if (a - c) * (b - f) == (a - e) * (b - d):
			continue
		py = ((e - a) * (a ** 2 + b ** 2 - c ** 2 - d ** 2) - (c - a) * (a ** 2 + b ** 2 - e ** 2 - f ** 2)) / (2 * (e - a) * (b - d) - 2 * (c - a) * (b - f))
		if c == a:
			px = (2 * (b - f) * py - (a ** 2 + b ** 2 - e ** 2 - f ** 2)) / (2 * (e - a))
		else:
			px = (2 * (b - d) * py - (a ** 2 + b ** 2 - c ** 2 - d ** 2)) / (2 * (c - a))
		r = math.sqrt((px - a) ** 2 + (py - b) ** 2)
		for Y in p:
			if not (r + 1e-06) ** 2 >= (px - Y[0]) ** 2 + (py - Y[1]) ** 2:
				ok = False
		if ok:
			ans = min(ans, r)
T = list(itertools.combinations(p, 2))
for X in T:
	a = X[0][0]
	b = X[0][1]
	c = X[1][0]
	d = X[1][1]
	ok = True
	px = (a + c) / 2
	py = (b + d) / 2
	r = math.sqrt((px - a) ** 2 + (py - b) ** 2)
	for Y in p:
		if not (r + 1e-06) ** 2 >= (px - Y[0]) ** 2 + (py - Y[1]) ** 2:
			ok = False
	if ok:
		ans = min(ans, r)
print(ans)


import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10 ** 9))
write = lambda x: sys.stdout.write(x + '\n')
from math import sqrt
eps = 10 ** (-10)

def crosscl(cx, cy, r, x1, y1, x2, y2):
	xd = x2 - x1
	yd = y2 - y1
	X = x1 - cx
	Y = y1 - cy
	a = xd ** 2 + yd ** 2
	b = xd * X + yd * Y
	c = X ** 2 + Y ** 2 - r ** 2
	D = b ** 2 - a * c
	if D < 0:
		return (None, None)
	s1 = (-b + sqrt(D)) / a
	s2 = (-b - sqrt(D)) / a
	return ((x1 + xd * s1, y1 + yd * s1), (x1 + xd * s2, y1 + yd * s2))

def crosscc(x1, y1, r1, x2, y2, r2):
	k = -2 * (x1 - x2)
	l = -2 * (y1 - y2)
	m = x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2 - r1 ** 2 + r2 ** 2
	if k == 0:
		p1 = (0, -m / l)
		p2 = (100, -m / l)
	elif l == 0:
		p1 = (-m / k, 0)
		p2 = (-m / k, 100)
	else:
		p1 = (0, -m / l)
		p2 = (1, -(m + k) / l)
	return crosscl(x1, y1, r1, *p1, *p2)
N = int(input())
xy = [None] * N
for i in range(N):
	(x, y) = map(int, input().split())
	xy[i] = (x, y)

def sub(r):
	kouho = xy[:]
	for i in range(N):
		for j in range(i + 1, N):
			(p1, p2) = crosscc(xy[i][0], xy[i][1], r, xy[j][0], xy[j][1], r)
			if p1 is not None:
				kouho.append(p1)
				kouho.append(p2)
	ans = False
	for k in kouho:
		for (x, y) in xy:
			if (k[0] - x) ** 2 + (k[1] - y) ** 2 <= r ** 2 * (1 + eps):
				pass
			else:
				break
		else:
			ans = True
	return ans
lb = 0
ub = 2000
while abs(lb - ub) > 10 ** (-8):
	mm = (lb + ub) / 2
	if sub(mm):
		ub = mm
	else:
		lb = mm
print(ub)


import numpy as np
iNum = int(input())
naXY = np.zeros((iNum, 2))
for iI in range(iNum):
	(x, y) = list(map(int, input().split()))
	naXY[iI] = [x, y]
naXY0 = np.average(naXY, axis=0) + np.random.rand(2) * 0.001
fA = 0.1
while fA > 1e-10:
	naP = naXY - naXY0
	naR = np.einsum('ij, ij -> i', naP, naP)
	iImax = np.argmax(naR)
	naE = naP[iImax]
	naXY0 += naE * fA
	fA *= 0.9998
print(naR[iImax] ** 0.5)


from scipy.optimize import fmin
I = input
n = int(I())
L = [list(map(int, I().split())) for i in range(n)]

def C(t):
	(i, j) = t
	return max(((x - i) ** 2 + (y - j) ** 2 for (x, y) in L))
(x, y) = fmin(C, (500, 500), disp=0)
print(C((x, y)) ** 0.5)


import numpy as np
n = int(input())
x = [tuple(map(int, input().split())) for _ in range(n)]

def circle(x, y, z):
	ra = np.array(x)
	rb = np.array(y)
	rc = np.array(z)
	A = np.dot(rb - rc, rb - rc)
	B = np.dot(rc - ra, rc - ra)
	C = np.dot(ra - rb, ra - rb)
	T = A * (B + C - A)
	U = B * (C + A - B)
	W = C * (A + B - C)
	rcc = (T * ra + U * rb + W * rc) / (T + U + W)
	return rcc

def dis(a, b, c, d):
	return (a - b) ** 2 + (c - d) ** 2
e = 10 ** (-9)
ans = 10 ** 18
for i in range(n):
	for j in range(i + 1, n):
		a = x[i]
		b = x[j]
		(px, py) = ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2)
		r = dis(px, a[0], py, a[1])
		ok = True
		for (s, t) in x:
			if dis(px, s, py, t) > r + e:
				ok = False
				break
		if ok:
			ans = min(ans, r)
if ans != 10 ** 18:
	print(ans ** (1 / 2))
	return
for i in range(n):
	for j in range(i + 1, n):
		for k in range(j + 1, n):
			a = x[i]
			b = x[j]
			c = x[k]
			(px, py) = circle(a, b, c)
			r = dis(px, a[0], py, a[1])
			ok = True
			for (s, t) in x:
				if dis(px, s, py, t) > r + e:
					ok = False
					break
			if ok:
				ans = min(ans, r)
print(ans ** (1 / 2))


N = int(input())
L = [[int(l) for l in input().split()] for _ in range(N)]

def dist(x, y, x0, y0):
	return ((x - x0) ** 2 + (y - y0) ** 2) ** 0.5

def f(x, y):
	res = 0
	for i in range(N):
		res = max(res, dist(L[i][0], L[i][1], x, y))
	return res
lx = -10 ** 4
rx = 10 ** 4
for _ in range(100):
	cx1 = (lx * 2 + rx) / 3
	ly = -10 ** 4
	ry = 10 ** 4
	for _ in range(100):
		cy1 = (ly * 2 + ry) / 3
		cy2 = (ly + ry * 2) / 3
		if f(cx1, cy1) < f(cx1, cy2):
			ry = cy2
		else:
			ly = cy1
	y = (ly + ry) / 2
	cx2 = (lx + rx * 2) / 3
	ly = -10 ** 4
	ry = 10 ** 4
	for _ in range(100):
		cy1 = (ly * 2 + ry) / 3
		cy2 = (ly + ry * 2) / 3
		if f(cx2, cy1) < f(cx2, cy2):
			ry = cy2
		else:
			ly = cy1
	if f(cx1, y) < f(cx2, ly):
		rx = cx2
		ans = f(cx1, y)
	else:
		lx = cx1
		ans = f(cx2, ly)
print(ans)


import sys, math
sys.setrecursionlimit(300000)

def circumcenter(ax, ay, bx, by, cx, cy):
	d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by))
	if d == 0:
		return (None, None)
	ux = ((ax * ax + ay * ay) * (by - cy) + (bx * bx + by * by) * (cy - ay) + (cx * cx + cy * cy) * (ay - by)) / d
	uy = ((ax * ax + ay * ay) * (cx - bx) + (bx * bx + by * by) * (ax - cx) + (cx * cx + cy * cy) * (bx - ax)) / d
	return (ux, uy)

def center(a, b, c, d, e, f):
	aa = a * a
	bb = b * b
	cc = c * c
	dd = d * d
	ee = e * e
	ff = f * f
	tmp = 2 * (e - a) * (b - d) - 2 * (c - a) * (b - f)
	if tmp == 0:
		return (None, None)
	py = ((e - a) * (aa + bb - cc - dd) - (c - a) * (aa + bb - ee - ff)) / tmp
	if c == a:
		px = (2 * (b - f) * py - aa - bb + ee + ff) / (2 * (e - a))
	else:
		px = (2 * (b - d) * py - aa - bb + cc + dd) / (2 * (c - a))
	return (px, py)

def solve(N: int, x: 'List[int]', y: 'List[int]'):
	e = 10 ** (-10)

	def can(px, py, dis):
		for p in range(N):
			d = math.hypot(px - x[p], py - y[p])
			if d > dis + e:
				return False
		return True
	ret = float('inf')
	for i in range(N):
		for j in range(i + 1, N):
			dx = abs(x[i] - x[j])
			dy = abs(y[i] - y[j])
			px = (x[i] + x[j]) / 2.0
			py = (y[i] + y[j]) / 2.0
			dis = math.hypot(px - x[i], py - y[i])
			if can(px, py, dis):
				ret = min(ret, dis)
	for i in range(N):
		for j in range(i + 1, N):
			for k in range(j + 1, N):
				(px, py) = circumcenter(x[i], y[i], x[j], y[j], x[k], y[k])
				if not px:
					continue
				dis = math.hypot(px - x[i], py - y[i])
				if can(px, py, dis):
					ret = min(ret, dis)
	print(ret)
	return

def main():

	def iterate_tokens():
		for line in sys.stdin:
			for word in line.split():
				yield word
	tokens = iterate_tokens()
	N = int(next(tokens))
	x = [int()] * N
	y = [int()] * N
	for i in range(N):
		x[i] = int(next(tokens))
		y[i] = int(next(tokens))
	solve(N, x, y)

def __starting_point():
	main()
__starting_point()


N = int(input())
xy = [list(map(int, input().split())) for _ in range(N)]

def gaisin(a, b, c):
	A = a[0] ** 2 + a[1] ** 2 - b[0] ** 2 - b[1] ** 2
	B = b[0] ** 2 + b[1] ** 2 - c[0] ** 2 - c[1] ** 2
	x = [2 * (b[0] - a[0]), 2 * (c[0] - b[0])]
	y = [2 * (b[1] - a[1]), 2 * (c[1] - b[1])]
	return renritu(x, y, [A, B])

def renritu(x, y, z):
	k = x[1] * y[0] - x[0] * y[1]
	if k == 0:
		return (False, 0, 0)
	Cx = -(y[0] * z[1] - y[1] * z[0]) / k
	Cy = (x[0] * z[1] - x[1] * z[0]) / k
	return (True, Cx, Cy)

def nasu(a, b, c):
	(f, Cx, Cy) = gaisin(a, b, c)
	if f:
		return honyamorake(Cx, Cy)
	else:
		return 10 ** 10

def honya(x, y, Cx, Cy):
	return ((x - Cx) ** 2 + (y - Cy) ** 2) ** (1 / 2)

def honyaraka(a, b):
	Cx = (a[0] + b[0]) / 2
	Cy = (a[1] + b[1]) / 2
	return honyamorake(Cx, Cy)

def honyamorake(Cx, Cy):
	r = honya(xy[0][0], xy[0][1], Cx, Cy)
	for i in range(1, N):
		r = max(r, honya(xy[i][0], xy[i][1], Cx, Cy))
	return r
ans = 10 ** 10
for i in range(N - 2):
	for j in range(i + 1, N - 1):
		for k in range(j + 1, N):
			ans = min(ans, nasu(xy[i], xy[j], xy[k]))
for i in range(N - 1):
	for j in range(i + 1, N):
		ans = min(ans, honyaraka(xy[i], xy[j]))
print(ans)


n = int(input())
XY = [tuple(map(int, input().split())) for _ in range(n)]

def f(x, y):
	r = 0
	for (xi, yi) in XY:
		d = ((x - xi) ** 2 + (y - yi) ** 2) ** 0.5
		if d > r:
			r = d
	return r

def g(x):
	(l, r) = (0, 1000)
	for _ in range(75):
		(c1, c2) = ((2 * l + r) / 3, (l + 2 * r) / 3)
		if f(x, c1) > f(x, c2):
			l = c1
		else:
			r = c2
	return f(x, l)
(l, r) = (0, 1000)
for _ in range(75):
	(c1, c2) = ((2 * l + r) / 3, (l + 2 * r) / 3)
	if g(c1) > g(c2):
		l = c1
	else:
		r = c2
print(g(l))


import sys
import cmath
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
eps = 1e-08
input = lambda : sys.stdin.readline().rstrip()
YesNo = lambda b: bool([print('Yes')] if b else print('No'))
YESNO = lambda b: bool([print('YES')] if b else print('NO'))
int1 = lambda x: int(x) - 1

def main():
	N = int(input())
	(x, y) = ([0] * N, [0] * N)
	for i in range(N):
		(x[i], y[i]) = map(int, input().split())

	def get_Intersection(c1, c2, R):
		mid = (c1 + c2) / 2
		if R < abs(c1 - mid):
			return (None, None)
		d = (R ** 2 - abs(c1 - mid) ** 2) ** 0.5
		p = cmath.polar((c1 - c2) * 1j)
		v = cmath.rect(d, p[1])
		i1 = mid + v
		i2 = mid - v
		return (i1, i2)

	def nibutan(ok, ng):
		for _ in range(100):
			mid = (ok + ng) / 2
			if solve(mid):
				ok = mid
			else:
				ng = mid
		return ok

	def solve(mid):
		for i in range(N):
			for j in range(N):
				if i == j:
					continue
				c1 = x[i] + y[i] * 1j
				c2 = x[j] + y[j] * 1j
				(i1, i2) = get_Intersection(c1, c2, mid)
				if i1 is None:
					continue
				for k in range(N):
					i3 = x[k] + y[k] * 1j
					if abs(i3 - i1) > mid + eps:
						break
				else:
					return True
				for k in range(N):
					i3 = x[k] + y[k] * 1j
					if abs(i3 - i2) > mid + eps:
						break
				else:
					return True
		return False
	print(nibutan(2000, 0))
main()


import math
import itertools
N = int(input())
C = [tuple(map(int, input().split())) for _ in range(N)]
e = 10 ** (-10)

def dist(p1, p2):
	return math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)

def dist2(p1, p2):
	return (p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2

def mid(p1, p2):
	return ((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2)

def angle(p1, p2):
	return math.atan2(p2[1] - p1[1], p2[0] - p1[0])

def angle2(c1, c2, r):
	d = dist(c1, c2)
	return math.acos(d / 2 / r)

def cross(c1, c2, r):
	if dist2(c1, c2) > (2 * r) ** 2:
		return set()
	a = angle(c1, c2)
	t = angle2(c1, c2, r)
	return set([(c1[0] + r * math.cos(a + t), c1[1] + r * math.sin(a + t)), (c1[0] + r * math.cos(a - t), c1[1] + r * math.sin(a - t))])

def judge(r):
	P = set()
	for (c1, c2) in itertools.product(C, C):
		if c1 == c2:
			continue
		P |= cross(c1, c2, r)
	for p in P:
		for c in C:
			if dist2(p, c) > r ** 2 + e:
				break
		else:
			return True
	return False

def solve():
	under = 0
	ok = 800
	while ok - under > 10 ** (-6):
		m = (ok + under) / 2
		if judge(m):
			ok = m
		else:
			under = m
	return ok
print(solve())


import sys
input = sys.stdin.readline
N = int(input())
P = [tuple(map(int, input().split())) for i in range(N)]

def calcdismax(x, y):
	MAX = 0
	for (px, py) in P:
		MAX = max(MAX, (px - x) ** 2 + (py - y) ** 2)
	return MAX
delta = 10 ** (-10)

def div100(xmin, xmax, ymin, ymax):
	xh = (xmax - xmin) / 100
	yh = (ymax - ymin) / 100
	MIN = 1 << 30
	MINx = 0
	MINy = 0
	for i in range(101):
		xk = xmin + xh * i
		for j in range(101):
			yk = ymin + yh * j
			cd = calcdismax(xk, yk)
			if MIN > cd:
				MIN = cd
				MINx = xk
				MINy = yk
	return (MINx, MINy)
now = 500
k = 500
l = 500
while now > 10 ** (-7):
	(k, l) = div100(k - now, k + now, l - now, l + now)
	now /= 2
import math
print(math.sqrt(calcdismax(k, l)))


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop, heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10 ** 9 + 7
inf = float('inf')

def I():
	return int(sys.stdin.readline())

def LI():
	return list(map(int, sys.stdin.readline().split()))
n = I()
xy = [LI() for _ in range(n)]

def d(x1, y1, x2, y2):
	return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)

def f(x, y):
	res = 0
	for (x1, y1) in xy:
		res = max(res, d(x, y, x1, y1))
	return res

def g(x):
	(l, r) = (0, 1000)
	for _ in range(80):
		a = (l * 2 + r) / 3
		b = (l + r * 2) / 3
		if f(x, a) > f(x, b):
			l = a
		else:
			r = b
	return f(x, l)
(l, r) = (0, 1000)
for _ in range(80):
	a = (l * 2 + r) / 3
	b = (l + r * 2) / 3
	if g(a) > g(b):
		l = a
	else:
		r = b
print(g(l))


from itertools import combinations
epsilon = 5 * 10 ** (-7)
N = int(input())
points = [complex(*list(map(int, input().split()))) for _ in range(N)]
longest_radius = 0
for (p, q) in combinations(points, 2):
	radius = abs(p - q) / 2
	if longest_radius < radius:
		longest_radius = radius
		center = (p + q) / 2
out_of_circle = False
for s in points:
	if abs(s - center) > longest_radius + epsilon:
		out_of_circle = True
		break
if not out_of_circle:
	print(longest_radius)
	return
smallest_radius = 10 ** 9
for (p, q, r) in combinations(points, 3):
	denominator = (p - q) * r.conjugate() + (q - r) * p.conjugate() + (r - p) * q.conjugate()
	if denominator == 0 + 0j:
		continue
	numerator = (p - q) * abs(r) ** 2 + (q - r) * abs(p) ** 2 + (r - p) * abs(q) ** 2
	center = numerator / denominator
	radius = abs(p - center)
	for s in points:
		if abs(s - center) > radius + epsilon:
			break
	else:
		smallest_radius = min(smallest_radius, radius)
print(smallest_radius)


n = int(input())
xy = [list(map(int, input().split())) for i in range(n)]
import math

def calc(x1, y1, x2, y2, x3, y3):
	try:
		d = 2 * ((y1 - y3) * (x1 - x2) - (y1 - y2) * (x1 - x3))
		x = ((y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)) / d
		y = ((x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)) / -d
		r2 = (x - x1) ** 2 + (y - y1) ** 2
	except:
		return (0, 0, -1)
	else:
		return (x, y, r2)

def check(cx, cy, r2):
	for tmp in xy:
		(x, y) = tmp
		if (x - cx) ** 2 + (y - cy) ** 2 > r2:
			return False
	return True
ans = float('inf')
eps = 10 ** (-5)
for i in range(n):
	for j in range(i + 1, n):
		(x1, y1) = xy[i]
		(x2, y2) = xy[j]
		cx = (x1 + x2) / 2
		cy = (y1 + y2) / 2
		r2 = (cx - x1) ** 2 + (cy - y1) ** 2
		if check(cx, cy, r2 + eps):
			ans = min(ans, math.sqrt(r2))
for i in range(n):
	for j in range(i + 1, n):
		for k in range(j + 1, n):
			(x1, y1) = xy[i]
			(x2, y2) = xy[j]
			(x3, y3) = xy[k]
			(cx, cy, r2) = calc(x1, y1, x2, y2, x3, y3)
			if 0 < r2 and check(cx, cy, r2 + eps):
				ans = min(ans, math.sqrt(r2))
print(ans)


from math import hypot
n = int(input())
ls = [list(map(int, input().split())) for i in range(n)]

def f(x, y):
	dist = 0
	for i in range(n):
		dx = x - ls[i][0]
		dy = y - ls[i][1]
		dist = max(dist, hypot(dx, dy))
	return dist

def g(x):
	l = 0
	r = 1000
	for _ in range(100):
		c1 = (l * 2 + r) / 3
		c2 = (l + r * 2) / 3
		if f(x, c1) > f(x, c2):
			l = c1
		else:
			r = c2
	return f(x, l)
l = 0
r = 1000
for _ in range(100):
	c1 = (l * 2 + r) / 3
	c2 = (l + r * 2) / 3
	if g(c1) > g(c2):
		l = c1
	else:
		r = c2
print(g(l))


import math
N = int(input())
(X, Y) = ([], [])
for _ in range(N):
	(x, y) = map(int, input().split())
	X.append(x)
	Y.append(y)

def calc_r(x0, y0):
	res = 0
	for i in range(N):
		res = max(res, (X[i] - x0) ** 2 + (Y[i] - y0) ** 2)
	return res
(lb_x, ub_x) = (0.0, 1000.0)

def g(x):
	(lb_y, ub_y) = (0.0, 1000.0)
	for _ in range(100):
		y1 = lb_y + (ub_y - lb_y) / 3
		y2 = ub_y - (ub_y - lb_y) / 3
		if calc_r(x, y1) > calc_r(x, y2):
			lb_y = y1
		else:
			ub_y = y2
	return calc_r(x, lb_y)
for _ in range(100):
	x1 = lb_x + (ub_x - lb_x) / 3
	x2 = ub_x - (ub_x - lb_x) / 3
	if g(x1) > g(x2):
		lb_x = x1
	else:
		ub_x = x2
print(math.sqrt(g(lb_x)))


from math import sin, sqrt
N = int(input())
XY = [[int(i) for i in input().split()] for _ in range(N)]
INF = 10 ** 6

def circumcenter(i, j, k):
	(a, b) = XY[i]
	(c, d) = XY[j]
	(e, f) = XY[k]
	(aa, bb, cc, dd, ee, ff) = (a ** 2, b ** 2, c ** 2, d ** 2, e ** 2, f ** 2)
	try:
		y = ((e - a) * (aa + bb - cc - dd) - (c - a) * (aa + bb - ee - ff)) / (2 * (e - a) * (b - d) - 2 * (c - a) * (b - f))
		x = (2 * (b - f) * y - aa - bb + ee + ff) / (2 * (e - a)) if c == a else (2 * (b - d) * y - aa - bb + cc + dd) / (2 * (c - a))
	except ZeroDivisionError as e:
		return (-INF, -INF)
	return (x, y)

def radius(x, y):
	dist = 0
	for (X, Y) in XY:
		tmp = pow(X - x, 2) + pow(Y - y, 2)
		dist = max(dist, tmp)
	return sqrt(dist)

def midpoint(a, b):
	(xa, ya) = XY[a]
	(xb, yb) = XY[b]
	x = (xa + xb) / 2
	y = (ya + yb) / 2
	return (x, y)

def main():
	ans = float('inf')
	for a in range(N):
		for b in range(a + 1, N):
			(x, y) = midpoint(a, b)
			r = radius(x, y)
			ans = min(ans, r)
	for a in range(N):
		for b in range(a + 1, N):
			for c in range(b + 1, N):
				(x, y) = circumcenter(a, b, c)
				r = radius(x, y)
				ans = min(ans, r)
	print('{0:.7f}'.format(ans))

def __starting_point():
	main()
__starting_point()


import math
epsilon = 5 * 10 ** (-7)
N = int(input())
xys = [tuple(map(int, input().split())) for _ in range(N)]
(xs, ys) = zip(*xys)
lsd = 0
for i in range(0, N):
	for j in range(i + 1, N):
		sd = (xs[i] - xs[j]) ** 2 + (ys[i] - ys[j]) ** 2
		if lsd < sd:
			lsd = sd
			farthest_2_points = (i, j)
(p, q) = farthest_2_points
center_x = (xs[p] + xs[q]) / 2
center_y = (ys[p] + ys[q]) / 2
all_in_circle = True
for i in range(N):
	if (xs[i] - center_x) ** 2 + (ys[i] - center_y) ** 2 > lsd / 4 + epsilon:
		all_in_circle = False
if all_in_circle:
	print(lsd ** 0.5 / 2)
	return
smallest_radius = 10 ** 9
for p in range(0, N):
	for q in range(p + 1, N):
		for r in range(q + 1, N):
			pq = ((xs[q] - xs[p]) ** 2 + (ys[q] - ys[p]) ** 2) ** 0.5
			v1x = xs[p] - xs[r]
			v1y = ys[p] - ys[r]
			v2x = xs[q] - xs[r]
			v2y = ys[q] - ys[r]
			vec1_len = (v1x ** 2 + v1y ** 2) ** 0.5
			vec2_len = (v2x ** 2 + v2y ** 2) ** 0.5
			vecs_dot = v1x * v2x + v1y * v2y
			theta = math.acos(min(1.0, max(-1.0, vecs_dot / (vec1_len * vec2_len))))
			if theta == 0:
				continue
			radius = pq / (2 * math.sin(theta))
			det = v1x * v2y - v1y * v2x
			if det == 0:
				continue
			center_x = xs[r] + (v2y * vec1_len ** 2 + -v1y * vec2_len ** 2) / (2 * det)
			center_y = ys[r] + (-v2x * vec1_len ** 2 + v1x * vec2_len ** 2) / (2 * det)
			all_in_circle = True
			for s in range(N):
				if ((xs[s] - center_x) ** 2 + (ys[s] - center_y) ** 2) ** 0.5 > radius + epsilon:
					all_in_circle = False
			if all_in_circle:
				smallest_radius = min(smallest_radius, radius)
print(smallest_radius)


n = int(input())
xy = [list(map(int, input().split())) for _ in range(n)]
sgm = pow(10, -7)

def func(c):
	allp = []
	for i in range(n - 1):
		for j in range(i + 1, n):
			(xi, yi) = xy[i]
			(xj, yj) = xy[j]
			dx = xi - xj
			dy = yi - yj
			d = ((xi - xj) ** 2 + (yi - yj) ** 2) ** 0.5
			if c ** 2 - (d / 2) ** 2 < 0:
				return False
			h = (c ** 2 - (d / 2) ** 2) ** 0.5
			(mx, my) = ((xi + xj) / 2, (yi + yj) / 2)
			if dx == 0:
				allp.append([mx - h, my])
				allp.append([mx + h, my])
			elif dy == 0:
				allp.append([mx, my - h])
				allp.append([mx, my + h])
			else:
				(dx, dy) = (dy, -dx)
				dh = (dy ** 2 + dx ** 2) ** 0.5
				dx *= h / dh
				dy *= h / dh
				allp.append([mx + dx, my + dy])
				allp.append([mx - dx, my - dy])
	for (px, py) in allp:
		flg = True
		for (x, y) in xy:
			if ((px - x) ** 2 + (py - y) ** 2) ** 0.5 > c + sgm:
				flg = False
				break
		if flg:
			return True
	return False
r = 2 * max([abs(x) for (x, y) in xy]) + max([abs(y) for (x, y) in xy])
(l, r) = (0, r)
for i in range(400):
	c = (l + r) / 2
	if func(c):
		(l, r) = (l, c)
	else:
		(l, r) = (c, r)
print(c)


n = int(input())
l = [tuple(map(int, input().split())) for _ in range(n)]
ans = 10 ** 5
dist = lambda p, q: ((p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2) ** 0.5
check = lambda c, d: all((dist(c, p) <= d for p in l))

def S(p1, p2, p3):
	(a, b) = p1
	(c, d) = p2
	(e, f) = p3
	return abs((d - b) * (e - a) - (f - b) * (c - a))

def disk(p1, p2, p3):
	(x1, y1) = p1
	(x2, y2) = p2
	(x3, y3) = p3
	a2 = (x2 - x3) ** 2 + (y2 - y3) ** 2
	b2 = (x1 - x3) ** 2 + (y1 - y3) ** 2
	c2 = (x2 - x1) ** 2 + (y2 - y1) ** 2
	area = ((x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1)) / 2
	if area == 0:
		return ((0, 0), 10 ** 5)
	x = (a2 * (b2 + c2 - a2) * x1 + b2 * (c2 + a2 - b2) * x2 + c2 * (a2 + b2 - c2) * x3) / (16 * area * area)
	y = (a2 * (b2 + c2 - a2) * y1 + b2 * (c2 + a2 - b2) * y2 + c2 * (a2 + b2 - c2) * y3) / (16 * area * area)
	r = ((x1 - x) ** 2 + (y1 - y) ** 2) ** 0.5
	return ((x, y), r)
for i in range(n - 1):
	for j in range(i + 1, n):
		c = ((l[i][0] + l[j][0]) / 2, (l[i][1] + l[j][1]) / 2)
		d = dist(l[i], l[j]) / 2
		if check(c, d) and d < ans:
			ans = d
for i in range(n - 2):
	for j in range(i + 1, n - 1):
		for k in range(j + 1, n):
			(c, d) = disk(l[i], l[j], l[k])
			if check(c, d) and d < ans:
				ans = d
print(ans)


import math, time, sys
from decimal import *
getcontext().prec = 1000
DEBUG = False

def all_points(x, y):
	return max((one_point(x, y, _x, _y) for (_x, _y) in points))

def one_point(x0, y0, x1, y1):
	return math.pow(x0 - x1, 2) + math.pow(y0 - y1, 2)

def two():
	for i in range(N):
		for j in range(i + 1, N):
			yield (points[i], points[j])

def three():
	for i in range(N):
		for j in range(i + 1, N):
			for k in range(j + 1, N):
				yield (points[i], points[j], points[k])

def process_two():
	minimum = 1e+18
	for ((a, b), (c, d)) in two():
		if DEBUG:
			print('two: ', a, b, c, d)
		(x, y) = ((a + c) / 2, (b + d) / 2)
		minimum = min(minimum, all_points(x, y))
	return minimum

def process_three():
	minimum = 1e+18
	for ((a, b), (c, d), (e, f)) in three():
		if DEBUG:
			print('three: ', a, b, c, d, e, f)
		try:
			if b == d == f:
				continue
			if d == b:
				(a, b, c, d, e, f) = (e, f, a, b, c, d)
			if f == b:
				(a, b, c, d, e, f) = (c, d, e, f, a, b)
			(m0x, m0y) = ((a + c) / 2, (b + d) / 2)
			m0 = -(c - a) / (d - b)
			b0 = m0y - m0 * m0x
			(m1x, m1y) = ((a + e) / 2, (b + f) / 2)
			m1 = -(e - a) / (f - b)
			b1 = m1y - m1 * m1x
			x = (b1 - b0) / (m0 - m1)
			y = m0 * x + b0
			minimum = min(minimum, all_points(x, y))
		except ZeroDivisionError:
			if DEBUG:
				print(a, b, c, d, e, f)
			continue
	return minimum
N = int(input())
points = []
for i in range(N):
	(x, y) = map(int, input().split())
	points.append((x, y))
if N == 2000:
	print(0.5 * math.sqrt(one_point(points[0][0], points[0][1], points[1][0], points[1][1])))
else:
	print(math.sqrt(min(process_two(), process_three())))


import itertools
import math
EPS = 1e-06

def dot(a, b):
	return a.real * b.real + a.imag * b.imag

def enclose_triangle(p1, p2, p3):
	v12 = p2 - p1
	v23 = p3 - p2
	v31 = p1 - p3
	an1 = dot(v12, -v31)
	an2 = dot(-v12, v23)
	an3 = dot(-v23, v31)
	if an1 < 0 + EPS or an2 < 0 + EPS or an3 < 0 + EPS:
		vx = max(v12, v23, v31, key=abs)
		rad = abs(vx) / 2
		if vx == v12:
			cent = (p1 + p2) / 2
		elif vx == v23:
			cent = (p2 + p3) / 2
		else:
			cent = (p3 + p1) / 2
	else:
		a = p1
		b = p2
		c = p3
		a2 = abs(v23) ** 2
		b2 = abs(v31) ** 2
		c2 = abs(v12) ** 2
		u = a2 * (b2 + c2 - a2) * a + b2 * (c2 + a2 - b2) * b + c2 * (a2 + b2 - c2) * c
		u /= a2 * (b2 + c2 - a2) + b2 * (c2 + a2 - b2) + c2 * (a2 + b2 - c2)
		rad = abs(u - p1)
		cent = u
	return (rad, cent)

def enclose_points(n, ps):
	assert n >= 2
	if n == 2:
		return abs(ps[1] - ps[0]) / 2
	for (p1, p2, p3) in itertools.combinations(ps, 3):
		(rad_cand, cent_cand) = enclose_triangle(p1, p2, p3)
		for q1 in ps:
			dist = abs(cent_cand - q1)
			if dist >= rad_cand + EPS:
				break
		else:
			return rad_cand

def main():
	n = int(input())
	ps = []
	for _ in range(n):
		(x, y) = (float(z) for z in input().split())
		ps.append(complex(x, y))
	res = enclose_points(n, ps)
	print('{:.16f}'.format(res))
main()


def calc_intersection(z1, z2, R):
	d2 = (z1[0] - z2[0]) ** 2 + (z1[1] - z2[1]) ** 2
	d = d2 ** 0.5
	if R < d / 2:
		return None
	else:
		m = [(z1[0] + z2[0]) * 0.5, (z1[1] + z2[1]) * 0.5]
		l = (R ** 2 / d2 - 0.25) ** 0.5
		v = [l * (z2[1] - z1[1]), l * (z1[0] - z2[0])]
		return [[m[0] + v[0], m[1] + v[1]], [m[0] - v[0], m[1] - v[1]]]

def check(R):
	intersections = []
	for i in range(N):
		for j in range(i + 1, N):
			points = calc_intersection(xy[i], xy[j], R)
			if points is None:
				return False
			else:
				intersections.extend(points)
	for (px, py) in intersections:
		res = True
		for (x, y) in xy:
			res *= (x - px) ** 2 + (y - py) ** 2 <= R ** 2 + 1e-06
			if not res:
				break
		if res:
			return True
	return False
N = int(input())
xy = [list(map(int, input().split())) for i in range(N)]
left = 0
right = 500 * 2 ** 0.5
while right - left > 1e-06:
	mid = (left + right) / 2
	if check(mid):
		right = mid
	else:
		left = mid
print(right)


def main():
	import sys
	from math import sqrt, hypot
	input = sys.stdin.readline

	def dist(p1, p2):
		(x1, y1) = p1
		(x2, y2) = p2
		return hypot(x2 - x1, y2 - y1)

	def CP(x1, y1, r1, x2, y2, r2):
		rr0 = (x2 - x1) ** 2 + (y2 - y1) ** 2
		xd = x2 - x1
		yd = y2 - y1
		rr1 = r1 ** 2
		rr2 = r2 ** 2
		cv = rr0 + rr1 - rr2
		sv = sqrt(4 * rr0 * rr1 - cv ** 2)
		return ((x1 + (cv * xd - sv * yd) / (2.0 * rr0), y1 + (cv * yd + sv * xd) / (2.0 * rr0)), (x1 + (cv * xd + sv * yd) / (2.0 * rr0), y1 + (cv * yd - sv * xd) / (2.0 * rr0)))
	N = int(input())
	P = []
	for _ in range(N):
		(x, y) = map(int, input().split())
		P.append((x, y))
	dmax = 0
	for i in range(N):
		for j in range(i + 1, N):
			dmax = max(dmax, dist(P[i], P[j]))
	eps = 10 ** (-8)
	ok = 1000.0
	ng = dmax / 2
	mid = (ok + ng) / 2
	while ok - ng > 10 ** (-7):
		cp_list = []
		for i in range(N - 1):
			(x1, y1) = P[i]
			for j in range(i + 1, N):
				(x2, y2) = P[j]
				(cp1, cp2) = CP(x1, y1, mid, x2, y2, mid)
				cp_list.append(cp1)
				cp_list.append(cp2)
		flg = 0
		for p0 in cp_list:
			tmp = 1
			for p in P:
				if dist(p0, p) > mid + eps:
					tmp = 0
			if tmp:
				flg = 1
				break
		if flg:
			ok = mid
		else:
			ng = mid
		mid = (ok + ng) / 2
	print(ok)
main()


import sys
input = sys.stdin.readline
LOCAL = len(sys.argv) > 1 and sys.argv[1] == 'LOCAL'

def dprint(*args):
	if LOCAL:
		print(*args)
n = int(input())
xy = [list(map(int, input().split())) for _ in range(n)]
import math
import itertools

def distanse(x1, y1, x2, y2):
	return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)

def isValid(ox, oy, r):
	global xy
	for (x, y) in xy:
		if distanse(x, y, ox, oy) - r > 1e-06:
			return False
	return True
rs = []
for ((x1, y1), (x2, y2)) in itertools.combinations(xy, r=2):
	dprint(x1, y1, x2, y2)
	r = distanse(x1, y1, x2, y2) / 2
	ox = (x1 + x2) / 2
	oy = (y1 + y2) / 2
	dprint(ox, oy, r)
	if isValid(ox, oy, r):
		rs.append(r)
for ((x1, y1), (x2, y2), (x3, y3)) in itertools.combinations(xy, r=3):
	a = x1 * (y2 - y3) - y1 * (x2 - x3) + x2 * y3 - x3 * y2
	b = (x1 ** 2 + y1 ** 2) * (y3 - y2) + (x2 ** 2 + y2 ** 2) * (y1 - y3) + (x3 ** 2 + y3 ** 2) * (y2 - y1)
	c = (x1 ** 2 + y1 ** 2) * (x2 - x3) + (x2 ** 2 + y2 ** 2) * (x3 - x1) + (x3 ** 2 + y3 ** 2) * (x1 - x2)
	d = (x1 ** 2 + y1 ** 2) * (x3 * y2 - x2 * y3) + (x2 ** 2 + y2 ** 2) * (x1 * y3 - x3 * y1) + (x3 ** 2 + y3 ** 2) * (x2 * y1 - x1 * y2)
	if a == 0:
		continue
	ox = -b / (2 * a)
	oy = -c / (2 * a)
	r = math.sqrt((b ** 2 + c ** 2 - 4 * a * d) / (4 * a ** 2))
	if isValid(ox, oy, r):
		rs.append(r)
dprint(rs)
print('{:.18f}'.format(min(rs)))


def get_center_and_radius(x1, y1, x2, y2, x3, y3):
	if (y2 - y1) * (x3 - x1) == (y3 - y1) * (x2 - x1):
		return (-1, -1, -1)
	d = 2 * (x1 - x2) * (y1 - y3) - 2 * (x1 - x3) * (y1 - y2)
	cx = ((x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) * (y1 - y3) - (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2) * (y1 - y2)) / d
	cy = ((x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2) * (x1 - x2) - (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) * (x1 - x3)) / d
	r2 = (x1 - cx) ** 2 + (y1 - cy) ** 2
	return (cx, cy, r2)

def is_inclusive(cx, cy, r2):
	for (xi, yi) in xy:
		if (xi - cx) ** 2 + (yi - cy) ** 2 > r2 + 1e-10:
			return False
	return True
N = int(input())
xy = [tuple(map(int, input().split())) for _ in range(N)]
R2 = 10 ** 18
for i in range(N):
	for j in range(i + 1, N):
		(xi, yi) = xy[i]
		(xj, yj) = xy[j]
		(cx, cy) = ((xi + xj) / 2, (yi + yj) / 2)
		r2 = (cx - xi) ** 2 + (cy - yi) ** 2
		if is_inclusive(cx, cy, r2):
			R2 = min(R2, r2)
for i in range(N):
	for j in range(i + 1, N):
		for k in range(j + 1, N):
			(xi, yi) = xy[i]
			(xj, yj) = xy[j]
			(xk, yk) = xy[k]
			(cx, cy, r2) = get_center_and_radius(xi, yi, xj, yj, xk, yk)
			if cx == -1:
				continue
			if is_inclusive(cx, cy, r2):
				R2 = min(R2, r2)
print(R2 ** 0.5)


import math
n = int(input())
(tx, ty) = (0, 0)
(x, y) = ([], [])
for i in range(n):
	(tx, ty) = map(int, input().split())
	x.append(tx)
	y.append(ty)
cx = 0
cy = 0
rad = 0
jud = 0
diffr = 0
maxdist = 0
(sx, sy) = ([], [])
for i in range(n - 1):
	for j in range(i + 1, n):
		if rad < math.sqrt((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j])):
			rad = math.sqrt((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]))
			cx = (x[i] + x[j]) / 2
			cy = (y[i] + y[j]) / 2
if rad >= max([math.sqrt((cx - x[i]) * (cx - x[i]) + (cy - y[i]) * (cy - y[i])) for i in range(n)]) * 2:
	jud = 1
if jud == 1:
	rad = rad / 2
else:
	(p, sx, sy) = (n, x, y)
	rad = 800
	for i in range(0, p - 2):
		for j in range(i + 1, p - 1):
			for k in range(j + 1, p):
				a = sx[i]
				b = sy[i]
				c = sx[j]
				d = sy[j]
				e = sx[k]
				f = sy[k]
				aa = 2 * (c - a)
				bb = 2 * (d - b)
				cc = c * c - a * a + d * d - b * b
				dd = 2 * (e - a)
				ee = 2 * (f - b)
				ff = e * e - a * a + f * f - b * b
				z = bb * dd - aa * ee
				if z != 0:
					cx = (bb * ff - cc * ee) / z
					cy = (cc * dd - aa * ff) / z
					maxdist = max([math.sqrt((cx - sx[m]) * (cx - sx[m]) + (cy - sy[m]) * (cy - sy[m])) for m in range(p)])
					diffr = math.sqrt((cx - a) * (cx - a) + (cy - b) * (cy - b))
					if maxdist <= diffr and diffr < rad:
						rad = diffr
print(rad)


import random
import math

def make_circle(points):
	shuffled = [(float(x), float(y)) for (x, y) in points]
	random.shuffle(shuffled)
	c = None
	for (i, p) in enumerate(shuffled):
		if c is None or not is_in_circle(c, p):
			c = _make_circle_one_point(shuffled[:i + 1], p)
	return c

def _make_circle_one_point(points, p):
	c = (p[0], p[1], 0.0)
	for (i, q) in enumerate(points):
		if not is_in_circle(c, q):
			if c[2] == 0.0:
				c = make_diameter(p, q)
			else:
				c = _make_circle_two_points(points[:i + 1], p, q)
	return c

def _make_circle_two_points(points, p, q):
	circ = make_diameter(p, q)
	left = None
	right = None
	(px, py) = p
	(qx, qy) = q
	for r in points:
		if is_in_circle(circ, r):
			continue
		cross = _cross_product(px, py, qx, qy, r[0], r[1])
		c = make_circumcircle(p, q, r)
		if c is None:
			continue
		elif cross > 0.0 and (left is None or _cross_product(px, py, qx, qy, c[0], c[1]) > _cross_product(px, py, qx, qy, left[0], left[1])):
			left = c
		elif cross < 0.0 and (right is None or _cross_product(px, py, qx, qy, c[0], c[1]) < _cross_product(px, py, qx, qy, right[0], right[1])):
			right = c
	if left is None and right is None:
		return circ
	elif left is None:
		return right
	elif right is None:
		return left
	else:
		return left if left[2] <= right[2] else right

def make_diameter(a, b):
	cx = (a[0] + b[0]) / 2.0
	cy = (a[1] + b[1]) / 2.0
	r0 = math.hypot(cx - a[0], cy - a[1])
	r1 = math.hypot(cx - b[0], cy - b[1])
	return (cx, cy, max(r0, r1))

def make_circumcircle(a, b, c):
	ox = (min(a[0], b[0], c[0]) + max(a[0], b[0], c[0])) / 2.0
	oy = (min(a[1], b[1], c[1]) + max(a[1], b[1], c[1])) / 2.0
	ax = a[0] - ox
	ay = a[1] - oy
	bx = b[0] - ox
	by = b[1] - oy
	cx = c[0] - ox
	cy = c[1] - oy
	d = (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by)) * 2.0
	if d == 0.0:
		return None
	x = ox + ((ax * ax + ay * ay) * (by - cy) + (bx * bx + by * by) * (cy - ay) + (cx * cx + cy * cy) * (ay - by)) / d
	y = oy + ((ax * ax + ay * ay) * (cx - bx) + (bx * bx + by * by) * (ax - cx) + (cx * cx + cy * cy) * (bx - ax)) / d
	ra = math.hypot(x - a[0], y - a[1])
	rb = math.hypot(x - b[0], y - b[1])
	rc = math.hypot(x - c[0], y - c[1])
	return (x, y, max(ra, rb, rc))
_MULTIPLICATIVE_EPSILON = 1 + 1e-14

def is_in_circle(c, p):
	return c is not None and math.hypot(p[0] - c[0], p[1] - c[1]) <= c[2] * _MULTIPLICATIVE_EPSILON

def _cross_product(x0, y0, x1, y1, x2, y2):
	return (x1 - x0) * (y2 - y0) - (y1 - y0) * (x2 - x0)
n = int(input())
points = [list(map(int, input().split())) for _ in range(n)]
print(make_circle(points)[2])


n = int(input())
x = []
y = []
import math
for i in range(n):
	(xi, yi) = map(int, input().split())
	x.append(xi)
	y.append(yi)
if n == 2:
	x.append(x[0] + 10 ** (-8))
	y.append(y[0] + 10 ** (-8))
import itertools

def get_circle_center_and_radius(x1, y1, x2, y2, x3, y3):
	d = 2 * ((y1 - y3) * (x1 - x2) - (y1 - y2) * (x1 - x3))
	if d == 0:
		return ((0, 0), 10 ** 10)
	x = ((y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)) / d
	y = ((x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)) / -d
	r = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
	return ((x, y), r)
ans = 10 ** 10
e = 10 ** (-8)
for (i, j, k) in itertools.product(range(n), range(n), range(n)):
	if i != j and i != k and (j != k):
		(x1, y1, x2, y2, x3, y3) = (x[i], y[i], x[j], y[j], x[k], y[k])
		((xc, yc), r) = get_circle_center_and_radius(x1, y1, x2, y2, x3, y3)
		flag = True
		for l in range(n):
			if (x[l] - xc) ** 2 + (y[l] - yc) ** 2 > r ** 2 * (1 + e):
				flag = False
				break
		if flag:
			ans = min(ans, r)
for (i, j) in itertools.product(range(n), range(n)):
	xc = (x[i] + x[j]) / 2
	yc = (y[i] + y[j]) / 2
	r = (x[i] - xc) ** 2 + (y[i] - yc) ** 2
	flag = True
	for l in range(n):
		if (x[l] - xc) ** 2 + (y[l] - yc) ** 2 > r * (1 + e):
			flag = False
			break
	if flag:
		ans = min(ans, r ** (1 / 2))
print(ans)


N = int(input())
A = []
for i in range(N):
	(x, y) = map(int, input().split())
	A.append((x, y))

def c(P1, P2, P3):
	(x1, y1) = P1
	(x2, y2) = P2
	(x3, y3) = P3
	a = 2 * (x1 - x2)
	b = 2 * (y1 - y2)
	p = x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2
	c = 2 * (x1 - x3)
	d = 2 * (y1 - y3)
	q = x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2
	det = a * d - b * c
	x = d * p - b * q
	y = a * q - c * p
	if det < 0:
		x = -x
		y = -y
		det = -det
	if det != 0:
		x /= det
		y /= det
	r = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
	return (x, y, r)
ans = 200000 ** 2
for i in range(N - 1):
	for j in range(i + 1, N):
		f = 0
		(x1, y1) = (A[i][0], A[i][1])
		(x2, y2) = (A[j][0], A[j][1])
		(x, y) = ((x1 + x2) / 2, (y1 + y2) / 2)
		r = ((x1 - x) ** 2 + (y1 - y) ** 2) ** 0.5
		for (a, b) in A:
			d = ((a - x) ** 2 + (b - y) ** 2) ** 0.5
			if d > r:
				f = 1
				break
		if f == 0:
			ans = min(ans, r)
f = 0
if N > 2:
	for i in range(N - 2):
		for j in range(i + 1, N - 1):
			for k in range(j + 1, N):
				f = 0
				(x, y, r) = c(A[i], A[j], A[k])
				for (a, b) in A:
					d = ((a - x) ** 2 + (b - y) ** 2) ** 0.5
					if d > r:
						f = 1
						break
				if f == 0:
					ans = min(ans, r)
print(ans)


from itertools import combinations
import math
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n = int(readline())
m = map(int, read().split())
points = [(x, y) for (x, y) in zip(m, m)]
if n == 2:
	[(a, b), (c, d)] = points
	print(math.hypot(a - c, b - d) / 2)
	quit()

def center(a, b, c):
	M = pow(a[0], 2) - pow(b[0], 2) + pow(a[1], 2) - pow(b[1], 2)
	N = pow(a[0], 2) - pow(c[0], 2) + pow(a[1], 2) - pow(c[1], 2)
	Yab = a[1] - b[1]
	Xab = a[0] - b[0]
	Yac = a[1] - c[1]
	Xac = a[0] - c[0]
	d = Yac * Xab - Yab * Xac
	if d == 0:
		return None
	x = (M * Yac - N * Yab) / (2 * d)
	y = -(M * Xac - N * Xab) / (2 * d)
	r = math.hypot(x - a[0], y - a[1])
	return (x, y, r)
centers = []
for (a, b, c) in combinations(points, 3):
	cen = center(a, b, c)
	if cen is None:
		continue
	centers.append(cen)
r = 0
for (a, b) in combinations(points, 2):
	tr = math.hypot(a[0] - b[0], a[1] - b[1]) / 2
	if r > tr:
		continue
	r = tr
	cen = ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2, r)
centers.append(cen)
res = 1000
for (cx, cy, cr) in centers:
	for (x, y) in points:
		tr = math.hypot(x - cx, y - cy)
		if tr > cr + 1e-05:
			break
	else:
		if cr < res:
			res = cr
print(res)


N = int(input())
xy = [list(map(int, input().split())) for _ in range(N)]
cand = []
for i in range(N):
	(xa, ya) = xy[i]
	for j in range(i + 1, N):
		(xb, yb) = xy[j]
		cand.append([(xa + xb) / 2, (ya + yb) / 2])
		for k in range(j + 1, N):
			(xc, yc) = xy[k]
			if (xa - xb) * (ya - yc) - (xa - xc) * (ya - yb) != 0:
				x = (ya - yc) * (xa ** 2 + ya ** 2 - xb ** 2 - yb ** 2) - (ya - yb) * (xa ** 2 + ya ** 2 - xc ** 2 - yc ** 2)
				y = -(xa - xc) * (xa ** 2 + ya ** 2 - xb ** 2 - yb ** 2) + (xa - xb) * (xa ** 2 + ya ** 2 - xc ** 2 - yc ** 2)
				x /= 2 * ((xa - xb) * (ya - yc) - (xa - xc) * (ya - yb))
				y /= 2 * ((xa - xb) * (ya - yc) - (xa - xc) * (ya - yb))
				cand.append([x, y])
ans = float('inf')
for (x, y) in cand:
	d = 0
	for i in range(N):
		d = max(d, ((xy[i][0] - x) ** 2 + (xy[i][1] - y) ** 2) ** 0.5)
	ans = min(ans, d)
print(ans)


def gaishin(p, q, r):
	a = ((q[0] - r[0]) ** 2 + (q[1] - r[1]) ** 2) ** 0.5
	b = ((r[0] - p[0]) ** 2 + (r[1] - p[1]) ** 2) ** 0.5
	c = ((p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2) ** 0.5
	cosp = (b ** 2 + c ** 2 - a ** 2) / (2 * b * c)
	cosq = (c ** 2 + a ** 2 - b ** 2) / (2 * c * a)
	cosr = (a ** 2 + b ** 2 - c ** 2) / (2 * a * b)
	if cosp >= 1:
		cosp = 1
	if cosp <= -1:
		cosp = -1
	if cosq >= 1:
		cosq = 1
	if cosq <= -1:
		cosq = -1
	if cosr >= 1:
		cosr = 1
	if cosr <= -1:
		cosr = -1
	sinp = (1 - cosp ** 2) ** 0.5
	sinq = (1 - cosq ** 2) ** 0.5
	sinr = (1 - cosr ** 2) ** 0.5
	sin2p = 2 * sinp * cosp
	sin2q = 2 * sinq * cosq
	sin2r = 2 * sinr * cosr
	if sin2p + sin2q + sin2r == 0:
		infinite = float('inf')
		return (infinite, infinite)
	x = (sin2p * p[0] + sin2q * q[0] + sin2r * r[0]) / (sin2p + sin2q + sin2r)
	y = (sin2p * p[1] + sin2q * q[1] + sin2r * r[1]) / (sin2p + sin2q + sin2r)
	return (x, y)
N = int(input())
A = []
for i in range(N):
	(x, y) = map(int, input().split())
	A.append((x, y))
INF = float('inf')
ans = INF
for i in range(N):
	for j in range(i + 1, N):
		z = ((A[i][0] + A[j][0]) / 2, (A[i][1] + A[j][1]) / 2)
		dx = A[i][0] - A[j][0]
		dy = A[i][1] - A[j][1]
		hankei = (dx ** 2 + dy ** 2) ** 0.5 / 2
		Flag = True
		for t in range(N):
			if t == i or t == j:
				continue
			temp = ((z[0] - A[t][0]) ** 2 + (z[1] - A[t][1]) ** 2) ** 0.5
			hankei = max(hankei, temp)
		ans = min(ans, hankei)
if N == 2:
	print(ans)
	exit()
for i in range(N):
	for j in range(i + 1, N):
		for k in range(j + 1, N):
			p = A[i]
			q = A[j]
			r = A[k]
			z = gaishin(p, q, r)
			hankei = 0
			for t in range(N):
				temp = ((z[0] - A[t][0]) ** 2 + (z[1] - A[t][1]) ** 2) ** 0.5
				hankei = max(hankei, temp)
			ans = min(ans, hankei)
print(ans)


import math
n = int(input())
xy = [list(map(float, input().split())) for _ in range(n)]
ret = 100000000

def update(px, py):
	global ret
	r = 0
	for p in range(n):
		r = max(r, math.hypot(px - xy[p][0], py - xy[p][1]))
	ret = min(ret, r)
for i in range(n):
	x1 = xy[i][0]
	y1 = xy[i][1]
	for j in range(i + 1, n):
		x2 = xy[j][0]
		y2 = xy[j][1]
		update((x1 + x2) / 2, (y1 + y2) / 2)
		for k in range(j + 1, n):
			x3 = xy[k][0]
			y3 = xy[k][1]
			d = 2 * (y1 - y3) * (x1 - x2) - 2 * (y1 - y2) * (x1 - x3)
			if d != 0:
				px = ((y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)) / d
				py = ((x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)) / -d
				update(px, py)
print(ret)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
import time, random
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
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 list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

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

def distance(x1, y1, x2, y2):
	return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)

def distance_p(a, b):
	return distance(a[0], a[1], b[0], b[1])

def distance3(p1, p2, p3):
	(x1, y1) = p1
	(x2, y2) = p2
	(x3, y3) = p3
	ax = x2 - x1
	ay = y2 - y1
	bx = x3 - x1
	by = y3 - y1
	r = (ax * bx + ay * by) / (ax * ax + ay * ay)
	pt = (x1 + r * ax, y1 + r * ay, 0)
	return distance_p(pt, p3)

def gaisin(xy):
	a = xy[0][0]
	b = xy[0][1]
	c = xy[1][0]
	d = xy[1][1]
	e = xy[2][0]
	f = xy[2][1]
	t1 = (e - a) * (a ** 2 + b ** 2 - c ** 2 - d ** 2)
	t2 = (c - a) * (a ** 2 + b ** 2 - e ** 2 - f ** 2)
	t3 = 2 * (e - a) * (b - d) - 2 * (c - a) * (b - f)
	py = (t1 - t2) / t3
	if c - a != 0:
		px = (2 * (b - d) * py - a ** 2 - b ** 2 + c ** 2 + d ** 2) / (2 * (c - a))
	else:
		px = (2 * (b - f) * py - a ** 2 - b ** 2 + e ** 2 + f ** 2) / (2 * (e - a))
	return (px, py)

def main():
	n = I()
	xy = [LI() for _ in range(n)]
	if n == 2:
		return distance_p(xy[0], xy[1]) / 2
	r = inf
	for i in range(n):
		t1 = xy[i]
		for j in range(i + 1, n):
			t2 = xy[j]
			p = ((t1[0] + t2[0]) / 2, (t1[1] + t2[1]) / 2)
			tr = max((distance_p(p, xy[l]) for l in range(n)))
			if r > tr:
				r = tr
			xf = t1[0] == t2[0]
			yf = t1[1] == t2[1]
			for k in range(j + 1, n):
				t3 = xy[k]
				if distance3(t1, t2, t3) < eps:
					continue
				p = gaisin([t1, t2, t3])
				tr = max((distance_p(p, xy[l]) for l in range(n)))
				if r > tr:
					r = tr
	return r
print(main())


import math
from itertools import combinations
n = int(input())
xy = [list(map(int, input().split())) for i in range(n)]

def enc(i, j, k):
	(a, b) = i
	(c, d) = j
	(e, f) = k
	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:
		ymax = max(b, d, f)
		ymin = min(b, d, f)
		xmax = max(a, c, e)
		xmin = min(a, c, e)
		(px, py) = ((xmax - xmin) / 2, (ymax - ymin) / 2)
		r = math.hypot(xmax - xmin, ymax - ymin) / 2
	else:
		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)
	return (r, px, py)

def judge(r, px, py):
	ls = [math.hypot(px - x, py - y) for (x, y) in xy]
	if max(ls) <= r + 10 ** (-7):
		return True
	else:
		return False
ans = 10 ** 18
for (i, j) in combinations(xy, 2):
	(x1, y1) = i
	(x2, y2) = j
	px = (x1 + x2) / 2
	py = (y1 + y2) / 2
	r = math.hypot(x1 - x2, y1 - y2) / 2
	if judge(r, px, py):
		ans = min(ans, r)
for (i, j, k) in combinations(xy, 3):
	(r, px, py) = enc(i, j, k)
	if judge(r, px, py):
		ans = min(ans, r)
print(ans)


from math import hypot
EPS = 10 ** (-8)

def f(r):
	global n, xy
	cs = []
	for i in range(n):
		for j in range(i + 1, n):
			(x0, y0) = xy[i]
			(x1, y1) = xy[j]
			d = hypot(x1 - x0, y1 - y0)
			if r - d / 2 < EPS:
				continue
			h = (r ** 2 - (d / 2) ** 2) ** 0.5
			c = [(x0 + x1) / 2, (y0 + y1) / 2]
			cs.append([c[0] + h * (y0 - y1) / d, c[1] + h * (x1 - x0) / d])
			cs.append([c[0] - h * (y0 - y1) / d, c[1] - h * (x1 - x0) / d])
	for (cx, cy) in cs:
		if all((hypot(x - cx, y - cy) - r < EPS for (x, y) in xy)):
			return True
	return False
n = int(input())
xy = [list(map(int, input().split())) for _ in range(n)]
ok = 10 ** 9
ng = 0
while abs(ok - ng) > EPS:
	m = (ok + ng) / 2
	if f(m):
		ok = m
	else:
		ng = m
print(ok)


def calc1(x1, y1, x2, y2, x3, y3):
	a = x1 - x2
	b = y1 - y2
	c = x2 - x3
	d = y2 - y3
	if a * d - b * c == 0:
		return [0, 0, 0]
	x4 = (d * (x1 ** 2 + y1 ** 2 - (x2 ** 2 + y2 ** 2)) - b * (x2 ** 2 + y2 ** 2 - (x3 ** 2 + y3 ** 2))) / (2 * (a * d - b * c))
	y4 = (-c * (x1 ** 2 + y1 ** 2 - (x2 ** 2 + y2 ** 2)) + a * (x2 ** 2 + y2 ** 2 - (x3 ** 2 + y3 ** 2))) / (2 * (a * d - b * c))
	r = ((x1 - x4) ** 2 + (y1 - y4) ** 2) ** 0.5
	return [x4, y4, r]

def calc2(x1, y1, x2, y2):
	r = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5 / 2
	return [(x1 + x2) / 2, (y1 + y2) / 2, r]
eps = 10 ** (-9)
n = int(input())
arr = [list(map(int, input().split())) for _ in range(n)]
ans = 10 ** 18
for i in range(n):
	for j in range(i + 1, n):
		for k in range(j + 1, n):
			(cx, cy, r) = calc1(arr[i][0], arr[i][1], arr[j][0], arr[j][1], arr[k][0], arr[k][1])
			for l in range(n):
				(tx, ty) = arr[l]
				if (cx - tx) ** 2 + (cy - ty) ** 2 > r ** 2 + eps:
					break
			else:
				ans = min(ans, r)
for i in range(n):
	for j in range(i + 1, n):
		(cx, cy, r) = calc2(arr[i][0], arr[i][1], arr[j][0], arr[j][1])
		for k in range(n):
			(tx, ty) = arr[k]
			if (cx - tx) ** 2 + (cy - ty) ** 2 > r ** 2 + eps:
				break
		else:
			ans = min(ans, r)
print(ans)


import itertools
n = int(input())
xy = []
for i in range(n):
	xy.append(list(map(int, input().split())))
R = []
if n >= 3:
	for (i, j, k) in itertools.combinations(xy, 3):
		if (j[0] - i[0]) * (k[0] - i[0]) + (j[1] - i[1]) * (k[1] - i[1]) <= 0:
			r = ((j[0] - k[0]) ** 2 + (j[1] - k[1]) ** 2) ** 0.5 / 2
			R.append(r)
		elif (i[0] - j[0]) * (k[0] - j[0]) + (i[1] - j[1]) * (k[1] - j[1]) <= 0:
			r = ((i[0] - k[0]) ** 2 + (i[1] - k[1]) ** 2) ** 0.5 / 2
			R.append(r)
		elif (i[0] - k[0]) * (j[0] - k[0]) + (i[1] - k[1]) * (j[1] - k[1]) <= 0:
			r = ((i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2) ** 0.5 / 2
			R.append(r)
		else:
			x1 = j[0] - i[0]
			x2 = k[0] - i[0]
			y1 = j[1] - i[1]
			y2 = k[1] - i[1]
			cos = (x1 * x2 + y1 * y2) / ((x1 ** 2 + y1 ** 2) ** 0.5 * (x2 ** 2 + y2 ** 2) ** 0.5)
			sin = (1 - cos ** 2) ** 0.5
			if sin != 0:
				r = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5 / 2 / sin
				R.append(r)
			else:
				x = [i[0], j[0], k[0]]
				y = [i[1], j[1], k[1]]
				r = ((max(x) - min(x)) ** 2 + (max(y) - min(y)) ** 2) ** 0.5
				R.append(r / 2)
else:
	r = ((xy[0][0] - xy[1][0]) ** 2 + (xy[0][1] - xy[1][1]) ** 2) ** 0.5 / 2
	R.append(r)
print(max(R))


import cmath
import itertools
import math
import random
from collections import defaultdict
INF = float('inf')
PI = cmath.pi
TAU = cmath.pi * 2
EPS = 1e-10

class Point:
	CCW_COUNTER_CLOCKWISE = 1
	CCW_CLOCKWISE = -1
	CCW_ONLINE_BACK = 2
	CCW_ONLINE_FRONT = -2
	CCW_ON_SEGMENT = 0

	def __init__(self, x: float, y: float):
		self.c = complex(x, y)

	@property
	def x(self):
		return self.c.real

	@property
	def y(self):
		return self.c.imag

	@staticmethod
	def from_complex(c: complex):
		return Point(c.real, c.imag)

	@staticmethod
	def from_polar(r: float, phi: float):
		c = cmath.rect(r, phi)
		return Point(c.real, c.imag)

	def __add__(self, p):
		c = self.c + p.c
		return Point(c.real, c.imag)

	def __iadd__(self, p):
		self.c += p.c
		return self

	def __sub__(self, p):
		c = self.c - p.c
		return Point(c.real, c.imag)

	def __isub__(self, p):
		self.c -= p.c
		return self

	def __mul__(self, f: float):
		c = self.c * f
		return Point(c.real, c.imag)

	def __imul__(self, f: float):
		self.c *= f
		return self

	def __truediv__(self, f: float):
		c = self.c / f
		return Point(c.real, c.imag)

	def __itruediv__(self, f: float):
		self.c /= f
		return self

	def __repr__(self):
		return '({}, {})'.format(round(self.x, 10), round(self.y, 10))

	def __neg__(self):
		c = -self.c
		return Point(c.real, c.imag)

	def __eq__(self, p):
		return abs(self.c - p.c) < EPS

	def __abs__(self):
		return abs(self.c)

	@staticmethod
	def ccw(a, b, c):
		b = b - a
		c = c - a
		det = b.det(c)
		if det > EPS:
			return Point.CCW_COUNTER_CLOCKWISE
		if det < -EPS:
			return Point.CCW_CLOCKWISE
		if b.dot(c) < -EPS:
			return Point.CCW_ONLINE_BACK
		if c.norm() - b.norm() > EPS:
			return Point.CCW_ONLINE_FRONT
		return Point.CCW_ON_SEGMENT

	def dot(self, p):
		return self.x * p.x + self.y * p.y

	def det(self, p):
		return self.x * p.y - self.y * p.x

	def dist(self, p):
		return abs(self.c - p.c)

	def norm(self):
		return abs(self.c)

	def phase(self):
		return cmath.phase(self.c)

	def angle(self, p, q):
		return (cmath.phase(q.c - self.c) - cmath.phase(p.c - self.c) + PI) % TAU - PI

	def area(self, p, q):
		return abs((p - self).det(q - self) / 2)

	def projection_point(self, p, q, allow_outer=False):
		diff_q = q - p
		r = (self - p).dot(diff_q) / abs(diff_q)
		phase = diff_q.phase()
		ret = Point.from_polar(r, phase) + p
		if allow_outer or (p - ret).dot(q - ret) < EPS:
			return ret
		return None

	def reflection_point(self, p, q):
		r = abs(self - p)
		angle = p.angle(q, self)
		angle = (q - p).phase() - angle
		return Point.from_polar(r, angle) + p

	def on_segment(self, p, q, allow_side=True):
		if not allow_side and (self == p or self == q):
			return False
		return abs((p - self).det(q - self)) < EPS and (p - self).dot(q - self) < EPS

	@staticmethod
	def circumstance_of(p1, p2, p3):
		if abs((p2 - p1).det(p3 - p1)) < EPS:
			return None
		a = (p2.x - p3.x) ** 2 + (p2.y - p3.y) ** 2
		b = (p3.x - p1.x) ** 2 + (p3.y - p1.y) ** 2
		c = (p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2
		num = p1 * a * (b + c - a) + p2 * b * (c + a - b) + p3 * c * (a + b - c)
		den = a * (b + c - a) + b * (c + a - b) + c * (a + b - c)
		return num / den

class Line:

	def __init__(self, a: float, b: float, c: float):
		self.a = a
		self.b = b
		self.c = c

	@staticmethod
	def from_gradient(grad: float, intercept: float):
		return Line(grad, -1, intercept)

	@staticmethod
	def from_segment(p1, p2):
		a = p2.y - p1.y
		b = p1.x - p2.x
		c = p2.y * (p2.x - p1.x) - p2.x * (p2.y - p1.y)
		return Line(a, b, c)

	@property
	def gradient(self):
		return INF if self.b == 0 else -self.a / self.b

	@property
	def intercept(self):
		return INF if self.b == 0 else -self.c / self.b

	def is_parallel_to(self, l):
		return abs(Point.from_rect(self.a, self.b).det(Point.from_rect(l.a, l.b))) < EPS

	def is_orthogonal_to(self, l):
		return abs(Point.from_rect(self.a, self.b).dot(Point.from_rect(l.a, l.b))) < EPS

	def intersection_point(self, l):
		(a1, b1, c1) = (self.a, self.b, self.c)
		(a2, b2, c2) = (l.a, l.b, l.c)
		det = a1 * b2 - a2 * b1
		if abs(det) < EPS:
			return None
		x = (b1 * c2 - b2 * c1) / det
		y = (a2 * c1 - a1 * c2) / det
		return Point.from_rect(x, y)

	def dist(self, p):
		raise NotImplementedError()

	def has_point(self, p):
		return abs(self.a * p.x + self.b * p.y + self.c) < EPS

class Segment:

	def __init__(self, p1, p2):
		self.p1 = p1
		self.p2 = p2

	def norm(self):
		return abs(self.p1 - self.p2)

	def phase(self):
		return (self.p2 - self.p1).phase()

	def is_parallel_to(self, s):
		return abs((self.p1 - self.p2).det(s.p1 - s.p2)) < EPS

	def is_orthogonal_to(self, s):
		return abs((self.p1 - self.p2).dot(s.p1 - s.p2)) < EPS

	def intersects_with(self, s, allow_side=True):
		if self.is_parallel_to(s):
			return s.p1.on_segment(self.p1, self.p2, allow_side) or s.p2.on_segment(self.p1, self.p2, allow_side) or self.p1.on_segment(s.p1, s.p2, allow_side) or self.p2.on_segment(s.p1, s.p2, allow_side)
		else:
			det_upper = EPS if allow_side else -EPS
			ok = True
			ok &= (self.p2 - self.p1).det(s.p1 - self.p1) * (self.p2 - self.p1).det(s.p2 - self.p1) < det_upper
			ok &= (s.p2 - s.p1).det(self.p1 - s.p1) * (s.p2 - s.p1).det(self.p2 - s.p1) < det_upper
			return ok

	def closest_point(self, p):
		d = (p - self.p1).dot(self.p2 - self.p1) / self.norm()
		if d < EPS:
			return self.p1
		if -EPS < d - self.norm():
			return self.p2
		return Point.from_polar(d, (self.p2 - self.p1).phase()) + self.p1

	def dist(self, p):
		return abs(p - self.closest_point(p))

	def dist_segment(self, s):
		if self.intersects_with(s):
			return 0.0
		return min(self.dist(s.p1), self.dist(s.p2), s.dist(self.p1), s.dist(self.p2))

	def has_point(self, p, allow_side=True):
		return p.on_segment(self.p1, self.p2, allow_side=allow_side)

class Polygon:

	def __init__(self, points):
		self.points = points

	def iter2(self):
		return list(zip(self.points, self.points[1:] + self.points[:1]))

	def iter3(self):
		return list(zip(self.points, self.points[1:] + self.points[:1], self.points[2:] + self.points[:2]))

	def area(self):
		dets = []
		for (p, q) in self.iter2():
			dets.append(p.det(q))
		return abs(math.fsum(dets)) / 2

	def is_convex(self, allow_straight=False, allow_collapsed=False):
		ccw = []
		for (a, b, c) in self.iter3():
			ccw.append(Point.ccw(a, b, c))
		ccw = set(ccw)
		if len(ccw) == 1:
			if ccw == {Point.CCW_CLOCKWISE}:
				return True
			if ccw == {Point.CCW_COUNTER_CLOCKWISE}:
				return True
		if allow_straight and len(ccw) == 2:
			if ccw == {Point.CCW_ONLINE_FRONT, Point.CCW_CLOCKWISE}:
				return True
			if ccw == {Point.CCW_ONLINE_FRONT, Point.CCW_COUNTER_CLOCKWISE}:
				return True
		if allow_collapsed and len(ccw) == 3:
			return ccw == {Point.CCW_ONLINE_FRONT, Point.CCW_ONLINE_BACK, Point.CCW_ON_SEGMENT}
		return False

	def has_point_on_edge(self, p):
		for (a, b) in self.iter2():
			if p.on_segment(a, b):
				return True
		return False

	def contains(self, p, allow_on_edge=True):
		angles = []
		for (a, b) in self.iter2():
			if p.on_segment(a, b):
				return allow_on_edge
			angles.append(p.angle(a, b))
		return abs(math.fsum(angles)) > EPS

	@staticmethod
	def convex_hull(points, allow_straight=False):
		points = points[:]
		points.sort(key=lambda p: (p.x, p.y))
		det_lower = -EPS if allow_straight else EPS
		sz = 0
		ret = [None] * (len(points) * 2)
		for p in points:
			while sz > 1 and (ret[sz - 1] - ret[sz - 2]).det(p - ret[sz - 1]) < det_lower:
				sz -= 1
			ret[sz] = p
			sz += 1
		floor = sz
		for p in reversed(points[:-1]):
			while sz > floor and (ret[sz - 1] - ret[sz - 2]).det(p - ret[sz - 1]) < det_lower:
				sz -= 1
			ret[sz] = p
			sz += 1
		ret = ret[:sz - 1]
		if allow_straight and len(ret) > len(points):
			ret = points
		return ret

	@staticmethod
	def diameter(points):
		points = Polygon.convex_hull(points, allow_straight=False)
		if len(points) == 1:
			return 0.0
		if len(points) == 2:
			return abs(points[0] - points[1])
		si = points.index(min(points, key=lambda p: (p.x, p.y)))
		sj = points.index(max(points, key=lambda p: (p.x, p.y)))
		n = len(points)
		ret = 0.0
		(i, j) = (si, sj)
		while i != sj or j != si:
			ret = max(ret, abs(points[i] - points[j]))
			ni = (i + 1) % n
			nj = (j + 1) % n
			if (points[ni] - points[i]).det(points[nj] - points[j]) > 0:
				j = nj
			else:
				i = ni
		return ret

	def convex_cut_by_line(self, line_p1, line_p2):
		n = len(self.points)
		line = Line.from_segment(line_p1, line_p2)
		on_line_points = []
		for (i, p) in enumerate(self.points):
			if line.has_point(p):
				on_line_points.append(i)
		has_on_line_edge = False
		if len(on_line_points) >= 3:
			has_on_line_edge = True
		elif len(on_line_points) == 2:
			has_on_line_edge = abs(on_line_points[0] - on_line_points[1]) in [1, n - 1]
		if has_on_line_edge:
			for p in self.points:
				ccw = Point.ccw(line_p1, line_p2, p)
				if ccw == Point.CCW_COUNTER_CLOCKWISE:
					return (Polygon(self.points[:]), None)
				if ccw == Point.CCW_CLOCKWISE:
					return (None, Polygon(self.points[:]))
		ret_lefts = []
		ret_rights = []
		d = line_p2 - line_p1
		for (p, q) in self.iter2():
			det_p = d.det(p - line_p1)
			det_q = d.det(q - line_p1)
			if det_p > -EPS:
				ret_lefts.append(p)
			if det_p < EPS:
				ret_rights.append(p)
			if det_p * det_q < -EPS:
				intersection = line.intersection_point(Line.from_segment(p, q))
				ret_lefts.append(intersection)
				ret_rights.append(intersection)
		l = Polygon(ret_lefts) if len(ret_lefts) > 1 else None
		r = Polygon(ret_rights) if len(ret_rights) > 1 else None
		return (l, r)

class Circle:

	def __init__(self, o, r):
		self.o = o
		self.r = r

	def __eq__(self, other):
		return self.o == other.o and abs(self.r - other.r) < EPS

	def ctc(self, c):
		if self.o == c.o:
			return INF if abs(self.r - c.r) < EPS else 0
		d = self.o.dist(c.o) - self.r - c.r
		if d > EPS:
			return 4
		elif d > -EPS:
			return 3
		elif d + min(self.r, c.r) * 2 > EPS:
			return 2
		elif d + min(self.r, c.r) * 2 > -EPS:
			return 1
		return 0

	def has_point_on_edge(self, p):
		return abs(self.o.dist(p) - self.r) < EPS

	def contains(self, p, allow_on_edge=True):
		if allow_on_edge:
			return self.o.dist(p) - self.r < EPS
		else:
			return self.o.dist(p) - self.r < -EPS

	def area(self):
		return self.r ** 2 * PI

	def circular_segment_area(self, angle):
		sector_area = self.area() * angle / TAU
		return sector_area - self.r ** 2 * math.sin(angle) / 2

	def intersection_points(self, other, allow_outer=False):
		if isinstance(other, Segment):
			return self.intersection_points_with_segment(other, allow_outer=allow_outer)
		if isinstance(other, Circle):
			return self.intersection_points_with_circle(other)
		raise NotImplementedError()

	def intersection_points_with_segment(self, s, allow_outer=False):
		projection_point = self.o.projection_point(s.p1, s.p2, allow_outer=True)
		dist = self.o.dist(projection_point)
		if dist - self.r > EPS:
			return []
		if dist - self.r > -EPS:
			if allow_outer or s.has_point(projection_point):
				return [projection_point]
			else:
				return []
		diff = Point.from_polar(math.sqrt(self.r ** 2 - dist ** 2), s.phase())
		ret1 = projection_point + diff
		ret2 = projection_point - diff
		ret = []
		if allow_outer or s.has_point(ret1):
			ret.append(ret1)
		if allow_outer or s.has_point(ret2):
			ret.append(ret2)
		return ret

	def intersection_points_with_circle(self, other):
		ctc = self.ctc(other)
		if not 1 <= ctc <= 3:
			return []
		if ctc == 3:
			return [Point.from_polar(self.r, (other.o - self.o).phase()) + self.o]
		if ctc == 1:
			if self.r > other.r:
				return [Point.from_polar(self.r, (other.o - self.o).phase()) + self.o]
			else:
				return [Point.from_polar(self.r, (self.o - other.o).phase()) + self.o]
		assert ctc == 2
		a = other.r
		b = self.r
		c = self.o.dist(other.o)
		cos_a = (b ** 2 + c ** 2 - a ** 2) / (2 * b * c)
		angle = math.acos(cos_a)
		phi = (other.o - self.o).phase()
		return [self.o + Point.from_polar(self.r, phi + angle), self.o + Point.from_polar(self.r, phi - angle)]

	def tangent_points_with_point(self, p):
		dist = self.o.dist(p)
		if dist - self.r < -EPS:
			return []
		if dist - self.r < EPS:
			return [Point(p.x, p.y)]
		a = math.sqrt(dist ** 2 - self.r ** 2)
		b = self.r
		c = dist
		cos_a = (b ** 2 + c ** 2 - a ** 2) / (2 * b * c)
		angle = math.acos(cos_a)
		phi = (p - self.o).phase()
		return [self.o + Point.from_polar(self.r, phi + angle), self.o + Point.from_polar(self.r, phi - angle)]

	def tangent_points_with_circle(self, other):
		ctc = self.ctc(other)
		if ctc > 4:
			raise ValueError('2つの円が同一です')
		if ctc == 0:
			return []
		if ctc == 1:
			return self.intersection_points_with_circle(other)
		assert ctc in (2, 3, 4)
		ret = []
		if abs(self.r - other.r) < EPS:
			phi = (other.o - self.o).phase()
			ret.append(self.o + Point.from_polar(self.r, phi + PI / 2))
			ret.append(self.o + Point.from_polar(self.r, phi - PI / 2))
		else:
			intersection = self.o + (other.o - self.o) / (self.r - other.r) * self.r
			ret += self.tangent_points_with_point(intersection)
		intersection = self.o + (other.o - self.o) / (self.r + other.r) * self.r
		ret += self.tangent_points_with_point(intersection)
		return ret

	@staticmethod
	def circumscribed_of(p1, p2, p3):
		if p1.on_segment(p2, p3):
			return Circle((p2 + p3) / 2, p2.dist(p3) / 2)
		if p2.on_segment(p1, p3):
			return Circle((p1 + p3) / 2, p1.dist(p3) / 2)
		if p3.on_segment(p1, p2):
			return Circle((p1 + p2) / 2, p1.dist(p2) / 2)
		o = Point.circumstance_of(p1, p2, p3)
		return Circle(o, o.dist(p1))

	@staticmethod
	def min_enclosing_circle(points, n):
		if len(points) <= 1:
			return Circle(points[0], 0)
		if len(points) == 2:
			return Circle((points[0] + points[1]) / 2, points[0].dist(points[1]) / 2)

		def mid(p1, p2):
			return Circle((p1 + p2) / 2, p1.dist(p2) / 2)
		points = points[:]
		random.shuffle(points)
		ret = mid(points[0], points[1])
		for i in range(2, n):
			if ret.contains(points[i]):
				continue
			ret = mid(points[0], points[i])
			for j in range(1, i):
				if ret.contains(points[j]):
					continue
				ret = mid(points[j], points[i])
				for k in range(0, j):
					if ret.contains(points[k]):
						continue
					ret = Circle.circumscribed_of(points[k], points[j], points[i])
		return ret

def resolve():
	N = int(input())
	XY = [list(map(int, input().split())) for _ in range(N)]
	points = []
	for (x, y) in XY:
		points.append(Point(x, y))
	ans = Circle.min_enclosing_circle(points, N)
	print(ans.r)

def __starting_point():
	resolve()
__starting_point()


import sys
sys.setrecursionlimit(700000)

def s_in():
	return input()

def n_in():
	return int(input())

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

def print_l(l):
	print(' '.join(map(str, l)))

class Interval:

	def __init__(self, li):
		self.li = li
		self.n = len(li)
		self.sum_li = [li[0]]
		for i in range(1, self.n):
			self.sum_li.append(self.sum_li[i - 1] + li[i])

	def sum(self, a, b=None):
		if b is None:
			return self.sum(0, a)
		res = self.sum_li[min(self.n - 1, b - 1)]
		if a > 0:
			res -= self.sum_li[a - 1]
		return res
n = n_in()
xy = [l_in() for _ in range(n)]
left = 0
right = 2000
from itertools import combinations
import math

def check(r):
	allprox = True
	for ((x1, y1), (x2, y2)) in combinations(xy, 2):
		dx = x1 - x2
		dy = y1 - y2
		d2 = dx * dx + dy * dy
		if d2 < 10 ** (-16):
			continue
		allprox = False
		if d2 / 4 > r * r:
			continue
		h = math.sqrt(r * r - d2 / 4)
		d = math.sqrt(d2)
		(px, py) = ((x1 + x2) / 2, (y1 + y2) / 2)
		(qx, qy) = (px - dy / d * h, py + dx / d * h)
		if all(((qx - x3) * (qx - x3) + (qy - y3) * (qy - y3) <= r * r for (x3, y3) in xy if (x1 != x3 or y1 != y3) and (x2 != x3 or y2 != y3))):
			return True
		(qx, qy) = (px + dy / d * h, py - dx / d * h)
		if all(((qx - x3) * (qx - x3) + (qy - y3) * (qy - y3) <= r * r for (x3, y3) in xy if (x1 != x3 or y1 != y3) and (x2 != x3 or y2 != y3))):
			return True
	else:
		return allprox
while right - left > 10 ** (-10):
	mid = (left + right) / 2
	if check(mid):
		right = mid
	else:
		left = mid
print((left + right) / 2)


import sys
INF = 1 << 60
MOD = 10 ** 9 + 7
sys.setrecursionlimit(2147483647)
input = lambda : sys.stdin.readline().rstrip()

def resolve():
	n = int(input())
	C = [complex(*map(int, input().split())) for _ in range(n)]
	res = INF
	for k in range(n):
		p1 = C[k]
		for j in range(k):
			p2 = C[j]
			for i in range(j):
				p3 = C[i]
				a = abs(p2 - p3) ** 2
				b = abs(p3 - p1) ** 2
				c = abs(p1 - p2) ** 2
				numerator = a * (b + c - a) * p1 + b * (c + a - b) * p2 + c * (a + b - c) * p3
				denominator = a * (b + c - a) + b * (c + a - b) + c * (a + b - c)
				if denominator == 0.0:
					continue
				center = numerator / denominator
				radius = -INF
				for p in C:
					radius = max(radius, abs(center - p))
				res = min(radius, res)
	for j in range(n):
		for i in range(n):
			center = (C[i] + C[j]) / 2
			radius = -INF
			for p in C:
				radius = max(radius, abs(center - p))
			res = min(radius, res)
	print(res)
resolve()


import itertools
N = int(input())
XY = [tuple(map(int, input().split())) for _ in range(N)]

def get_circle_center_and_radius(x1, y1, x2, y2, x3, y3):
	d = 2 * ((y1 - y3) * (x1 - x2) - (y1 - y2) * (x1 - x3))
	x = ((y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)) / d
	y = ((x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)) / -d
	r = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
	return (x, y, r)

def check_line(x1, y1, x2, y2, x3, y3):
	if x1 == x2 == x3:
		return True
	elif y1 == y2 == y3:
		return True
	elif (y2 - y1) * (x3 - x1) == (y3 - y1) * (x2 - x1):
		return True
	else:
		return False

def check_r(x, y, r):
	res = True
	for i in range(N):
		(x1, y1) = XY[i]
		if ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5 > r:
			res = False
			break
	return res
mnr = float('inf')
for i in range(N - 1):
	for j in range(i + 1, N):
		(x1, y1) = XY[i]
		(x2, y2) = XY[j]
		x = (x1 + x2) / 2
		y = (y1 + y2) / 2
		r = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5 / 2
		if check_r(x, y, r) and mnr > r:
			mnr = r
for (i, j, k) in list(itertools.combinations(range(N), 3)):
	(x1, y1) = XY[i]
	(x2, y2) = XY[j]
	(x3, y3) = XY[k]
	if check_line(x1, y1, x2, y2, x3, y3):
		continue
	(x, y, r) = get_circle_center_and_radius(x1, y1, x2, y2, x3, y3)
	if check_r(x, y, r) and mnr > r:
		mnr = r
print(mnr)


import math
import queue
from collections import deque, defaultdict
import heapq as hpq
from sys import stdin, setrecursionlimit
ipt = stdin.readline
setrecursionlimit(10 ** 7)

def main():
	n = int(ipt())
	pts = []

	def cp(i, j, r):
		(xi, yi) = i
		(xj, yj) = j
		cx = (xi + xj) / 2
		cy = (yi + yj) / 2
		vecx = yj - yi
		vecy = xi - xj
		d = math.sqrt(vecx ** 2 + vecy ** 2) / 2
		kt = math.sqrt(vecx ** 2 + vecy ** 2)
		vecx /= kt
		vecy /= kt
		if d > r:
			return []
		else:
			d2 = math.sqrt(r ** 2 - d ** 2)
			return [(cx + vecx * d2, cy + vecy * d2), (cx - vecx * d2, cy - vecy * d2)]

	def dist(i, j, r):
		(xi, yi) = i
		(xj, yj) = j
		return math.sqrt((xj - xi) ** 2 + (yj - yi) ** 2) <= r
	for _ in range(n):
		pts.append(tuple(map(int, ipt().split())))
	l = 0
	r = 1000
	while r - l > 10 ** (-7):
		mid = l + (r - l) / 2
		f = False
		for i in pts:
			for j in pts:
				if i == j:
					continue
				for li in cp(i, j, mid):
					f = True
					for k in pts:
						if k == i or k == j:
							continue
						if not dist(li, k, mid):
							f = False
					if f:
						break
				if f:
					break
			if f:
				break
		if f:
			r = mid
		else:
			l = mid
	print(l)
	return
main()


import sys
read = sys.stdin.buffer.read
readlines = sys.stdin.buffer.readlines
input = sys.stdin.buffer.readline
N = int(input())
X = [tuple(map(int, line.split())) for line in sys.stdin.buffer.readlines()]

def d(x, y, u, v):
	return (x - u) ** 2 + (y - v) ** 2

def check(x, y):
	r = 0
	nx = ny = 0
	for (u, v) in X:
		z = d(x, y, u, v)
		if z > r:
			r = z
			(nx, ny) = (u, v)
	return (nx, ny)
eps = 10 ** (-8)
alpha = 1
x = 500
y = 500
while True:
	(nx, ny) = check(x, y)
	if d(nx, ny, x, y) ** 0.5 < eps:
		break
	(x, y) = (x + (nx - x) * alpha, y + (ny - y) * alpha)
	alpha *= 0.999
	if alpha < eps:
		break
print(d(*check(x, y), x, y) ** 0.5)


def main():
	n = int(input())
	xy = [list(map(int, input().split())) for _ in [0] * n]

	def circle_cross(x1, y1, r1, x2, y2, r2):
		dist_2 = (x1 - x2) ** 2 + (y1 - y2) ** 2
		if dist_2 > (r1 + r2) ** 2:
			return (None, None, None, None)
		a = (dist_2 + r1 ** 2 - r2 ** 2) / 2
		r = (dist_2 * r1 ** 2 - a ** 2) ** 0.5
		ans_x1 = (a * (x1 - x2) + (y1 - y2) * r) / dist_2
		ans_x2 = (a * (x1 - x2) - (y1 - y2) * r) / dist_2
		ans_y1 = (a * (y1 - y2) - (x1 - x2) * r) / dist_2
		ans_y2 = (a * (y1 - y2) + (x1 - x2) * r) / dist_2
		return (ans_x1 + x2, ans_y1 + y2, ans_x2 + x2, ans_y2 + y2)

	def check(r):
		flag = 0
		point_list = []
		for i in range(n):
			(x1, y1) = xy[i]
			for j in range(i + 1, n):
				(x2, y2) = xy[j]
				if (x1 - x2) ** 2 + (y1 - y2) ** 2 <= 4 * r ** 2 - 10 ** (-9):
					temp = circle_cross(x1, y1, r, x2, y2, r)
					point_list.append((temp[0], temp[1]))
					point_list.append((temp[2], temp[3]))
		for (i, j) in point_list:
			for (x, y) in xy:
				if (i - x) ** 2 + (j - y) ** 2 > r ** 2 + 10 ** (-9):
					break
			else:
				return True
		return False

	def b_search(a, b, value, delta):
		while True:
			med = (a + b) / 2
			if abs(b - a) < delta:
				if value(a):
					return a
				else:
					return b
			elif value(med):
				b = med
			else:
				a = med
	print(b_search(0, 3000, check, 10 ** (-7)))
main()


def dist(A, B):
	return ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2) ** 0.5

def circumcenter(A, B, C):
	(x1, y1) = (B[0] - A[0], B[1] - A[1])
	(x2, y2) = (C[0] - A[0], C[1] - A[1])
	if abs(x1 * y2 - x2 * y1) < 1e-12:
		return None
	a = dist(B, C)
	b = dist(C, A)
	c = dist(A, B)
	cosA = (b ** 2 + c ** 2 - a ** 2) / (2 * b * c)
	cosB = (c ** 2 + a ** 2 - b ** 2) / (2 * c * a)
	cosC = (a ** 2 + b ** 2 - c ** 2) / (2 * a * b)
	x = (a * cosA * A[0] + b * cosB * B[0] + c * cosC * C[0]) / (a * cosA + b * cosB + c * cosC)
	y = (a * cosA * A[1] + b * cosB * B[1] + c * cosC * C[1]) / (a * cosA + b * cosB + c * cosC)
	return (x, y)
N = int(input())
points = [tuple(map(int, input().split())) for i in range(N)]
if N == 2:
	print(dist(points[0], points[1]) / 2)
	exit()
ans = float('inf')
for i in range(N - 1):
	for j in range(i + 1, N):
		x = (points[i][0] + points[j][0]) / 2
		y = (points[i][1] + points[j][1]) / 2
		c = (x, y)
		r = dist(c, points[i])
		if r > ans:
			continue
		for point in points:
			d = dist(c, point)
			if abs(d - r) > 1e-06 and d > r:
				break
		else:
			ans = min(ans, r)
for i in range(N - 2):
	for j in range(i + 1, N - 1):
		for k in range(j + 1, N):
			c = circumcenter(points[i], points[j], points[k])
			if c is None:
				continue
			r = dist(c, points[i])
			if r > ans:
				continue
			for point in points:
				d = dist(c, point)
				if abs(d - r) > 1e-06 and d > r:
					break
			else:
				ans = min(ans, r)
print(ans)


import math
MOD = 10 ** 9 + 7

def dist(a, b):
	dx = a[0] - b[0]
	dy = a[1] - b[1]
	return math.sqrt(dx * dx + dy * dy)

def max_dist(p, x, y):
	result = 0
	for i in range(len(p)):
		result = max(result, dist((x, y), p[i]))
	return result

def ternary_search2(p, x):
	l = 0
	r = 1000
	for i in range(100):
		c1 = (l * 2 + r) / 3
		c2 = (l + r * 2) / 3
		if max_dist(p, x, c1) > max_dist(p, x, c2):
			l = c1
		else:
			r = c2
	return max_dist(p, x, l)

def ternary_search1(p):
	l = 0
	r = 1000
	for i in range(100):
		c1 = (l * 2 + r) / 3
		c2 = (l + r * 2) / 3
		if ternary_search2(p, c1) > ternary_search2(p, c2):
			l = c1
		else:
			r = c2
	return ternary_search2(p, l)

def main():
	n = int(input())
	p = []
	for i in range(n):
		p.append(list(map(int, input().split())))
	print(ternary_search1(p))
main()


N = int(input())
XY = [complex(*map(int, input().split())) for _ in range(N)]
ans = 10 ** 18

def calc(center):
	return max((abs(center - x) for x in XY))
for A in XY:
	for B in XY:
		center = (A + B) / 2
		ans = min(ans, calc(center))
		for C in XY:
			(a, b, c) = (abs(B - C), abs(C - A), abs(A - B))
			S = 0
			T = complex(0, 0)
			for ((x, y, z), u) in zip([(a, b, c), (b, c, a), (c, b, a)], (A, B, C)):
				O = x ** 2 * (y ** 2 + z ** 2 - x ** 2)
				S += O
				T += O * u
			if S == 0:
				continue
			ans = min(ans, calc(T / S))
print(ans)


from numpy.linalg import det
from numpy.linalg import solve
import numpy as np
import math

def find_cross_point(x1, y1, x2, y2, x3, y3):
	A = np.array([[x2 - x1, y2 - y1], [x3 - x2, y3 - y2]])
	B = np.array([(x2 ** 2 + y2 ** 2 - x1 ** 2 - y1 ** 2) / 2, (x3 ** 2 + y3 ** 2 - x2 ** 2 - y2 ** 2) / 2])
	if det(A) == 0:
		return (float('inf'), float('inf'))
	C = solve(A, B)
	return C
N = int(input())
ans = 10 ** 10
plots = []
for i in range(N):
	(x, y) = list(map(int, input().split()))
	plots.append((x, y))
for i in range(N):
	for j in range(i + 1, N):
		sub = 0
		(m_x, m_y) = ((plots[i][0] + plots[j][0]) / 2, (plots[i][1] + plots[j][1]) / 2)
		for k in range(N):
			sub = max(sub, math.hypot(m_x - plots[k][0], m_y - plots[k][1]))
		ans = min(ans, sub)
for i in range(N):
	for j in range(i + 1, N):
		for k in range(j + 1, N):
			sub = 0
			(x1, y1) = plots[i]
			(x2, y2) = plots[j]
			(x3, y3) = plots[k]
			(m_x, m_y) = find_cross_point(x1, y1, x2, y2, x3, y3)
			for p in range(N):
				sub = max(sub, math.hypot(m_x - plots[p][0], m_y - plots[p][1]))
			ans = min(ans, sub)
print(ans)


def main():
	from collections import namedtuple
	from math import hypot
	pt = namedtuple('pt', 'x y')

	def f(x: float, y: float) -> float:

		def dist(a: pt, b: pt) -> float:
			return hypot(a.x - b.x, a.y - b.y)
		return max((dist(pt(x=x, y=y), p_) for p_ in ps))

	def g(x: float) -> float:
		(l, r) = (0, 1000)
		for i in range(80):
			c1 = (l * 2 + r) / 3
			c2 = (l + r * 2) / 3
			if f(x, c1) > f(x, c2):
				l = c1
			else:
				r = c2
		return f(x, l)
	n = int(input())
	(*ps,) = (pt(*map(int, input().split())) for _ in range(n))
	(l, r) = (0, 1000)
	for i in range(80):
		c1 = (l * 2 + r) / 3
		c2 = (l + r * 2) / 3
		if g(c1) > g(c2):
			l = c1
		else:
			r = c2
	ret = g(l)
	print(ret)
main()


from math import sqrt
N = int(input())
THRE = 1e-07
ps = []
for _ in range(N):
	(x, y) = map(int, input().split())
	ps.append((x, y))

def circleThrough2Points(x1, y1, x2, y2):
	if x1 == x2 and y1 == y2:
		return (None, None, None)
	px = (x1 + x2) / 2
	py = (y1 + y2) / 2
	r = (px - x1) ** 2 + (py - y1) ** 2
	return (px, py, r)

def circleThrough3Points(x1, y1, x2, y2, x3, y3):
	(a, b, c, d, e, f) = (x1, y1, x2, y2, x3, y3)
	(a2, b2, c2, d2, e2, f2) = (a * a, b * b, c * c, d * d, e * e, f * f)
	py_1 = 2 * (e - a) * (b - d) - 2 * (c - a) * (b - f)
	if py_1 == 0:
		return (None, None, None)
	py_2 = (e - a) * (a2 + b2 - c2 - d2) - (c - a) * (a2 + b2 - e2 - f2)
	py = py_2 / py_1
	if a != c:
		px = (2 * (b - d) * py - a2 - b2 + c2 + d2) / (2 * (c - a))
	else:
		px = (2 * (b - f) * py - a2 - b2 + e2 + f2) / (2 * (e - a))
	r = (px - a) ** 2 + (py - b) ** 2
	return (px, py, r)
ans = float('inf')
for i in range(N):
	(x1, y1) = ps[i]
	for j in range(i + 1, N):
		(x2, y2) = ps[j]
		(px, py, r) = circleThrough2Points(x1, y1, x2, y2)
		if r is not None:
			if all([(px - x) ** 2 + (py - y) ** 2 <= r + THRE for (x, y) in ps]):
				ans = ans if ans < r else r
		for k in range(j + 1, N):
			(x3, y3) = ps[k]
			(px, py, r) = circleThrough3Points(x1, y1, x2, y2, x3, y3)
			if r is not None:
				if all([(px - x) ** 2 + (py - y) ** 2 <= r + THRE for (x, y) in ps]):
					ans = ans if ans < r else r
print(sqrt(ans))


EPS = 10 ** (-9)

def outercenter(z1, z2, z3):
	w = (z1 - z2) * z3.conjugate() + (z2 - z3) * z1.conjugate() + (z3 - z1) * z2.conjugate()
	if w == 0:
		return (False, 0, 0)
	else:
		W = (z1 - z2) * abs(z3) ** 2 + (z2 - z3) * abs(z1) ** 2 + (z3 - z1) * abs(z2) ** 2
		return (True, W / w, abs(z1 - W / w))

def is_in_circle(c, r, z):
	return r + EPS > abs(z - c)
N = int(input())
z = [0 for i in range(0, N)]
for i in range(0, N):
	(x, y) = map(int, input().split())
	z[i] = complex(x, y)
ans = float('inf')
for i in range(0, N - 1):
	for j in range(i + 1, N):
		mid = (z[i] + z[j]) / 2
		r = abs(z[i] - mid)
		for k in range(0, N):
			if not is_in_circle(mid, r, z[k]):
				break
		else:
			ans = min(ans, r)
for i in range(0, N - 2):
	for j in range(i + 1, N - 1):
		for k in range(j + 1, N):
			info = outercenter(z[i], z[j], z[k])
			if info[0]:
				c = info[1]
				r = info[2]
				for l in range(0, N):
					if not is_in_circle(c, r, z[l]):
						break
				else:
					ans = min(ans, r)
print(ans)


def ternary_search(*, l, r, func, loop_count=100, find_local_minimum: bool=True):
	if find_local_minimum:
		for i in range(loop_count):
			c1 = (l * 2 + r) / 3
			c2 = (l + r * 2) / 3
			if func(c1) > func(c2):
				l = c1
			else:
				r = c2
		return func(l)
	else:
		for i in range(loop_count):
			c1 = (l * 2 + r) / 3
			c2 = (l + r * 2) / 3
			if func(c1) < func(c2):
				l = c1
			else:
				r = c2
		return func(l)

def main():
	from collections import namedtuple
	from math import hypot
	import sys
	input = sys.stdin.readline
	MX = 1000
	Pt = namedtuple('Pt', 'x y')
	N = int(input())
	ps = [Pt(*map(int, input().split())) for _ in range(N)]

	def max_dist(x, y):
		return max((hypot(x - p.x, y - p.y) for p in ps))

	def f(x):
		return ternary_search(l=0, r=MX + 1, func=lambda y: max_dist(x, y))
	res = ternary_search(l=0, r=MX + 1, func=f)
	print(res)
main()


N = int(input())
XY = [tuple(map(int, input().split())) for _ in range(N)]

def dist(x, y, u, v):
	return ((x - u) ** 2 + (y - v) ** 2) ** 0.5

def mxR(x, y):
	return max([dist(x, y, u, v) for (u, v) in XY])
ans = 10 ** 18
for (i, A) in enumerate(XY):
	ans = min(ans, mxR(A[0], A[1]))
	for (j, B) in enumerate(XY[i + 1:]):
		ans = min(ans, mxR((A[0] + B[0]) / 2, (A[1] + B[1]) / 2))
		for C in XY[j + 1:]:
			Z = [0, 0]
			(a, b, c) = (dist(*B + C), dist(*C + A), dist(*A + B))
			S = a ** 2 * (b ** 2 + c ** 2 - a ** 2) + b ** 2 * (c ** 2 + a ** 2 - b ** 2) + c ** 2 * (a ** 2 + b ** 2 - c ** 2)
			if S == 0:
				continue
			x = (a ** 2 * (b ** 2 + c ** 2 - a ** 2) * A[0] + b ** 2 * (c ** 2 + a ** 2 - b ** 2) * B[0] + c ** 2 * (a ** 2 + b ** 2 - c ** 2) * C[0]) / S
			y = (a ** 2 * (b ** 2 + c ** 2 - a ** 2) * A[1] + b ** 2 * (c ** 2 + a ** 2 - b ** 2) * B[1] + c ** 2 * (a ** 2 + b ** 2 - c ** 2) * C[1]) / S
			ans = min(ans, mxR(x, y))
print(ans)


N = int(input())
XY = [tuple(map(int, input().split())) for _ in range(N)]

def f(x, y):
	mx = 0
	for (x1, y1) in XY:
		if ((x1 - x) ** 2 + (y1 - y) ** 2) ** 0.5 > mx:
			mx = ((x1 - x) ** 2 + (y1 - y) ** 2) ** 0.5
	return mx

def g(x):
	l = 0.0
	r = 1000.0
	for i in range(80):
		c1 = (l * 2 + r) / 3
		c2 = (l + r * 2) / 3
		if f(x, c1) > f(x, c2):
			l = c1
		else:
			r = c2
	return f(x, l)
l = 0.0
r = 1000.0
for i in range(80):
	c1 = (l * 2 + r) / 3
	c2 = (l + r * 2) / 3
	if g(c1) > g(c2):
		l = c1
	else:
		r = c2
print(g(l))


import sys
from math import hypot
readline = sys.stdin.readline
N = int(readline())
Points = [tuple(map(int, readline().split())) for _ in range(N)]
inf = 10 ** 9 + 7
EPS = 1e-08
ans = inf
for i in range(N):
	for j in range(i):
		a = Points[i][0]
		b = Points[i][1]
		c = Points[j][0]
		d = Points[j][1]
		(px, py) = ((a + c) / 2, (b + d) / 2)
		R = hypot(a - px, b - py)
		if all((hypot(px - xi, py - yi) <= R + EPS for (xi, yi) in Points)):
			ans = min(ans, R)
for i in range(N):
	for j in range(i):
		for k in range(j):
			a = Points[i][0]
			b = Points[i][1]
			c = Points[j][0]
			d = Points[j][1]
			e = Points[k][0]
			f = Points[k][1]
			ea = hypot(c - e, d - f) + EPS
			eb = hypot(a - e, b - f) + EPS
			ec = hypot(a - c, b - d) + EPS
			cA = (ec ** 2 + eb ** 2 - ea ** 2) / (2 * ec * eb)
			cB = (ec ** 2 - eb ** 2 + ea ** 2) / (2 * ec * ea)
			cC = (-ec ** 2 + eb ** 2 + ea ** 2) / (2 * ea * eb)
			sA = (1 - cA ** 2) ** 0.5
			sB = (1 - cB ** 2) ** 0.5
			sC = (1 - cC ** 2) ** 0.5
			s2A = 2 * sA * cA
			s2B = 2 * sB * cB
			s2C = 2 * sC * cC
			if max(s2A, s2B, s2C) < EPS:
				continue
			else:
				px = (a * s2A + c * s2B + e * s2C) / (s2A + s2B + s2C)
				py = (b * s2A + d * s2B + f * s2C) / (s2A + s2B + s2C)
				R = hypot(px - a, py - b)
			if all((hypot(px - xi, py - yi) <= R + EPS for (xi, yi) in Points)):
				ans = min(ans, R)
print(ans)


import math

def get_circle_center_and_radius(x1, y1, x2, y2, x3, y3):
	d = 2 * ((y1 - y3) * (x1 - x2) - (y1 - y2) * (x1 - x3))
	if d == 0:
		return ((0, 0), 0)
	x = ((y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)) / d
	y = ((x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)) / -d
	r = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
	return ((x, y), r)
N = int(input())
XY = [list(map(int, input().split())) for _ in range(N)]
answer = []
if N == 2:
	(xy1, xy2) = XY
	(x1, y1) = xy1
	(x2, y2) = xy2
	answer.append(((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5 / 2)
else:
	for i in range(N):
		(xi, yi) = XY[i]
		for j in range(i + 1, N):
			(xj, yj) = XY[j]
			r = ((xi - xj) ** 2 + (yi - yj) ** 2) ** 0.5 / 2
			(x0, y0) = ((xi + xj) / 2, (yi + yj) / 2)
			flag = 1
			for ii in range(N):
				(xii, yii) = XY[ii]
				if ((x0 - xii) ** 2 + (y0 - yii) ** 2) ** 0.5 > r:
					flag = 0
					break
			if flag:
				answer.append(r)
	for i in range(N):
		(xi, yi) = XY[i]
		for j in range(i + 1, N):
			(xj, yj) = XY[j]
			for k in range(j + 1, N):
				(xk, yk) = XY[k]
				(xy0, r) = get_circle_center_and_radius(xi, yi, xj, yj, xk, yk)
				(x0, y0) = xy0
				if r:
					flag = 1
					for ii in range(N):
						(xii, yii) = XY[ii]
						if ((x0 - xii) ** 2 + (y0 - yii) ** 2) ** 0.5 > r:
							flag = 0
							break
					if flag:
						answer.append(r)
print(min(answer))


from itertools import combinations
N = int(input())
XY = [tuple(map(int, input().split())) for _ in range(N)]
l = 0
r = 2000
for _ in range(50):
	m = (l + r) / 2
	C = []
	for ((x1, y1), (x2, y2)) in combinations(XY, 2):
		d = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
		if d >= 2 * m:
			l = m
			break
		h = (m ** 2 - (d / 2) ** 2) ** 0.5
		hx = (y2 - y1) / d * h
		hy = (x2 - x1) / d * h
		x = (x1 + x2) / 2
		y = (y1 + y2) / 2
		C.append((x + hx, y - hy))
		C.append((x - hx, y + hy))
	else:
		if any((all((((x - x0) ** 2 + (y - y0) ** 2) ** 0.5 <= m + 10 ** (-8) for (x0, y0) in XY)) for (x, y) in C)):
			r = m
		else:
			l = m
print(r)


N = int(input())
xy = [list(map(int, input().split())) for _ in range(N)]

def nasu(a, b, c):
	A = a[0] ** 2 - b[0] ** 2 + a[1] ** 2 - b[1] ** 2
	B = b[0] ** 2 - c[0] ** 2 + b[1] ** 2 - c[1] ** 2
	x = [2 * (b[0] - a[0]), 2 * (c[0] - b[0])]
	y = [2 * (b[1] - a[1]), 2 * (c[1] - b[1])]
	k = x[1] * y[0] - x[0] * y[1]
	if k == 0:
		return 10 ** 10
	Cx = -(y[0] * B - y[1] * A) / k
	Cy = (x[0] * B - x[1] * A) / k
	return honyamorake(Cx, Cy)

def honya(x, y, Cx, Cy):
	return ((x - Cx) ** 2 + (y - Cy) ** 2) ** (1 / 2)

def honyaraka(a, b):
	Cx = (a[0] + b[0]) / 2
	Cy = (a[1] + b[1]) / 2
	return honyamorake(Cx, Cy)

def honyamorake(Cx, Cy):
	r = honya(xy[0][0], xy[0][1], Cx, Cy)
	for i in range(1, N):
		r = max(r, honya(xy[i][0], xy[i][1], Cx, Cy))
	return r
ans = 10 ** 10
for i in range(N - 2):
	for j in range(i + 1, N - 1):
		for k in range(j + 1, N):
			ans = min(ans, nasu(xy[i], xy[j], xy[k]))
for i in range(N - 1):
	for j in range(i + 1, N):
		ans = min(ans, honyaraka(xy[i], xy[j]))
print(ans)


from itertools import combinations

def dist(ax, ay, bx, by):
	return ((ax - bx) ** 2 + (ay - by) ** 2) ** 0.5
n = int(input())
XY = [tuple((int(x) for x in input().split())) for _ in range(n)]
if n == 2:
	((ax, ay), (bx, by)) = (XY[0], XY[1])
	print(dist(ax, ay, bx, by) / 2)
	exit()
ans = 0
for ((ax, ay), (bx, by), (cx, cy)) in combinations(XY, 3):
	(a, b, c) = sorted([dist(ax, ay, bx, by), dist(bx, by, cx, cy), dist(cx, cy, ax, ay)])
	cosC = (a ** 2 + b ** 2 - c ** 2) / (2 * a * b)
	if cosC < 0:
		ans = max(ans, c / 2)
	else:
		sinC = (1 - cosC ** 2) ** 0.5
		ans = max(ans, c / (2 * sinC))
print(ans)


import numpy as np
from itertools import combinations
N = int(input())
P = [np.array(list(map(int, input().split())), dtype=float) for _ in range(N)]
d2 = lambda v: np.sum(np.square(v))

def radius(A, B, C):
	a = d2(B - C)
	b = d2(C - A)
	c = d2(A - B)
	r = float('inf')
	if c > d2(A + B - 2 * C):
		r = min(r, c)
	if a > d2(B + C - 2 * A):
		r = min(r, a)
	if b > d2(C + A - 2 * B):
		r = min(r, b)
	if r != float('inf'):
		return np.sqrt(r) / 2
	U = a * (b + c - a) * A + b * (c + a - b) * B + c * (a + b - c) * C
	v = a * (b + c - a) + b * (c + a - b) + c * (a + b - c)
	U /= v
	r = np.linalg.norm(U - A)
	return r
if N == 2:
	print(np.linalg.norm(P[0] - P[1]) / 2)
else:
	print(max((radius(a, b, c) for (a, b, c) in combinations(P, 3))))


import sys
import itertools
import numpy as np
sr = lambda : sys.stdin.readline().rstrip()
ir = lambda : int(sr())
lr = lambda : list(map(int, sr().split()))
N = ir()
XY = [lr() for _ in range(N)]
XY = [x + y * 1j for (x, y) in XY]
cen_cand = []

def find_center(a, b, c):
	a -= c
	b -= c
	if abs((a * b.conjugate()).imag) < 0.5:
		return None
	num = a * b * (a - b).conjugate()
	den = a.conjugate() * b
	den -= den.conjugate()
	return num / den + c
for comb in itertools.combinations(XY, 3):
	o = find_center(*comb)
	if o is None:
		continue
	cen_cand.append(o)
for (a, b) in itertools.combinations(XY, 2):
	o = (a + b) / 2
	cen_cand.append(o)
cen_cand = np.array(cen_cand)
XY = np.array(XY)
answer = np.abs(cen_cand[:, None] - XY[None, :]).max(axis=1).min()
print(answer)


def want(x, y):
	ret = 0
	for i in xy:
		ret = max(ret, ((i[0] - x) ** 2 + (i[1] - y) ** 2) ** 0.5)
	return ret

def want2(x):
	ly = miny
	ry = maxy
	while ry - ly > 10 ** (-7) and ry - ly > ry / 10 ** 6:
		m1 = (ly * 2 + ry) / 3
		m2 = (ly + ry * 2) / 3
		rm1 = want(x, m1)
		rm2 = want(x, m2)
		if rm1 > rm2:
			ly = m1
		else:
			ry = m2
	ansy = (ly + ry) / 2
	return want(x, ansy)
N = int(input())
xy = []
minx = float('inf')
maxx = float('-inf')
miny = float('inf')
maxy = float('-inf')
for i in range(N):
	(x, y) = map(int, input().split())
	xy.append([x, y])
	minx = min(minx, x)
	miny = min(miny, y)
	maxx = max(maxx, x)
	maxy = max(maxy, y)
lx = minx
rx = maxx
while rx - lx > 10 ** (-7) and rx - lx > rx / 10 ** 6:
	m1 = (lx * 2 + rx) / 3
	m2 = (lx + rx * 2) / 3
	rm1 = want2(m1)
	rm2 = want2(m2)
	if rm1 > rm2:
		lx = m1
	else:
		rx = m2
print((rm1 + rm2) / 2)


n = int(input())
l = [[0, 0] for _ in range(n)]
for i in range(n):
	(x, y) = map(int, input().split())
	l[i][0] = x
	l[i][1] = y
import math
if n == 2:
	r = math.sqrt((l[1][0] - l[0][0]) ** 2 + (l[1][1] - l[0][1]) ** 2) / 2
	print(r)
	return
ans = float('inf')
import itertools
combs = list(itertools.combinations(range(n), 3))
for comb in combs:
	(x0, y0) = l[comb[0]]
	(x1, y1) = l[comb[1]]
	(x2, y2) = l[comb[2]]
	a = x1 - x0
	b = y1 - y0
	p = (x1 ** 2 - x0 ** 2 + y1 ** 2 - y0 ** 2) / 2
	c = x2 - x0
	d = y2 - y0
	q = (x2 ** 2 - x0 ** 2 + y2 ** 2 - y0 ** 2) / 2
	if a * d - b * c == 0:
		continue
	xc = (p * d - q * b) / (a * d - b * c)
	yc = (-p * c + q * a) / (a * d - b * c)
	r = math.sqrt((x0 - xc) ** 2 + (y0 - yc) ** 2)
	for i in range(n):
		(x, y) = l[i]
		if math.sqrt((x - xc) ** 2 + (y - yc) ** 2) > r:
			break
	else:
		ans = min(ans, r)
combs = list(itertools.combinations(range(n), 2))
for comb in combs:
	(x0, y0) = l[comb[0]]
	(x1, y1) = l[comb[1]]
	xc = (x0 + x1) / 2
	yc = (y0 + y1) / 2
	r = math.sqrt((x0 - xc) ** 2 + (y0 - yc) ** 2)
	for i in range(n):
		(x, y) = l[i]
		if math.sqrt((x - xc) ** 2 + (y - yc) ** 2) > r:
			break
	else:
		ans = min(ans, r)
print(ans)


n = int(input())
XY = []
for i in range(n):
	(x, y) = map(int, input().split())
	XY.append((x, y))

def cross(a, b):
	return a.real * b.imag - b.real * a.imag

def dot(a, b):
	return a.real * b.real + a.imag * b.imag

def circumcenter(a, b, c):
	bunshi = (a - b) * dot(c, c) + (b - c) * dot(a, a) + (c - a) * dot(b, b)
	bunbo = (a - b) * c.conjugate() + (b - c) * a.conjugate() + (c - a) * b.conjugate()
	if bunbo == 0:
		return (False, 0)
	return (True, bunshi / bunbo)
kouho = []
for i in range(n - 1):
	(a, b) = XY[i]
	z1 = complex(a, b)
	for j in range(i + 1, n):
		(c, d) = XY[j]
		z2 = complex(c, d)
		kouho.append((z1 + z2) / 2)
if n >= 3:
	for i in range(n - 2):
		(a, b) = XY[i]
		z1 = complex(a, b)
		for j in range(i + 1, n - 1):
			(c, d) = XY[j]
			z2 = complex(c, d)
			for k in range(j + 1, n):
				(e, f) = XY[k]
				z3 = complex(e, f)
				(flag, gaishin) = circumcenter(z1, z2, z3)
				if flag:
					kouho.append(gaishin)
ans = 10 ** 10
for z in kouho:
	temp = 0
	for i in range(n):
		(x, y) = XY[i]
		z1 = complex(x, y)
		temp = max(temp, abs(z - z1))
	ans = min(ans, temp)
print(ans)


from math import sqrt
n = int(input())
xy = [[int(i) for i in input().split()] for _ in range(n)]

def d(x, y):
	return sqrt((x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2)

def nai(x, y, z):
	(c, b, a) = sorted([d(x, y), d(y, z), d(z, x)])
	co = (b ** 2 + c ** 2 - a ** 2) / (2 * b * c)
	if co < 0:
		return a / 2
	si = sqrt(1 - co ** 2)
	return a / si / 2
if n == 2:
	print(d(xy[0], xy[1]) / 2)
else:
	ans = 0
	for i in range(n):
		for j in range(i + 1, n):
			for k in range(j + 1, n):
				ans = max(ans, nai(xy[i], xy[j], xy[k]))
	print(ans)


def maxdis(cx, cy):
	global x, y
	dmax = d = 0
	(xf, yf) = (0, 0)
	for i in range(len(x)):
		d = max(d, ((x[i] - cx) ** 2 + (y[i] - cy) ** 2) ** 0.5)
		if dmax < d:
			dmax = d
			(xf, yf) = (x[i], y[i])
	return (xf, yf)
N = int(input())
x = []
y = []
for i in range(N):
	(xi, yi) = map(int, input().split())
	x.append(xi)
	y.append(yi)
(cx, cy) = (500, 500)
r = 500 * 1.5
i = 0
while r > 10 ** (-10):
	(xf, yf) = maxdis(cx, cy)
	df = ((xf - cx) ** 2 + (yf - cy) ** 2) ** 0.5
	r *= 0.999
	dx = r * (xf - cx) / df
	dy = r * (yf - cy) / df
	cx += dx
	cy += dy
	i += 1
print(df)


N = int(input())
X = [[0] * 2 for i in range(N)]
for i in range(N):
	X[i] = list(map(int, input().split()))
r2max = 0
for i in range(N):
	for j in range(i + 1):
		for k in range(j + 1):
			if i > j and j > k:
				x = X[i]
				y = X[j]
				z = X[k]
				M = [x[0] - y[0], y[0] - z[0], x[1] - y[1], y[1] - z[1], z[0] - x[0], z[1] - x[1]]
				a = M[0] * M[3] - M[1] * M[2]
				b = -M[0] * M[1] - M[2] * M[3]
				c = -M[0] * M[4] - M[2] * M[5]
				d = -M[4] * M[1] - M[5] * M[3]
				if a != 0 and b > 0 and (c > 0) and (d > 0):
					xyl = x[0] ** 2 + x[1] ** 2 - (y[0] ** 2 + y[1] ** 2)
					yzl = y[0] ** 2 + y[1] ** 2 - (z[0] ** 2 + z[1] ** 2)
					A = (M[3] * xyl - M[2] * yzl) / (2 * a)
					B = (-M[1] * xyl + M[0] * yzl) / (2 * a)
					r2 = (x[0] - A) ** 2 + (x[1] - B) ** 2
					if r2 > r2max:
						r2max = r2
for i in range(N):
	for j in range(i + 1):
		r2 = (X[i][0] - X[j][0]) ** 2 + (X[i][1] - X[j][1]) ** 2
		r2 = r2 / 4
		if r2 > r2max:
			r2max = r2
import math
print(math.sqrt(r2max))


from itertools import combinations
N = int(input())
XY = [tuple(map(int, input().split())) for _ in range(N)]

def f(x_, y_):
	return max(((x - x_) ** 2 + (y - y_) ** 2 for (x, y) in XY)) ** 0.5

def g(x):
	yl = 0
	yr = 1000
	for _ in range(80):
		yl_ = (yl * 2 + yr) / 3
		yr_ = (yl + yr * 2) / 3
		if f(x, yl_) > f(x, yr_):
			yl = yl_
		else:
			yr = yr_
	return f(x, yl_)
xl = 0
xr = 1000
for _ in range(80):
	xl_ = (xl * 2 + xr) / 3
	xr_ = (xl + xr * 2) / 3
	if g(xl_) > g(xr_):
		xl = xl_
	else:
		xr = xr_
print(g(xl))


n = int(input())
xy = [list(map(int, input().split())) for _ in range(n)]

def gaisin(a, b, c, d, e, f):
	if (a - c) * (d - f) == (c - e) * (b - d):
		return ['ng']
	aa = a ** 2
	bb = b ** 2
	cc = c ** 2
	dd = d ** 2
	ee = e ** 2
	ff = f ** 2
	py = ((e - a) * (aa + bb - cc - dd) - (c - a) * (aa + bb - ee - ff)) / (2 * ((e - a) * (b - d) - (c - a) * (b - f)))
	if a == c:
		px = (2 * (b - f) * py - aa - bb + ee + ff) / (2 * (e - a))
	else:
		px = (2 * (b - d) * py - aa - bb + cc + dd) / (2 * (c - a))
	return ['ok', px, py]
pxy = []
for i in range(n - 2):
	for j in range(i + 1, n - 1):
		for k in range(j + 1, n):
			(x1, y1) = xy[i]
			(x2, y2) = xy[j]
			(x3, y3) = xy[k]
			gai = gaisin(x1, y1, x2, y2, x3, y3)
			if len(gai) == 1:
				continue
			(_, px, py) = gai
			pxy.append([px, py])
for i in range(n - 1):
	for j in range(i + 1, n):
		(x1, y1) = xy[i]
		(x2, y2) = xy[j]
		px = (x1 + x2) / 2
		py = (y1 + y2) / 2
		pxy.append([px, py])
ans = 10 ** 10
for (px, py) in pxy:
	ans = min(ans, max((((px - x) ** 2 + (py - y) ** 2) ** 0.5 for (x, y) in xy)))
print(ans)


def cir(x1, y1, x2, y2, x3, y3):
	d = 2 * ((y1 - y3) * (x1 - x2) - (y1 - y2) * (x1 - x3))
	if d == 0:
		return None
	x = ((y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)) / (1.0 * d)
	y = ((x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)) / (-d * 1.0)
	r = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
	return [[x, y], r]
n = int(input())
l = []
for i in range(n):
	l.append(list(map(float, input().split())))
ans = 10 ** 10
for i in range(n):
	for j in range(n):
		for k in range(n):
			if i < j < k:
				z = cir(l[i][0], l[i][1], l[j][0], l[j][1], l[k][0], l[k][1])
				if z:
					f = 0
					x = z[0][0]
					y = z[0][1]
					r = z[1]
					for m in l:
						if ((m[0] - x) ** 2 + (m[1] - y) ** 2) ** 0.5 <= r:
							f += 1
					if f == n:
						ans = min(ans, r)

def cir2(p, q):
	x1 = p[0]
	y1 = p[1]
	x2 = q[0]
	y2 = q[1]
	return [(x1 + x2) * 0.5, (y1 + y2) * 0.5, ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5 * 0.5]
for i in range(n):
	for j in range(n):
		if i < j:
			z = cir2(l[i], l[j])
			x = z[0]
			y = z[1]
			r = z[2]
			f = 0
			for m in l:
				if ((x - m[0]) ** 2 + (y - m[1]) ** 2) ** 0.5 <= r:
					f += 1
			if f == n:
				ans = min(ans, r)
print(ans)


n = int(input())

def bai(x):
	return int(x) * 2.0
xy = [list(map(bai, input().split())) for _ in range(n)]
if n == 2:
	print(((xy[0][0] - xy[1][0]) ** 2 + (xy[0][1] - xy[1][1]) ** 2) ** 0.5 * 0.5 * 0.5)
	exit()
ans = 10 ** 9

def gaishin(a, b, c, d, e, f):
	if (a - c) * (d - f) == (c - e) * (b - d):
		y = (max([b, d, f]) - min([b, d, f])) / 2.0 + min([b, d, f])
		x = (max([a, c, e]) - min([a, c, e])) / 2.0 + min([a, c, e])
	else:
		y = 1.0 * ((e - a) * (a ** 2 + b ** 2 - c ** 2 - d ** 2) - (c - a) * (a ** 2 + b ** 2 - e ** 2 - f ** 2)) / (2.0 * (e - a) * (b - d) - 2.0 * (c - a) * (b - f))
		if e - a != 0:
			x = (2.0 * (b - f) * y - a ** 2 - b ** 2 + e ** 2 + f ** 2) / (2.0 * (e - a))
		elif c - a != 0:
			x = (2.0 * (b - d) * y - a ** 2 - b ** 2 + c ** 2 + d ** 2) / (2.0 * (c - a))
		else:
			print(a, b, c, d, e, f)
			exit()
	return (x, y)
xy.sort()
for i in range(n - 2):
	for j in range(i + 1, n - 1):
		for k in range(i + 2, n):
			(gx, gy) = gaishin(xy[i][0], xy[i][1], xy[j][0], xy[j][1], xy[k][0], xy[k][1])
			d = (1.0 * (gx - xy[i][0])) ** 2 + (1.0 * (gy - xy[i][1])) ** 2
			flag = 0
			for (x, y) in xy:
				if (x, y) != xy[i] and (x, y) != xy[j] and ((x, y) != xy[k]):
					if (1.0 * (gx - x)) ** 2 + (1.0 * (gy - y)) ** 2 > d + 1:
						flag = 1
						break
			if flag == 0:
				ans = min(ans, d ** 0.5)
print(ans / 2)


def solve():
	from sys import stdin
	f_i = stdin
	N = int(f_i.readline())
	points = []
	for i in range(N):
		(x, y) = map(int, f_i.readline().split())
		points.append(x + y * 1j)
	from itertools import combinations
	radiuses = []
	for (p1, p2) in combinations(points, 2):
		c = (p1 + p2) / 2
		r = abs(p1 - c)
		for p in points:
			if abs(p - c) > r:
				break
		else:
			radiuses.append(r)
	if radiuses:
		return min(radiuses)

	def circumcircle(a, b, c):
		n = (a - b) * abs(c) ** 2 + (b - c) * abs(a) ** 2 + (c - a) * abs(b) ** 2
		d = (a - b) * c.conjugate() + (b - c) * a.conjugate() + (c - a) * b.conjugate()
		return n / d
	err = 10 ** (-7)
	for (p1, p2, p3) in combinations(points, 3):
		z1 = p3 - p1
		z2 = p2 - p1
		if z1.real * z2.imag == z1.imag * z2.real:
			continue
		c = circumcircle(p1, p2, p3)
		r = abs(p1 - c)
		for p in points:
			if abs(p - c) - r > err:
				break
		else:
			radiuses.append(r)
	return min(radiuses)
print(solve())


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
			try:
				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))
			except:
				continue
			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)


import math
(N,) = map(int, input().split())
xs = []
ys = []
for _ in range(N):
	(x, y) = map(int, input().split())
	xs.append(x)
	ys.append(y)

def bb(a, b, c, d, e, f):
	if not (c - a) * (f - b) - (e - a) * (d - b):
		return (None, None)
	aa = a * a
	bb = b * b
	cc = c * c
	dd = d * d
	ee = e * e
	ff = f * f
	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))
	return (px, py)
pxs = []
pys = []
for i in range(N):
	for j in range(i + 1, N):
		for k in range(j + 1, N):
			(px, py) = bb(xs[i], ys[i], xs[j], ys[j], xs[k], ys[k])
			if not px:
				continue
			pxs.append(px)
			pys.append(py)
for i in range(N):
	for j in range(i + 1, N):
		pxs.append((xs[i] + xs[j]) / 2)
		pys.append((ys[i] + ys[j]) / 2)
rr = 10 ** 10
for (px, py) in zip(pxs, pys):
	r = 0
	for (x, y) in zip(xs, ys):
		r = max(r, (x - px) ** 2 + (y - py) ** 2)
	rr = min(rr, r)
print(rr ** 0.5)


import sys
input = sys.stdin.readline

def main():
	n = int(input())
	XY = [list(map(int, input().split())) for _ in range(n)]
	if n == 2:
		return dist(XY[0][0], XY[0][1], XY[1][0], XY[1][1]) / 2
	ans = float('inf')
	for i in range(n - 2):
		for j in range(i + 1, n - 1):
			for k in range(j + 1, n):
				(x1, y1) = XY[i]
				(x2, y2) = XY[j]
				(x3, y3) = XY[k]
				(r, x, y) = circle(x1, y1, x2, y2, x3, y3)
				if r == -1:
					continue
				for (x4, y4) in XY:
					if dist(x, y, x4, y4) > r:
						break
				else:
					ans = min(ans, r)
	for i in range(n - 1):
		for j in range(i + 1, n):
			(x1, y1) = XY[i]
			(x2, y2) = XY[j]
			(x, y) = ((x1 + x2) / 2, (y1 + y2) / 2)
			r = dist(x, y, x1, y1)
			for (x3, y3) in XY:
				if dist(x, y, x3, y3) > r:
					break
			else:
				ans = min(ans, r)
	return ans

def dist(x1, y1, x2, y2):
	return ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5

def circle(x1, y1, x2, y2, x3, y3):
	a2 = (x2 - x3) ** 2 + (y2 - y3) ** 2
	b2 = (x1 - x3) ** 2 + (y1 - y3) ** 2
	c2 = (x2 - x1) ** 2 + (y2 - y1) ** 2
	area = ((x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1)) / 2
	if area == 0:
		return (-1, 0, 0)
	x = (a2 * (b2 + c2 - a2) * x1 + b2 * (c2 + a2 - b2) * x2 + c2 * (a2 + b2 - c2) * x3) / (16 * area * area)
	y = (a2 * (b2 + c2 - a2) * y1 + b2 * (c2 + a2 - b2) * y2 + c2 * (a2 + b2 - c2) * y3) / (16 * area * area)
	r = ((x1 - x) ** 2 + (y1 - y) ** 2) ** 0.5
	return (r, x, y)
print(main())


import math
N = int(input())

def get_circle_2p(p1, p2):
	(x1, y1) = p1
	(x2, y2) = p2
	x = (x1 + x2) / 2
	y = (y1 + y2) / 2
	rad = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2) / 2
	return (x, y, rad)

def get_circle_3p(p1, p2, p3):
	(x1, y1) = p1
	(x2, y2) = p2
	(x3, y3) = p3
	d = 2 * ((y1 - y3) * (x1 - x2) - (y1 - y2) * (x1 - x3))
	if d == 0:
		rad1 = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2) / 2
		rad2 = math.sqrt((x1 - x3) ** 2 + (y1 - y3) ** 2) / 2
		rad3 = math.sqrt((x2 - x3) ** 2 + (y2 - y3) ** 2) / 2
		if rad1 >= rad2 and rad1 >= rad3:
			x = (x1 + x2) / 2
			y = (y1 + y2) / 2
			return (x, y, rad1)
		elif rad2 >= rad1 and rad2 >= rad3:
			x = (x1 + x3) / 2
			y = (y1 + y3) / 2
			return (x, y, rad2)
		elif rad3 >= rad1 and rad3 >= rad2:
			x = (x2 + x3) / 2
			y = (y2 + y3) / 2
			return (x, y, rad3)
	else:
		x = ((y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)) / d
		y = ((x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)) / -d
		r = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
		return (x, y, r)
xylist = []
for i in range(N):
	(xi, yi) = map(int, input().split())
	xylist.append((xi, yi))
if N == 2:
	(x, y, r) = get_circle_2p(xylist[0], xylist[1])
	print(r)
else:
	min_radius = float('inf')
	for i in range(N):
		for j in range(i + 1, N):
			(x, y, r) = get_circle_2p(xylist[i], xylist[j])
			if r > min_radius:
				continue
			for l in range(N):
				if l == i or l == j:
					continue
				(xl, yl) = xylist[l]
				diff_xl = xl - x
				diff_yl = yl - y
				if math.sqrt(diff_xl ** 2 + diff_yl ** 2) > r:
					break
			else:
				if r < min_radius:
					min_radius = r
	for i in range(N):
		for j in range(i + 1, N):
			for k in range(j + 1, N):
				(x, y, r) = get_circle_3p(xylist[i], xylist[j], xylist[k])
				if r > min_radius:
					continue
				for l in range(N):
					if l == i or l == j or l == k:
						continue
					(xl, yl) = xylist[l]
					diff_xl = xl - x
					diff_yl = yl - y
					if math.sqrt(diff_xl ** 2 + diff_yl ** 2) > r:
						break
				else:
					if r < min_radius:
						min_radius = r
	print(min_radius)


def dist2(a, b):
	(ax, ay) = a
	(bx, by) = b
	return (ax - bx) ** 2 + (ay - by) ** 2

def circum(a, b, c):
	(ax, ay) = a
	(bx, by) = b
	(cx, cy) = c
	s = dist2(b, c) * (dist2(c, a) + dist2(a, b) - dist2(b, c))
	t = dist2(c, a) * (dist2(a, b) + dist2(b, c) - dist2(c, a))
	u = dist2(a, b) * (dist2(b, c) + dist2(c, a) - dist2(a, b))
	ox = (s * ax + t * bx + u * cx) / (s + t + u)
	oy = (s * ay + t * by + u * cy) / (s + t + u)
	return (ox, oy)
n = int(input())
P = [tuple(map(int, input().split())) for i in range(n)]
eps = 10 ** (-7)
if n == 2:
	r = dist2(P[0], P[1]) ** 0.5 / 2
	print(r)
	return
for i in range(n - 2):
	for j in range(i + 1, n - 1):
		for k in range(j + 1, n):
			(a, b, c) = (P[i], P[j], P[k])
			(ax, ay) = a
			(bx, by) = b
			(cx, cy) = c
			if dist2(a, b) + dist2(b, c) <= dist2(c, a):
				p = ((cx + ax) / 2, (cy + ay) / 2)
				r2 = dist2(a, p)
			elif dist2(b, c) + dist2(c, a) <= dist2(a, b):
				p = ((ax + bx) / 2, (ay + by) / 2)
				r2 = dist2(b, p)
			elif dist2(c, a) + dist2(a, b) <= dist2(b, c):
				p = ((bx + cx) / 2, (by + cy) / 2)
				r2 = dist2(c, p)
			else:
				p = circum(a, b, c)
				r2 = dist2(a, p)
			if all([dist2(p, q) <= r2 + eps for q in P]):
				print(r2 ** 0.5)
				return


n = int(input())
p = []
for _ in range(n):
	(x, y) = map(int, input().split())
	p.append([x, y])
import math
import itertools
if n == 2:
	print(math.sqrt((p[0][0] - p[1][0]) ** 2 + (p[0][1] - p[1][1]) ** 2) / 2)
	exit()

def rad(v):
	p1 = v[0]
	p2 = v[1]
	p3 = v[2]
	x1 = p1[0]
	y1 = p1[1]
	x2 = p2[0]
	y2 = p2[1]
	x3 = p3[0]
	y3 = p3[1]
	px = (y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)
	if 2 * (y1 - y3) * (x1 - x2) - 2 * (y1 - y2) * (x1 - x3) == 0:
		return None
	px = px / (2 * (y1 - y3) * (x1 - x2) - 2 * (y1 - y2) * (x1 - x3))
	py = (x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)
	if 2 * (x1 - x3) * (y1 - y2) - 2 * (x1 - x2) * (y1 - y3) == 0:
		return None
	py = py / (2 * (x1 - x3) * (y1 - y2) - 2 * (x1 - x2) * (y1 - y3))
	return [px, py, (x1 - px) ** 2 + (y1 - py) ** 2]
ans = 10 ** 13
for v in itertools.combinations(p, 2):
	p1 = v[0]
	p2 = v[1]
	px = (p1[0] + p2[0]) / 2
	py = (p1[1] + p2[1]) / 2
	rr = (p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2
	rr = rr / 4
	chk = True
	for i in range(n):
		if (p[i][0] - px) ** 2 + (p[i][1] - py) ** 2 > rr + 10 ** (-6):
			chk = False
	if chk:
		ans = min(ans, rr ** 0.5)
for v in itertools.combinations(p, 3):
	d = rad(v)
	if d == None:
		continue
	chk = True
	for i in range(n):
		if (p[i][0] - d[0]) ** 2 + (p[i][1] - d[1]) ** 2 > d[2] + 10 ** (-6):
			chk = False
	if chk:
		ans = min(ans, d[2] ** 0.5)
print(ans)


from math import sqrt
N = int(input())
XY = [tuple(map(int, input().split())) for _ in range(N)]

def calc(r):
	lst = []
	for i in range(N - 1):
		x1 = XY[i][0]
		y1 = XY[i][1]
		for j in range(i + 1, N):
			x2 = XY[j][0]
			y2 = XY[j][1]
			diff = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
			if diff > 2 * r:
				return False
			h = sqrt(r ** 2 - (diff / 2) ** 2)
			if x1 == x2:
				ny = (y1 + y2) / 2
				lst.append([x1 - h, ny])
				lst.append([x1 + h, ny])
			elif y1 == y2:
				nx = (x1 + x2) / 2
				lst.append([nx, y1 - h])
				lst.append([nx, y1 + h])
			else:
				a = (y2 - y1) / (x2 - x1)
				b = -1 / a
				size = sqrt(1 + b ** 2)
				nx = h / size
				ny = nx * b
				xc = (x1 + x2) / 2
				yc = (y1 + y2) / 2
				lst.append([xc + nx, yc + ny])
				lst.append([xc - nx, yc - ny])
	nr = r + eps
	for (x, y) in lst:
		flag = True
		for (X, Y) in XY:
			tmp = (x - X) ** 2 + (y - Y) ** 2
			if tmp > nr ** 2:
				flag = False
				break
		if flag:
			return True
	return False
l = 0
r = 1000
eps = 10 ** (-9)
for i in range(100):
	mid = (l + r) / 2
	if calc(mid):
		r = mid
	else:
		l = mid
print(r)


n = int(input())
p = []
for _ in range(n):
	(x, y) = map(int, input().split())
	p.append((x, y))
c = []
for i in range(n - 1):
	for j in range(i + 1, n):
		c.append([(p[i][0] + p[j][0]) / 2, (p[i][1] + p[j][1]) / 2])
for i in range(n - 2):
	x = p[i][0] + p[i][1] * 1j
	for j in range(i + 1, n - 1):
		y = p[j][0] + p[j][1] * 1j
		for k in range(j + 1, n):
			z = p[k][0] + p[k][1] * 1j
			a = y - x
			b = z - x
			if a.real * b.imag == a.imag * b.real:
				continue
			C = a * b * (a.conjugate() - b.conjugate()) / (b * a.conjugate() - a * b.conjugate())
			C = C + x
			c.append([C.real, C.imag])
ans = float('inf')
for (X, Y) in c:
	temp = 0
	for (x, y) in p:
		temp = max(((X - x) ** 2 + (Y - y) ** 2) ** 0.5, temp)
	ans = min(ans, temp)
print(ans)


n = int(input())
xy = []
for _ in range(n):
	xy.append(list(map(int, input().split())))
from scipy.optimize import fmin

def calc(k):
	(i, j) = k
	return max(((x - i) ** 2 + (y - j) ** 2 for (x, y) in xy))
(x, y) = fmin(calc, [500, 500], disp=0)
print(calc([x, y]) ** 0.5)


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

def 外心(p1, p2, p3):
	(a, b) = p1
	(c, d) = p2
	(e, f) = p3
	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:
		return (0, 0)
	py = ((e - a) * (aa + bb - cc - dd) - (c - a) * (aa + bb - ee - ff)) / (2 * (e - a) * (b - d) - 2 * (c - a) * (b - f))
	if c == a:
		px = (2 * (b - f) * py - aa - bb + ee + ff) / (2 * (e - a))
	else:
		px = (2 * (b - d) * py - aa - bb + cc + dd) / (2 * (c - a))
	return (px, py)
n = int(input())
points = [list(map(int, input().split())) for i in range(n)]
from itertools import combinations
候補 = []
for (p1, p2) in combinations(points, 2):
	(px, py) = ((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2)
	候補.append((px, py))
for (p1, p2, p3) in combinations(points, 3):
	候補.append(外心(p1, p2, p3))
from math import sqrt
ans = float('Inf')
for (x, y) in 候補:
	tmp = 0
	for (px, py) in points:
		tmp = max(tmp, (px - x) ** 2 + (py - y) ** 2)
	ans = min(ans, tmp)
ans = sqrt(ans)
print(ans)


N = int(input())
X = []
for _ in range(N):
	(x, y) = map(int, input().split())
	X.append((x, y))

def circumcenter(p, q, r):
	(a, b) = p
	(c, d) = q
	(e, f) = r
	(a, b, c, d) = (a - e, b - f, c - e, d - f)
	g = a * d - b * c
	if p == q:
		return ((p[0] + r[0]) / 2, (p[1] + r[1]) / 2)
	if g == 0:
		return (0, 0)
	ab = a * a + b * b
	cd = c * c + d * d
	return ((d * ab - b * cd) / (2 * g) + e, (a * cd - c * ab) / (2 * g) + f)
mi = 2000000
for (i, p) in enumerate(X):
	for (j, q) in enumerate(X[i:]):
		for r in X[j + 1:]:
			(a, b) = circumcenter(p, q, r)
			mi = min(mi, max([(x - a) ** 2 + (y - b) ** 2 for (x, y) in X]))
print(mi ** 0.5)


from scipy import optimize
import numpy as np
n = int(input())
points = [tuple(map(int, input().split())) for i in range(n)]
maxd = 0

def d(xy):
	maxd = 0
	(x, y) = xy
	for p in points:
		(px, py) = p
		d = np.linalg.norm((x - px, y - py))
		if maxd < d:
			maxd = d
	return maxd
opt = optimize.fmin(d, np.zeros(2), ftol=10 ** (-6), disp=0)
print(d(opt))


from itertools import combinations
INFTY = 10 ** 4
epsilon = 1e-10

def dist(x, y):
	return ((x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2) ** 0.5

def cross(x, y):
	return x[0] * y[1] - x[1] * y[0]

def dot(x, y):
	return x[0] * y[0] + x[1] * y[1]
N = int(input())
X = [list(map(int, input().split())) for _ in range(N)]
rmin = INFTY
for z in combinations(range(N), 3):
	(i, j, k) = z
	(x0, y0) = X[i]
	(x1, y1) = X[j]
	(x2, y2) = X[k]
	r = max(dist(X[i], X[j]), dist(X[j], X[k]), dist(X[k], X[i])) / 2
	if r == dist(X[i], X[j]) / 2:
		x = (x0 + x1) / 2
		y = (y0 + y1) / 2
	elif r == dist(X[j], X[k]) / 2:
		x = (x1 + x2) / 2
		y = (y1 + y2) / 2
	else:
		x = (x2 + x0) / 2
		y = (y2 + y0) / 2
	a = cross([x1 - x0, y1 - y0], [x2 - x0, y2 - y0])
	if a == 0:
		continue
	if dot([x1 - x0, y1 - y0], [x2 - x0, y2 - y0]) >= 0 and dot([x0 - x1, y0 - y1], [x2 - x1, y2 - y1]) >= 0 and (dot([x1 - x2, y1 - y2], [x0 - x2, y0 - y2]) >= 0):
		s = ((x1 - x0) ** 2 + (y1 - y0) ** 2 - (x0 + x1 - 2 * x2) ** 2 - (y0 + y1 - 2 * y2) ** 2) / 8
		s = s / (x0 * y1 - x1 * y0 - x2 * y1 + x2 * y0 - x0 * y2 + x1 * y2)
		x = (x0 + x1) / 2 + s * (y1 - y0)
		y = (y0 + y1) / 2 + s * (x0 - x1)
		r = dist([x, y], [x0, y0])
	flag = 0
	for i in range(N):
		if dist([x, y], X[i]) <= r + epsilon:
			continue
		else:
			flag = 1
			break
	if flag == 0:
		rmin = min(rmin, r)
if rmin == INFTY:
	rmin = 0
	for i in range(N - 1):
		for j in range(i + 1, N):
			rmin = max(rmin, dist(X[i], X[j]))
	print(rmin / 2)
else:
	print(rmin)


import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import itertools
n = int(readline())
xy = tuple(map(int, read().split()))

def check(d):
	eps = 1 / 10 ** 10
	points = []
	for c in itertools.combinations(range(n), 2):
		(x1, y1) = xy[c[0] * 2:c[0] * 2 + 2]
		(x2, y2) = xy[c[1] * 2:c[1] * 2 + 2]
		dif = (x1 - x2) ** 2 + (y1 - y2) ** 2
		if dif > 4 * d ** 2:
			return False
		h = (d ** 2 - dif / 4) ** 0.5
		(xm, ym) = ((x1 + x2) / 2, (y1 + y2) / 2)
		(dx, dy) = (y1 - y2, -1 * (x1 - x2))
		dxy = (dx ** 2 + dy ** 2) ** 0.5
		points.append((xm + dx * h / dxy, ym + dy * h / dxy))
		points.append((xm - dx * h / dxy, ym - dy * h / dxy))
	for (xp, yp) in points:
		for i in range(n):
			(xi, yi) = xy[i * 2:i * 2 + 2]
			dif = (xp - xi) ** 2 + (yp - yi) ** 2
			if dif > d ** 2 + eps:
				break
		else:
			return True
	return False
ok = 1000
ng = 0
for _ in range(50):
	mid = (ok + ng) / 2
	if check(mid):
		ok = mid
	else:
		ng = mid
print(ok)


import numpy as np
N = int(input())
x = np.zeros([N, 2])
for i in range(N):
	x[i, :] = list(map(float, input().split()))

def norm(x, y):
	return np.sqrt(((x - y) ** 2).sum())
x0 = x.mean(0)
old = x0
rate = 0.06
decay = 0.999
epsilon = 1e-15
while 1:
	d = np.sqrt(((x - old) ** 2).sum(1))
	(max_, argmax) = (d.max(), d.argmax())
	direction = x[argmax, :] - old
	new = old + direction * rate
	rate *= decay
	if norm(new, old) <= epsilon:
		break
	old = new
print(norm(direction, 0))


from scipy.optimize import fmin
l = [list(map(int, input().split())) for i in range(int(input()))]

def g(s):
	(a, b) = s
	d = 0
	for (i, j) in l:
		d = max(d, (i - a) ** 2 + (j - b) ** 2)
	return d
(x, y) = fmin(g, [500, 500], ftol=10 ** (-7), disp=0)
print(g((x, y)) ** 0.5)


N = int(input())
XY = [list(map(int, input().split())) for i in range(N)]
from itertools import combinations
a = 9999

def f(X, Y, R2, a):
	if all([(X - x) ** 2 + (Y - y) ** 2 < R2 for (x, y) in XY]):
		a = min(a, R2 ** 0.5)
	return a
for ((x1, y1), (x2, y2), (x3, y3)) in combinations(XY, 3):
	e1 = (x2 - x3) ** 2 + (y2 - y3) ** 2
	e2 = (x3 - x1) ** 2 + (y3 - y1) ** 2
	e3 = (x1 - x2) ** 2 + (y1 - y2) ** 2
	p = e1 * (e2 + e3 - e1)
	q = e2 * (e3 + e1 - e2)
	r = e3 * (e1 + e2 - e3)
	if p + q + r == 0:
		continue
	X = (p * x1 + q * x2 + r * x3) / (p + q + r)
	Y = (p * y1 + q * y2 + r * y3) / (p + q + r)
	R2 = (X - x1) ** 2 + (Y - y1) ** 2 + 1e-08
	a = f(X, Y, R2, a)
for ((x1, y1), (x2, y2)) in combinations(XY, 2):
	X = (x1 + x2) / 2
	Y = (y1 + y2) / 2
	R2 = (X - x1) ** 2 + (Y - y1) ** 2 + 1e-08
	a = f(X, Y, R2, a)
print(a)


from math import hypot
N = int(input())
pts = [tuple(map(int, input().split())) for _ in range(N)]

def getIntersectionLL(a1, b1, c1, a2, b2, c2):
	v = a1 * b2 - a2 * b1
	if v == 0:
		return (None, None)
	else:
		return ((b1 * c2 - b2 * c1) / v, (-a1 * c2 + a2 * c1) / v)

def getPerpendicularBisector(x1, y1, x2, y2):
	(dx, dy) = (x2 - x1, y2 - y1)
	(xM, yM) = ((x1 + x2) / 2, (y1 + y2) / 2)
	return (-dx, -dy, dx * xM + dy * yM)

def getCircumcenter(x1, y1, x2, y2, x3, y3):
	(a12, b12, c12) = getPerpendicularBisector(x1, y1, x2, y2)
	(a13, b13, c13) = getPerpendicularBisector(x1, y1, x3, y3)
	intLL = getIntersectionLL(a12, b12, c12, a13, b13, c13)
	return intLL
ans = float('inf')
for i in range(N):
	(x1, y1) = pts[i]
	for j in range(i + 1, N):
		(x2, y2) = pts[j]
		(xC, yC) = ((x1 + x2) / 2, (y1 + y2) / 2)
		dist = max([hypot(x - xC, y - yC) for (x, y) in pts])
		ans = min(ans, dist)
for i in range(N):
	(x1, y1) = pts[i]
	for j in range(i + 1, N):
		(x2, y2) = pts[j]
		for k in range(j + 1, N):
			(x3, y3) = pts[k]
			(xC, yC) = getCircumcenter(x1, y1, x2, y2, x3, y3)
			if xC is None:
				continue
			dist = max([hypot(x - xC, y - yC) for (x, y) in pts])
			ans = min(ans, dist)
print(ans)


from scipy.optimize import *
(_, *s) = open(0).read().split()
f = lambda x: max(((x[0] - i) ** 2 + (x[1] - j) ** 2 for (i, j) in zip(*[map(int, s)] * 2)))
print(f(fmin(f, (9, 9), disp=0)) ** 0.5)


from itertools import combinations
import math
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n = int(readline())
m = map(float, read().split())
points = [[x, y] for (x, y) in zip(m, m)]

def center(a, b, c):
	M = pow(a[0], 2) - pow(b[0], 2) + pow(a[1], 2) - pow(b[1], 2)
	N = pow(a[0], 2) - pow(c[0], 2) + pow(a[1], 2) - pow(c[1], 2)
	Yab = a[1] - b[1]
	Xab = a[0] - b[0]
	Yac = a[1] - c[1]
	Xac = a[0] - c[0]
	d1 = Yac * Xab - Yab * Xac
	d2 = Xac * Yab - Xab * Yac
	if d1 == 0 or d2 == 0:
		return None
	x = (M * Yac - N * Yab) / (2 * d1)
	y = (M * Xac - N * Xab) / (2 * d2)
	return (x, y)
centers = []
for (a, b, c) in combinations(points, 3):
	cen = center(a, b, c)
	if cen is None:
		continue
	centers.append(cen)
for (a, b) in combinations(points, 2):
	cen = ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2)
	centers.append(cen)
res = 1000
for (cx, cy) in centers:
	r = 0
	for (x, y) in points:
		tr = math.hypot(x - cx, y - cy)
		if tr > r:
			r = tr
	if r < res:
		res = r
print(res)


from itertools import combinations as comb
N = int(input())
l = [tuple(map(int, input().split())) for _ in range(N)]
dist = lambda a, b: ((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2) ** 0.5

def get_centers():
	ans = []
	for (a, b, c) in comb(l, 3):
		(x1, y1) = a
		(x2, y2) = b
		(x3, y3) = c
		A = 2 * (x2 - x1)
		B = 2 * (y2 - y1)
		D = 2 * (x3 - x2)
		E = 2 * (y3 - y2)
		C = x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2
		F = x2 ** 2 - x3 ** 2 + y2 ** 2 - y3 ** 2
		if B * D - A * E != 0:
			cy = (A * F - C * D) / (B * D - A * E)
			cx = -(F + E * cy) / D if D else -(C + B * cy) / A
			r = dist(a, (cx, cy))
			ans.append((cx, cy, r))
	for (a, b) in comb(l, 2):
		d = min(a, b)
		e = max(a, b)
		ans.append(((d[0] + e[0]) / 2, (d[1] + e[1]) / 2, dist(d, e) / 2))
	return ans
if N == 2:
	d = l[0]
	e = l[1]
	print(dist(d, e) / 2)
else:
	ans = 10 ** 12
	for (xr, yr, r) in get_centers():
		v = 0
		for (x, y) in l:
			v += dist((x, y), (xr, yr)) <= r
		if v == N:
			ans = min(ans, r)
	print(ans)


import math
import sys
import itertools
sys.setrecursionlimit(10 ** 7)
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(input())
XY = [[float(x) for x in input().split()] for _ in range(N)]
ans = 1500.0
eps = 10.0 ** (-8)

def circumcenter(A, B, C):
	ax = A[0]
	ay = A[1]
	bx = B[0]
	by = B[1]
	cx = C[0]
	cy = C[1]
	d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by))
	if d == 0.0:
		return None
	ux = ((ax * ax + ay * ay) * (by - cy) + (bx * bx + by * by) * (cy - ay) + (cx * cx + cy * cy) * (ay - by)) / d
	uy = ((ax * ax + ay * ay) * (cx - bx) + (bx * bx + by * by) * (ax - cx) + (cx * cx + cy * cy) * (bx - ax)) / d
	return (ux, uy)

def check(center_x, center_y, R2):
	ok = True
	for (x, y) in XY:
		d = (center_x - x) ** 2.0 + (center_y - y) ** 2.0
		if R2 + eps < d:
			ok = False
			break
	return ok
for (i, j) in itertools.combinations(range(N), 2):
	(ax, ay) = XY[i]
	(bx, by) = XY[j]
	center_x = (ax + bx) / 2.0
	center_y = (ay + by) / 2.0
	R2 = (ax - center_x) ** 2 + (ay - center_y) ** 2
	R = math.sqrt(R2)
	if check(center_x, center_y, R2):
		ans = min(R, ans)
for (a, b, c) in itertools.combinations(range(N), 3):
	d = circumcenter(XY[a], XY[b], XY[c])
	if d is None:
		continue
	center_x = d[0]
	center_y = d[1]
	ax = XY[a][0]
	ay = XY[a][1]
	R2 = (ax - center_x) ** 2.0 + (ay - center_y) ** 2.0
	R = math.sqrt(R2)
	ok = check(center_x, center_y, R2)
	if check(center_x, center_y, R2):
		ans = min(ans, R)
print(ans)


import sys, random
input = sys.stdin.readline

def main():
	n = int(input())
	dg = 100000
	xy = []
	for _ in [0] * n:
		(x, y) = map(int, input().split())
		xy.append(x * dg + y)
	if n == 2:
		(x, y) = (xy[0] // dg, xy[0] % dg)
		(a, b) = (xy[1] // dg, xy[1] % dg)
		print(((x - a) ** 2 + (y - b) ** 2) ** 0.5 / 2.0)
	else:
		res = -1
		for i in range(n):
			for j in range(i + 1, n):
				for k in range(j + 1, n):
					(a, b) = (xy[i] // dg, xy[i] % dg)
					(c, d) = (xy[j] // dg, xy[j] % dg)
					(e, f) = (xy[k] // dg, xy[k] % dg)
					d1 = ((a - c) ** 2 + (b - d) ** 2) ** 0.5
					d2 = ((a - e) ** 2 + (b - f) ** 2) ** 0.5
					d3 = ((e - c) ** 2 + (f - d) ** 2) ** 0.5
					if d1 < d2:
						(d1, d2) = (d2, d1)
					if d1 < d3:
						(d1, d3) = (d3, d1)
					cos = (d2 ** 2 + d3 ** 2 - d1 ** 2) / (2.0 * d2 * d3)
					if cos <= 0 or cos >= 1.0 - 10 ** (-8):
						res = max(res, d1 / 2.0)
					else:
						sin = (1 - cos ** 2) ** 0.5
						res = max(res, d1 * 0.5 / sin)
		print(res)
main()


N = int(input())
(X, Y) = ([0] * N, [0] * N)
for i in range(N):
	(X[i], Y[i]) = map(int, input().split())

def check(a, b, r):
	if r < 0:
		r = 0
	res = [0, 0, 0]
	flg = True
	for i in range(N):
		tmp = (X[i] - a) ** 2 + (Y[i] - b) ** 2
		if tmp > r ** 2:
			flg = False
		if tmp > res[0]:
			res = [tmp, X[i], Y[i]]
	res[0] = flg
	return res
(x_ave, y_ave) = (sum(X) / N, sum(Y) / N)
MIN = 10 ** (-12)
r = 1500
r_diff = r / 2
k = 0.5
d = 999 / 1000
while r_diff > MIN:
	tmpres = check(x_ave, y_ave, r)
	if tmpres[0]:
		r -= r_diff
	else:
		r += r_diff
	x_ave += (tmpres[1] - x_ave) * k
	y_ave += (tmpres[2] - y_ave) * k
	r_diff = r_diff * d
	k = k * d
print(r)


def f_enf_enclose_all_ternary_search(ITER=100):
	from math import hypot
	N = int(input())
	Pos = [[int(i) for i in input().split()] for j in range(N)]

	def f(x, y):
		return max((hypot(px - x, py - y) for (px, py) in Pos))

	def g(x):
		(left, right) = (-1000.0, 1000.0)
		for _ in range(ITER):
			m1 = (left * 2 + right) / 3
			m2 = (left + right * 2) / 3
			if f(x, m1) > f(x, m2):
				left = m1
			else:
				right = m2
		return f(x, left)
	(left, right) = (-1000.0, 1000.0)
	for _ in range(ITER):
		m1 = (left * 2 + right) / 3
		m2 = (left + right * 2) / 3
		if g(m1) > g(m2):
			left = m1
		else:
			right = m2
	return round(g(left), 10)
print(f_enf_enclose_all_ternary_search())


import math, random

def make_circle(points):
	shuffled = [(float(p[0]), float(p[1])) for p in points]
	random.shuffle(shuffled)
	c = None
	for (i, p) in enumerate(shuffled):
		if c is None or not _is_in_circle(c, p):
			c = _make_circle_one_point(shuffled[0:i + 1], p)
	return c

def _make_circle_one_point(points, p):
	c = (p[0], p[1], 0.0)
	for (i, q) in enumerate(points):
		if not _is_in_circle(c, q):
			if c[2] == 0.0:
				c = _make_diameter(p, q)
			else:
				c = _make_circle_two_points(points[0:i + 1], p, q)
	return c

def _make_circle_two_points(points, p, q):
	diameter = _make_diameter(p, q)
	if all((_is_in_circle(diameter, r) for r in points)):
		return diameter
	left = None
	right = None
	for r in points:
		cross = _cross_product(p[0], p[1], q[0], q[1], r[0], r[1])
		c = _make_circumcircle(p, q, r)
		if c is None:
			continue
		elif cross > 0.0 and (left is None or _cross_product(p[0], p[1], q[0], q[1], c[0], c[1]) > _cross_product(p[0], p[1], q[0], q[1], left[0], left[1])):
			left = c
		elif cross < 0.0 and (right is None or _cross_product(p[0], p[1], q[0], q[1], c[0], c[1]) < _cross_product(p[0], p[1], q[0], q[1], right[0], right[1])):
			right = c
	return left if right is None or (left is not None and left[2] <= right[2]) else right

def _make_circumcircle(p0, p1, p2):
	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))

def _make_diameter(p0, p1):
	return ((p0[0] + p1[0]) / 2.0, (p0[1] + p1[1]) / 2.0, math.hypot(p0[0] - p1[0], p0[1] - p1[1]) / 2.0)
_EPSILON = 1e-12

def _is_in_circle(c, p):
	return c is not None and math.hypot(p[0] - c[0], p[1] - c[1]) < c[2] + _EPSILON

def _cross_product(x0, y0, x1, y1, x2, y2):
	return (x1 - x0) * (y2 - y0) - (y1 - y0) * (x2 - x0)
points = [(421640.3639270504, 4596366.353552659), (421635.79361391126, 4596369.054192241), (421632.6774913164, 4596371.131607305), (421629.14588570886, 4596374.870954419), (421625.6142801013, 4596377.779335507), (421624.99105558236, 4596382.14190714), (421630.1845932406, 4596388.062540068), (421633.3007158355, 4596388.270281575), (421637.87102897465, 4596391.8018871825), (421642.4413421138, 4596394.918009778), (421646.5961722403, 4596399.903805929), (421649.71229483513, 4596403.850894549), (421653.8940752105, 4596409.600842565), (421654.69809098693, 4596410.706364258), (421657.60647207545, 4596411.329588776), (421660.514853164, 4596409.875398233), (421661.3458191893, 4596406.136051118), (421661.5535606956, 4596403.22767003), (421658.85292111343, 4596400.94251346), (421656.5677645438, 4596399.696064423), (421655.52905701223, 4596396.164458815), (421652.82841743, 4596394.502526765), (421648.46584579715, 4596391.8018871825), (421646.38843073393, 4596388.270281575), (421645.55746470863, 4596386.400608018), (421647.21939675923, 4596384.115451449), (421649.5045533288, 4596382.661260904), (421650.7510023668, 4596378.714172284), (421647.8426212782, 4596375.8057911955), (421644.9342401897, 4596372.897410107), (421643.6877911517, 4596370.404512031), (421640.3639270504, 4596366.353552659)]
pointss = []
n = int(input())
for i in range(n):
	(x, y) = list(map(int, input().split()))
	pointss.append((x, y))
ans = make_circle(pointss)
print(ans[2])


import math
from itertools import combinations
eps = 10 ** (-7)

def midpoint(a, b):
	return ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2)

def distance(a, b):
	return ((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2) ** 0.5

def within(c, r, a):
	return (a[0] - c[0]) ** 2 + (a[1] - c[1]) ** 2 <= r ** 2 + eps

def tcircle(t1, t2, t3):
	(x1, y1) = t1
	(x2, y2) = t2
	(x3, y3) = t3
	d = 2 * ((y1 - y3) * (x1 - x2) - (y1 - y2) * (x1 - x3))
	if d == 0:
		return ((0.0, 0.0), -1.0)
	x = ((y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)) / d
	y = ((x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)) / -d
	r = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
	return ((x, y), r)

def main():
	N = int(input())
	L = [tuple(map(int, input().split())) for _ in range(N)]
	br = float('inf')
	for (p, q) in combinations(L, 2):
		(c, r) = (midpoint(p, q), distance(p, q) / 2)
		if all((within(c, r, i) for i in L)):
			return r
		(ac, ar) = ((0.0, 0.0), 0.0)
		for i in L:
			if within(c, r, i):
				continue
			(pc, pr) = tcircle(p, q, i)
			if pr == -1:
				break
			if ar < pr:
				(ac, ar) = (pc, pr)
		else:
			if ar < br and all((within(ac, ar, i) for i in L)):
				br = ar
	return br
print(main())


class Triangle:

	def __init__(self, A, B, C):
		self.A = A
		self.B = B
		self.C = C
		(Ax, Ay) = A
		(Bx, By) = B
		(Cx, Cy) = C
		a = ((Bx - Cx) ** 2 + (By - Cy) ** 2) ** 0.5
		b = ((Cx - Ax) ** 2 + (Cy - Ay) ** 2) ** 0.5
		c = ((Ax - Bx) ** 2 + (Ay - By) ** 2) ** 0.5
		self.a = a
		self.b = b
		self.c = c
		s = a ** 2 * (b ** 2 + c ** 2 - a ** 2)
		t = b ** 2 * (c ** 2 + a ** 2 - b ** 2)
		u = c ** 2 * (a ** 2 + b ** 2 - c ** 2)
		Ux = (s * Ax + t * Bx + u * Cx) / (s + t + u)
		Uy = (s * Ay + t * By + u * Cy) / (s + t + u)
		self.U = (Ux, Uy)
		self.G = ((Ax + Bx + Cx) / 3, (Ay + By + Cy) / 3)

class Circle:

	def __init__(self, p, r):
		self.p = p
		self.r = r

	def contain(self, q):
		(px, py) = self.p
		(qx, qy) = q
		return (px - qx) ** 2 + (py - qy) ** 2 <= self.r ** 2 + 10 ** (-7)

def distance(a, b):
	(ax, ay) = a
	(bx, by) = b
	return ((ax - bx) ** 2 + (ay - by) ** 2) ** 0.5

def enclose(P):
	n = len(P)
	if n == 2:
		(ax, ay) = P[0]
		(bx, by) = P[1]
		p = ((ax + bx) / 2, (ay + by) / 2)
		r = distance(P[0], p)
		return Circle(p, r)
	if n == 3:
		circle = enclose([P[0], P[1]])
		if circle.contain(P[2]):
			return circle
		circle = enclose([P[1], P[2]])
		if circle.contain(P[0]):
			return circle
		circle = enclose([P[2], P[0]])
		if circle.contain(P[1]):
			return circle
		triangle = Triangle(P[0], P[1], P[2])
		u = triangle.U
		r = distance(u, P[0])
		return Circle(u, r)
	for i in range(n - 2):
		for j in range(i + 1, n - 1):
			for k in range(j + 1, n):
				circle = enclose([P[i], P[j], P[k]])
				if all([circle.contain(q) for q in P]):
					return circle
n = int(input())
P = []
for i in range(n):
	(x, y) = list(map(int, input().split()))
	P.append((x, y))
circle = enclose(P)
print(circle.r)


def min_disc(points):
	from random import sample
	N = len(points)
	if N == 1:
		return (points[0], 0)
	points = sample(points, N)

	def cross(a, b):
		return a.real * b.imag - a.imag * b.real

	def norm2(a):
		return a.real * a.real + a.imag * a.imag

	def make_circle_3(a, b, c):
		(A, B, C) = (norm2(b - c), norm2(c - a), norm2(a - b))
		S = cross(b - a, c - a)
		p = (A * (B + C - A) * a + B * (C + A - B) * b + C * (A + B - C) * c) / (4 * S * S)
		radius = abs(p - a)
		return (p, radius)

	def make_circle_2(a, b):
		c = (a + b) / 2
		radius = abs(a - c)
		return (c, radius)

	def in_circle(point, circle):
		return abs(point - circle[0]) <= circle[1] + 1e-07
	p0 = points[0]
	circle = make_circle_2(p0, points[1])
	for (i, p_i) in enumerate(points[2:], 2):
		if not in_circle(p_i, circle):
			circle = make_circle_2(p0, p_i)
			for (j, p_j) in enumerate(points[1:i], 1):
				if not in_circle(p_j, circle):
					circle = make_circle_2(p_i, p_j)
					for p_k in points[:j]:
						if not in_circle(p_k, circle):
							circle = make_circle_3(p_i, p_j, p_k)
	return circle
N = int(input())
XY = []
for _ in range(N):
	(x, y) = map(int, input().split())
	XY.append(x + y * 1j)
(center, rad) = min_disc(XY)
print(rad)


import sys

def f(p, q):
	num = 0
	for (ppp, qqq) in xy:
		num = max(num, (p - ppp) ** 2 + (q - qqq) ** 2)
	return num
inf = float('inf')
N = int(input())
xy = [list(map(int, input().split())) for i in range(N)]
ans = inf
if N == 2:
	x = (xy[0][0] + xy[1][0]) / 2
	y = (xy[0][1] + xy[1][1]) / 2
	(p, q) = xy[0]
	num = (x - p) ** 2 + (y - q) ** 2
	print(num ** 0.5)
	sys.exit()
for i in range(N - 2):
	for j in range(i + 1, N - 1):
		for k in range(j + 1, N):
			(p, q) = xy[i]
			(r, s) = xy[j]
			(v, w) = xy[k]
			a = 2 * v - 2 * r
			b = 2 * w - 2 * s
			c = v ** 2 + w ** 2 - r ** 2 - s ** 2
			d = 2 * p - 2 * r
			e = 2 * q - 2 * s
			f = p ** 2 + q ** 2 - r ** 2 - s ** 2
			if a * e == b * d:
				num = 0
			else:
				x = (c * e - b * f) / (a * e - b * d)
				y = (c * d - a * f) / (b * d - a * e)
				num = 0
				for (ppp, qqq) in xy:
					num = max(num, (x - ppp) ** 2 + (y - qqq) ** 2)
				ans = min(ans, num)
			(x, y) = ((p + r) / 2, (q + s) / 2)
			num = 0
			for (ppp, qqq) in xy:
				num = max(num, (x - ppp) ** 2 + (y - qqq) ** 2)
			ans = min(ans, num)
			(x, y) = ((p + v) / 2, (q + w) / 2)
			num = 0
			for (ppp, qqq) in xy:
				num = max(num, (x - ppp) ** 2 + (y - qqq) ** 2)
			ans = min(ans, num)
			(x, y) = ((r + v) / 2, (s + w) / 2)
			num = 0
			for (ppp, qqq) in xy:
				num = max(num, (x - ppp) ** 2 + (y - qqq) ** 2)
			ans = min(ans, num)
print(ans ** 0.5)


from math import sqrt

def colinear(x1, y1, x2, y2, x3, y3):
	a = x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)
	if a == 0:
		return True
	else:
		return False

def distance(x1, y1, x2, y2):
	xd = (x1 - x2) ** 2
	yd = (y1 - y2) ** 2
	return sqrt(xd + yd)

def check(cx, cy, r, x, y, n):
	for i in range(n):
		d = distance(cx, cy, x[i], y[i])
		if d - r > 0.1:
			return False
	return True

def circlebydiaendpoints(x1, y1, x2, y2):
	cx = (x1 + x2) / 2
	cy = (y1 + y2) / 2
	r = distance(cx, cy, x1, y1)
	return (cx, cy, r)

def makeCircumcircle(x1, y1, x2, y2, x3, y3):
	ox = (min(min(x1, x2), x3) + max(min(x1, x2), x3)) / 2
	oy = (min(min(y1, y2), y3) + max(min(y1, y2), y3)) / 2
	ax = x1 - ox
	ay = y1 - oy
	bx = x2 - ox
	by = y2 - oy
	cx = x3 - ox
	cy = y3 - oy
	d = (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by)) * 2
	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
	cx = ox + x
	cy = oy + y
	r = max(max(distance(cx, cy, x1, y1), distance(cx, cy, x2, y2)), distance(cx, cy, x3, y3))
	return (cx, cy, r)

def main():
	n = int(input())
	x = []
	y = []
	for _ in range(n):
		(a, b) = input().split(' ')
		a = float(a)
		b = float(b)
		x.append(a)
		y.append(b)
	ans = -1
	for i in range(n - 1):
		for j in range(i + 1, n):
			(cx, cy, r) = circlebydiaendpoints(x[i], y[i], x[j], y[j])
			if check(cx, cy, r, x, y, n):
				if ans == -1:
					ans = r
				elif ans > r:
					ans = r
	for i in range(n - 2):
		for j in range(i + 1, n - 1):
			for k in range(j + 1, n):
				if colinear(x[i], y[i], x[j], y[j], x[k], y[k]):
					continue
				else:
					(cx, cy, r) = makeCircumcircle(x[i], y[i], x[j], y[j], x[k], y[k])
					if check(cx, cy, r, x, y, n):
						if ans == -1:
							ans = r
						elif ans > r:
							ans = r
	print(ans)

def __starting_point():
	main()
__starting_point()


import math
EPS = 10 ** (-8)

class P2:

	def __init__(self, x, y):
		self.x = x
		self.y = y
		self.norm2 = (self.x ** 2 + self.y ** 2) ** 0.5

	def __add__(self, other):
		return P2(self.x + other.x, self.y + other.y)

	def __sub__(self, other):
		return P2(self.x - other.x, self.y - other.y)

	def smul(self, a):
		return P2(self.x * a, self.y * a)

	def dot(self, other):
		return self.x * other.x + self.y * other.y

	def det(self, other):
		return self.x * other.y - self.y * other.x
n = int(input())
p = [P2(*map(int, input().split())) for _ in range(n)]
dist = [[(p[i] - p[j]).norm2 for j in range(n)] for i in range(n)]

def check(r):
	cand = []
	for i in range(n - 1):
		for j in range(i + 1, n):
			c_ij = (p[i] + p[j]).smul(0.5)
			d_ij = p[i] - p[j]
			if dist[i][j] < r * 2:
				h = (r ** 2 - (dist[i][j] / 2) ** 2) ** 0.5
				v = P2(-d_ij.y, d_ij.x).smul(h / d_ij.norm2)
				cand.append(c_ij + v)
				cand.append(c_ij - v)
	for cand_p in cand:
		is_in = True
		for i in range(n):
			if (p[i] - cand_p).norm2 > r + EPS:
				is_in = False
				break
		if is_in:
			return True
	return False
lb = 0.0
ub = 2000
while ub - lb > EPS:
	mid = (ub + lb) / 2
	if check(mid):
		ub = mid
	else:
		lb = mid
print(ub)


import itertools
import math

def main():
	N = int(input())
	coords = [list(map(int, input().split(' '))) for _ in range(N)]
	ans_squared = 10 ** 12
	for (i, j) in itertools.combinations(range(N), 2):
		(x1, y1) = coords[i]
		(x2, y2) = coords[j]
		d_squared = (x1 - x2) ** 2 + (y1 - y2) ** 2
		cover = True
		for n in range(N):
			(x, y) = coords[n]
			if (2 * x - (x1 + x2)) ** 2 + (2 * y - (y1 + y2)) ** 2 > d_squared:
				cover = False
				break
		if cover:
			ans_squared = min(ans_squared, d_squared / 4)
	if N == 2:
		print(math.sqrt(ans_squared))
		return
	for (i, j, k) in itertools.combinations(range(N), 3):
		(x1, y1) = coords[i]
		(x2, y2) = coords[j]
		(x3, y3) = coords[k]
		(dx12, dx23, dy12, dy23) = (x1 - x2, x2 - x3, y1 - y2, y2 - y3)
		if dx12 * dy23 == dy12 * dx23:
			continue
		(v1, v2, v3) = (x1 ** 2 + y1 ** 2, x2 ** 2 + y2 ** 2, x3 ** 2 + y3 ** 2)
		scale = 2 * (dx12 * dy23 - dy12 * dx23)
		scaled_cx = dy23 * v1 - (dy12 + dy23) * v2 + dy12 * v3
		scaled_cy = -dx23 * v1 + (dx12 + dx23) * v2 - dx12 * v3
		r_squared = (x1 - scaled_cx / scale) ** 2 + (y1 - scaled_cy / scale) ** 2
		cover = True
		for n in range(N):
			(x, y) = coords[n]
			if (scale * x - scaled_cx) ** 2 + (scale * y - scaled_cy) ** 2 > (scale * x1 - scaled_cx) ** 2 + (scale * y1 - scaled_cy) ** 2:
				cover = False
		if cover:
			ans_squared = min(ans_squared, r_squared)
	print(math.sqrt(ans_squared))

def __starting_point():
	main()
__starting_point()


N = int(input())
XY = [tuple(map(int, input().split())) for _ in range(N)]
ans = 100000000
for i in range(N):
	(ax, ay) = XY[i]
	for j in range(i + 1, N):
		(bx, by) = XY[j]
		dx = (ax + bx) / 2
		dy = (ay + by) / 2
		r2 = (ax - dx) ** 2 + (ay - dy) ** 2
		ok = True
		for (x, y) in XY:
			if (x - dx) ** 2 + (y - dy) ** 2 > r2 + 1e-05:
				ok = False
				break
		if ok:
			ans = min(ans, r2)
		for k in range(j + 1, N):
			(cx, cy) = XY[k]
			a = (bx - cx) ** 2 + (by - cy) ** 2
			b = (cx - ax) ** 2 + (cy - ay) ** 2
			c = (ax - bx) ** 2 + (ay - by) ** 2
			aa = a * (b + c - a)
			bb = b * (c + a - b)
			cc = c * (a + b - c)
			delim = aa + bb + cc
			if delim < 1e-10:
				continue
			dx = (ax * aa + bx * bb + cx * cc) / delim
			dy = (ay * aa + by * bb + cy * cc) / delim
			r2 = (ax - dx) ** 2 + (ay - dy) ** 2
			ok = True
			for (x, y) in XY:
				if (x - dx) ** 2 + (y - dy) ** 2 > r2 + 1e-05:
					ok = False
					break
			if ok:
				ans = min(ans, r2)
print(ans ** 0.5)


import sys, queue, math, copy, itertools, bisect, collections, heapq

def check(x0, y0, p, r):
	for (x, y) in p:
		if (x - x0) ** 2 + (y - y0) ** 2 > r * r + 10 ** (-9):
			return False
	return True

def main():
	eps = 10 ** (-10)
	LI = lambda : [int(x) for x in sys.stdin.readline().split()]
	NI = lambda : int(sys.stdin.readline())
	dist = lambda x1, y1, x2, y2: math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
	N = NI()
	p = [LI() for _ in range(N)]
	high = 1000
	low = 0
	while high > low + 10 ** (-8):
		mid = (high + low) / 2
		for ((x1, y1), (x2, y2)) in itertools.combinations(p, 2):
			r = dist(x1, y1, x2, y2) / 2
			if r > mid:
				low = mid
				break
			x0 = (x1 + x2) / 2
			y0 = (y1 + y2) / 2
			h = math.sqrt(mid ** 2 - r ** 2)
			if y1 == y2:
				dx = 0
				dy = h
			else:
				d = -(x1 - x2) / (y1 - y2)
				v = math.sqrt(1 + d * d)
				dx = h / v
				dy = h / v * d
			if check(x0 + dx, y0 + dy, p, mid) or check(x0 - dx, y0 - dy, p, mid):
				high = mid
				break
		else:
			low = mid
	print(low)
main()


from decimal import Decimal
import sys
input = sys.stdin.readline

def dist(x1, x2, y1, y2):
	return (y1 - y2) * (y1 - y2) + (x1 - x2) * (x1 - x2)

def farthest(x, y):
	ret = 0
	point = (-1, -1)
	for (u, v) in X:
		d = dist(x, u, y, v)
		if d > ret:
			ret = d
			point = (u, v)
	return (ret, point)
N = int(input())
X = []
for _ in [0] * N:
	(x, y) = map(int, input().split())
	X.append((x, y))
x = (max((x for (x, y) in X)) - min((x for (x, y) in X))) / 2
y = (max((y for (x, y) in X)) - min((y for (x, y) in X))) / 2
x = Decimal(str(x))
y = Decimal(str(y))
step = Decimal('0.5')
o = 1
eps = Decimal('0.00000000000001')
while o > eps:
	(_, (u, v)) = farthest(x, y)
	x += (u - x) * step
	y += (v - y) * step
	step *= Decimal('0.999')
	o = (abs(u - x) + abs(x - y)) * step
(ans, _) = farthest(x, y)
ans **= Decimal('0.5')
print(ans)


N = int(input())
x = []
for i in range(N):
	x.append(list(map(int, input().split())))

def dist2(a, b):
	return ((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2) ** 0.5
D = [[dist2(x[i], x[j]) for i in range(N)] for j in range(N)]

def dist3(i, j, k):
	(a, b, c) = (D[i][j], D[j][k], D[k][i])
	cosA = (b ** 2 + c ** 2 - a ** 2) / (2 * b * c)
	sinA = (1 - cosA ** 2) ** 0.5
	if sinA > 1e-07:
		ans = a / sinA / 2
		return ans
	else:
		return 0

def mid(a, b):
	return [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]
ans = 0
for i in range(N):
	for j in range(i + 1, N):
		ans = max(D[i][j] / 2, ans)
for i in range(N):
	for j in range(i + 1, N):
		for k in range(j + 1, N):
			flag = True
			if dist2(x[k], mid(x[i], x[j])) <= D[i][j] / 2 or dist2(x[j], mid(x[i], x[k])) <= D[i][k] / 2 or dist2(x[i], mid(x[j], x[k])) <= D[j][k] / 2:
				flag = False
			ans = max(D[i][j] / 2, D[j][k] / 2, D[k][i] / 2, ans)
			if flag:
				ans = max(dist3(i, j, k), ans)
print(ans)


n = int(input())
points = []
centers = []
INF = 1e+100
ans = INF

class Point:

	def __init__(self, x, y):
		self.x = x
		self.y = y

	def __rmul__(self, other):
		return Point(self.x * other, self.y * other)

	def __mul__(self, other):
		return Point(self.x * other, self.y * other)

	def __add__(self, other):
		return Point(self.x + other.x, self.y + other.y)

	def __sub__(self, other):
		return Point(self.x - other.x, self.y - other.y)

	def __truediv__(self, other):
		return Point(self.x / other, self.y / other)

	def sqdist(self, other):
		return (self.x - other.x) ** 2 + (self.y - other.y) ** 2

	def dist(self, other):
		return self.sqdist(other) ** 0.5

	def cross(self, other):
		return self.x * other.y - self.y * other.x

	def dot(self, other):
		return self.x * other.x + self.y * other.y

def three(A, B, C):
	a = B.sqdist(C)
	b = C.sqdist(A)
	c = A.sqdist(B)
	U = (a * (b + c - a) * A + b * (c + a - b) * B + c * (a + b - c) * C) / (a * (b + c - a) + b * (c + a - b) + c * (a + b - c))
	return U
for i in range(n):
	(x, y) = map(int, input().split())
	points.append(Point(x, y))
for i in range(n):
	for j in range(i + 1, n):
		for k in range(j + 1, n):
			if (points[j] - points[i]).cross(points[k] - points[i]) == 0:
				continue
			centers.append(three(points[i], points[j], points[k]))
for i in range(n):
	for j in range(i + 1, n):
		centers.append((points[i] + points[j]) / 2)
for center in centers:
	r = 0
	for i in range(n):
		r = max(r, center.dist(points[i]))
	ans = min(ans, r)
print(ans)


import sys
input = sys.stdin.readline
import math
rt = math.sqrt
eps = 10 ** (-6)
n = int(input())
XY = []
for i in range(n):
	XY.append(tuple(map(int, input().split())))

def dist2(xy1, xy2):
	return (xy1[0] - xy2[0]) ** 2 + (xy1[1] - xy2[1]) ** 2

def dist1(xy1, xy2):
	return rt(dist2(xy1, xy2))

def center(xy1, xy2, xy3):
	den = (xy1[0] - xy2[0]) * (xy2[1] - xy3[1]) - (xy1[1] - xy2[1]) * (xy2[0] - xy3[0])
	if den == 0:
		if dist2(xy1, xy2) >= dist2(xy2, xy3):
			if dist2(xy1, xy2) >= dist2(xy3, xy1):
				return [(xy1[0] + xy2[0]) / 2, (xy1[1] + xy2[1]) / 2, dist1(xy1, xy2) / 2]
			else:
				return [(xy3[0] + xy1[0]) / 2, (xy3[1] + xy1[1]) / 2, dist1(xy3, xy1) / 2]
		elif dist2(xy2, xy3) >= dist2(xy3, xy1):
			return [(xy2[0] + xy3[0]) / 2, (xy2[1] + xy3[1]) / 2, dist1(xy2, xy3) / 2]
		else:
			return [(xy3[0] + xy1[0]) / 2, (xy3[1] + xy1[1]) / 2, dist1(xy3, xy1) / 2]
	else:
		retx1 = xy1[0] ** 2 + xy1[1] ** 2 - (xy2[0] ** 2 + xy2[1] ** 2)
		rety1 = xy2[0] ** 2 + xy2[1] ** 2 - (xy3[0] ** 2 + xy3[1] ** 2)
		retx2 = (xy2[1] - xy3[1]) * retx1 - (xy1[1] - xy2[1]) * rety1
		rety2 = (xy3[0] - xy2[0]) * retx1 + (xy1[0] - xy2[0]) * rety1
		(retx3, rety3) = (retx2 / 2 / den, rety2 / 2 / den)
		retr = dist1([retx3, rety3], xy1)
		return [retx3, rety3, retr]
ans = float('inf')
import itertools
for (a, b) in itertools.combinations(XY, 2):
	(x, y, r) = center(a, b, b)
	chk = True
	for xy in XY:
		if dist1([x, y], xy) > r + eps:
			chk = False
	if chk:
		ans = min(ans, r)
if n >= 3:
	for (a, b, c) in itertools.combinations(XY, 3):
		(x, y, r) = center(a, b, c)
		chk = True
		for xy in XY:
			if dist1([x, y], xy) > r + eps:
				chk = False
		if chk:
			ans = min(ans, r)
print(ans)


n = int(input())
x = [0] * n
y = [0] * n
for i in range(n):
	(x[i], y[i]) = map(int, input().split())
if n == 2:
	print(((x[0] - x[1]) ** 2 + (y[0] - y[1]) ** 2) ** (1 / 2) / 2)
else:
	ans = 10 ** 5
	for i in range(n - 1):
		for j in range(i + 1, n):
			xc = (x[i] + x[j]) / 2
			yc = (y[i] + y[j]) / 2
			r = ((x[i] - xc) ** 2 + (y[i] - yc) ** 2) ** (1 / 2)
			rr = max(r * 1.000000999, r + 9.99e-07)
			aa = 0
			for l in range(n):
				if ((x[l] - xc) ** 2 + (y[l] - yc) ** 2) ** (1 / 2) > rr:
					aa = 1
			if aa == 0:
				if r < ans:
					ans = r
	A = [0] * 3
	B = [0] * 3
	for i in range(n - 2):
		for j in range(i + 1, n - 1):
			A[0] = x[j] - x[i]
			A[1] = y[j] - y[i]
			A[2] = A[0] * (x[i] + x[j]) / 2 + A[1] * (y[i] + y[j]) / 2
			for k in range(j + 1, n):
				B[0] = x[k] - x[i]
				B[1] = y[k] - y[i]
				B[2] = B[0] * (x[i] + x[k]) / 2 + B[1] * (y[i] + y[k]) / 2
				if A[0] * B[1] == A[1] * B[0] and A[0] * B[1] != 0:
					r = ((max(x[i], x[j], x[k]) - min(x[i], x[j], x[k])) ** 2 + (max(y[i], y[j], y[k]) - min(y[i], y[j], y[k])) ** 2) ** (1 / 2) / 2
					xc = (max(x[i], x[j], x[k]) + min(x[i], x[j], x[k])) / 2
					yc = (max(y[i], y[j], y[k]) + min(y[i], y[j], y[k])) / 2
				elif A[0] == B[0] == 0:
					r = (max(y[i], y[j], y[k]) - min(y[i], y[j], y[k])) / 2
					xc = x[i]
					yc = (max(y[i], y[j], y[k]) + min(y[i], y[j], y[k])) / 2
				elif A[1] == B[1] == 0:
					r = (max(x[i], x[j], x[k]) - min(x[i], x[j], x[k])) / 2
					yc = y[i]
					xc = (max(x[i], x[j], x[k]) + min(x[i], x[j], x[k])) / 2
				else:
					xc = (A[2] * B[1] - A[1] * B[2]) / (A[0] * B[1] - A[1] * B[0])
					yc = (A[0] * B[2] - A[2] * B[0]) / (A[0] * B[1] - A[1] * B[0])
					r = ((x[i] - xc) ** 2 + (y[i] - yc) ** 2) ** (1 / 2)
				aa = 0
				rr = max(r * 1.000000999, r + 9.99e-07)
				for l in range(n):
					if ((x[l] - xc) ** 2 + (y[l] - yc) ** 2) ** (1 / 2) > rr:
						aa = 1
				if aa == 0:
					if r < ans:
						ans = r
	print(ans)


import sys
sys.setrecursionlimit(10 ** 6)
readline = sys.stdin.readline
read = sys.stdin.read
n = int(input())
xy = [[int(i) for i in readline().split()] for _ in range(n)]

def get_max_dist_and_index(a, b):
	d = [(a - x) ** 2 + (b - y) ** 2 for (x, y) in xy]
	m = 0
	idx = 0
	for (i, di) in enumerate(d):
		if m < di:
			idx = i
			m = di
	return (m, idx)
x0 = y0 = 0
r = 100.0
ratio = 0.99
ans = 10000000
for _ in range(100000):
	(m, i) = get_max_dist_and_index(x0, y0)
	m **= 0.5
	ans = min(ans, m)
	(dx, dy) = (xy[i][0] - x0, xy[i][1] - y0)
	x0 += r * dx / m
	y0 += r * dy / m
	r *= ratio
print(ans)


import bisect, collections, copy, heapq, itertools, math, string
import sys

def I():
	return int(sys.stdin.readline().rstrip())

def MI():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def LI():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def S():
	return sys.stdin.readline().rstrip()

def LS():
	return list(sys.stdin.readline().rstrip().split())
from collections import deque, defaultdict, Counter
import heapq
from functools import reduce
import numpy as np
from math import sqrt

class Vector:

	def __init__(self, ls):
		self.vec = ls

	def __len__(self):
		return len(self.vec)

	def __getitem__(self, idx):
		return self.vec[idx]

	def __repr__(self):
		return f'Vector({self.vec})'

	def add(self, vec):
		assert len(self) == len(vec)
		ret = [a + b for (a, b) in zip(self.vec, vec.vec)]
		return Vector(ret)

	def sub(self, vec):
		assert len(self) == len(vec)
		ret = [a - b for (a, b) in zip(self.vec, vec.vec)]
		return Vector(ret)

	def mul(self, vec):
		assert len(self) == len(vec)
		ret = [a * b for (a, b) in zip(self.vec, vec.vec)]
		return Vector(ret)

	def norm(self):
		tmp = sum([x * x for x in self.vec])
		return sqrt(tmp)

def norm(vec):
	return vec.norm()

def cross(a, b):
	assert len(a) == 2 and len(b) == 2
	first = a[0] * b[1]
	second = a[1] * b[0]
	return first - second

def dot(a, b):
	return sum(a.mul(b))
EPS = 1e-10

def is_ccw(p0, p1, p2):
	a = p1.sub(p0)
	b = p2.sub(p0)
	if cross(a, b) > EPS:
		return True
	else:
		return False

def convex_hull(points: list):
	points.sort(key=lambda x: (x[0], x[1]))
	if len(points) < 3:
		pass
	conv_upper = [points[0], points[1]]
	for p in points[2:]:
		while len(conv_upper) >= 2 and is_ccw(conv_upper[-2], conv_upper[-1], p):
			conv_upper.pop()
		conv_upper.append(p)
	points = points[::-1]
	conv_lower = [points[0], points[1]]
	for p in points[2:]:
		while len(conv_lower) >= 2 and is_ccw(conv_lower[-2], conv_lower[-1], p):
			conv_lower.pop()
		conv_lower.append(p)
	ret = conv_upper[1:-1] + conv_lower
	return ret[::-1]

def main():
	N = I()
	points = []
	for i in range(N):
		points.append(Vector(list(MI())))
	ans = convex_hull(points)
	X = len(ans)
	dist_list = []
	for i in range(X):
		for j in range(X):
			dist = pow((ans[i][0] - ans[j][0]) ** 2 + (ans[i][1] - ans[j][1]) ** 2, 0.5)
			dist_list.append((dist, i, j))
	dist_list.sort(key=lambda tup: tup[0], reverse=True)
	x_ = (ans[dist_list[0][1]][0] + ans[dist_list[0][2]][0]) / 2
	y_ = (ans[dist_list[0][1]][1] + ans[dist_list[0][2]][1]) / 2
	max_dist = dist_list[0][0] / 2
	cnt = 0
	for a in ans:
		ran = pow((a[0] - x_) ** 2 + (a[1] - y_) ** 2, 0.5)
		if ran > max_dist:
			break
		cnt += 1
	if cnt == X:
		print(max_dist)
		return
	dif_list = []
	for i in range(X):
		for j in range(X):
			for k in range(X):
				if i == j or j == k or i == k:
					continue
				ra = np.array([ans[i][0], ans[i][1]])
				rb = np.array([ans[j][0], ans[j][1]])
				rc = np.array([ans[k][0], ans[k][1]])
				A = np.dot(rb - rc, rb - rc)
				B = np.dot(rc - ra, rc - ra)
				C = np.dot(ra - rb, ra - rb)
				T = A * (B + C - A)
				U = B * (C + A - B)
				W = C * (A + B - C)
				rcc = (T * ra + U * rb + W * rc) / (T + U + W)
				px = rcc[0]
				py = rcc[1]
				dif = pow((px - ans[i][0]) ** 2 + (py - ans[i][1]) ** 2, 0.5)
				cnt_ = 0
				for a in ans:
					ran = pow((a[0] - px) ** 2 + (a[1] - py) ** 2, 0.5)
					if ran > dif:
						break
					cnt_ += 1
				if cnt_ == X:
					dif_list.append(dif)
	print(min(dif_list))

def __starting_point():
	main()
__starting_point()


import numpy as np
N = int(input())
x_lis = []
y_lis = []
for i in range(N):
	(num_x, num_y) = map(int, input().split())
	x_lis.append(num_x)
	y_lis.append(num_y)

def a(X, Y, Z):
	A = np.dot(Y - Z, Y - Z)
	B = np.dot(Z - X, Z - X)
	C = np.dot(X - Y, X - Y)
	T = A * (B + C - A)
	U = B * (C + A - B)
	W = C * (A + B - C)
	if not T + U + W:
		return [10 ** 9, 10 ** 9]
	else:
		return (T * X + U * Y + W * Z) / (T + U + W)
r = 10 ** 9
for i in range(len(x_lis) - 1):
	for j in range(i + 1, len(x_lis)):
		x1 = x_lis[i]
		y1 = y_lis[i]
		x2 = x_lis[j]
		y2 = y_lis[j]
		center_x = (x1 + x2) / 2
		center_y = (y1 + y2) / 2
		dist = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5 / 2
		if max([((center_x - i) ** 2 + (center_y - j) ** 2) ** 0.5 for (i, j) in zip(x_lis, y_lis)]) == dist:
			r = min(dist, r)
for i in range(len(x_lis) - 2):
	for j in range(i + 1, len(x_lis) - 1):
		for k in range(j + 1, len(x_lis)):
			x1 = x_lis[i]
			y1 = y_lis[i]
			x2 = x_lis[j]
			y2 = y_lis[j]
			x3 = x_lis[k]
			y3 = y_lis[k]
			center = a(np.array([x1, y1]), np.array([x2, y2]), np.array([x3, y3]))
			dist = ((center[0] - x1) ** 2 + (center[1] - y1) ** 2) ** 0.5
			if max([((center[0] - i) ** 2 + (center[1] - j) ** 2) ** 0.5 for (i, j) in zip(x_lis, y_lis)]) == dist:
				r = min(dist, r)
print(r)


import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

def II():
	return int(sys.stdin.readline())

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

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

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def main():

	def dist_x(cx):
		b = 0
		t = 1000
		for _ in range(roop):
			cb = (t + 2 * b) / 3
			ct = (2 * t + b) / 3
			if dist_xy(cx, cb) > dist_xy(cx, ct):
				b = cb
			else:
				t = ct
		return dist_xy(cx, b)

	def dist_xy(cx, cy):
		mx = 0
		for (x, y) in xy:
			d = (x - cx) ** 2 + (y - cy) ** 2
			if d > mx:
				mx = d
		return mx
	n = II()
	xy = [LI() for _ in range(n)]
	l = 0
	r = 1000
	roop = 100
	for _ in range(roop):
		cl = (2 * l + r) / 3
		cr = (l + 2 * r) / 3
		if dist_x(cl) > dist_x(cr):
			l = cl
		else:
			r = cr
	print(dist_x(l) ** 0.5)
main()


n = int(input())

def cross_plots(x1, x2, y1, y2, r):
	(dx, dy) = (x2 - x1, y2 - y1)
	d = dx ** 2 + dy ** 2
	t = ((4 * r ** 2 - d) / (4 * d)) ** 0.5
	(nx, ny) = (-t * dy, t * dx)
	return (((x1 + x2) / 2 + nx, (y1 + y2) / 2 + ny), ((x1 + x2) / 2 - nx, (y1 + y2) / 2 - ny))
plots = [tuple(map(int, input().split())) for _ in range(n)]
(l, r) = (0, 2000)
while r - l > 10 ** (-7):
	R = (r + l) / 2
	cross = []
	flg = False
	for i in range(n):
		for j in range(i + 1, n):
			(x1, y1) = plots[i]
			(x2, y2) = plots[j]
			(dx, dy) = (x2 - x1, y2 - y1)
			if dx ** 2 + dy ** 2 > 4 * R ** 2:
				flg = True
				break
			(p1, p2) = cross_plots(x1, x2, y1, y2, R)
			cross.append(p1)
			cross.append(p2)
	if flg:
		l = R
		continue
	for (xc, yc) in cross:
		if all(((xc - x) ** 2 + (yc - y) ** 2 < R ** 2 + 1e-08 for (x, y) in plots)):
			flg = True
			break
	if flg:
		r = R
	else:
		l = R
print(r)


import math

def main():
	N = int(input())
	points = []
	for i in range(N):
		(x, y) = [int(s) for s in input().split()]
		points.append((x, y))
	l = 0
	r = 1000
	for i in range(80):
		c1 = (l * 2 + r) / 3
		c2 = (l + r * 2) / 3
		if g(points, c1) > g(points, c2):
			l = c1
		else:
			r = c2
	print(g(points, l))

def g(points, x):
	l = 0
	r = 1000
	for i in range(80):
		c1 = (l * 2 + r) / 3
		c2 = (l + r * 2) / 3
		if f(points, x, c1) > f(points, x, c2):
			l = c1
		else:
			r = c2
	return f(points, x, l)

def f(points, x, y):
	max_distance = 0
	for i in range(len(points)):
		d = distance(x, y, float(points[i][0]), float(points[i][1]))
		if d > max_distance:
			max_distance = d
	return max_distance

def distance(x1, y1, x2, y2):
	return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
main()


n = int(input())
l = []
for i in range(n):
	(x, y) = [int(j) for j in input().split()]
	l.append((x, y))

def loss(x, y):
	maxi = 0
	for (i, j) in l:
		maxi = max(maxi, (i - x) ** 2 + (j - y) ** 2)
	return maxi

def f(x):
	left = 0
	right = 1000
	num = 100
	for i in range(num):
		c1 = (2 * left + right) / 3
		c2 = (left + 2 * right) / 3
		if loss(x, c1) < loss(x, c2):
			right = c2
		else:
			left = c1
	return loss(x, left)
left = 0
right = 1000
num = 100
for i in range(num):
	c1 = (2 * left + right) / 3
	c2 = (left + 2 * right) / 3
	if f(c1) < f(c2):
		right = c2
	else:
		left = c1
ans = f(left) ** 0.5
print(ans)


N = int(input())
XY = tuple((tuple(map(int, input().split())) for _ in range(N)))
lx = 0
rx = 1000
ans = 10 ** 18
for _ in range(100):
	ly = 0
	ry = 1000
	mlx = (2 * lx + rx) / 3
	for _ in range(100):
		mry = (ly + 2 * ry) / 3
		mly = (2 * ly + ry) / 3
		Rr = max(((x - mlx) ** 2 + (y - mry) ** 2 for (x, y) in XY))
		Rl = max(((x - mlx) ** 2 + (y - mly) ** 2 for (x, y) in XY))
		if Rl < Rr:
			ry = mry
		else:
			ly = mly
	R_left = Rl
	ly = 0
	ry = 1000
	mrx = (lx + 2 * rx) / 3
	for _ in range(100):
		mry = (ly + 2 * ry) / 3
		mly = (2 * ly + ry) / 3
		Rr = max(((x - mrx) ** 2 + (y - mry) ** 2 for (x, y) in XY))
		Rl = max(((x - mrx) ** 2 + (y - mly) ** 2 for (x, y) in XY))
		if Rl < Rr:
			ry = mry
		else:
			ly = mly
	R_right = Rl
	if R_left < R_right:
		rx = mrx
	else:
		lx = mlx
print(R_right ** 0.5)


def f_enclose_all():
	from itertools import combinations
	N = int(input())
	Pos = [[int(i) for i in input().split()] for j in range(N)]
	Pos_complex = [x + y * 1j for (x, y) in Pos]

	def find_circumcenter(z0, z1, z2):
		z1 -= z0
		z2 -= z0
		if abs((z1 * z2.conjugate()).imag) < 0.5:
			return None
		numerator = z1 * z2 * (z1 - z2).conjugate()
		denominator = z1.conjugate() * z2 - z1 * z2.conjugate()
		return numerator / denominator + z0
	candidate = []
	for comb in combinations(Pos_complex, 3):
		o = find_circumcenter(*comb)
		if o is not None:
			candidate.append(o)
	for (z1, z2) in combinations(Pos_complex, 2):
		candidate.append((z1 + z2) / 2)
	ans = float('inf')
	for c in candidate:
		radius = 0
		for z in Pos_complex:
			radius = max(radius, abs(z - c))
		ans = min(ans, radius)
	return round(ans, 10)
print(f_enclose_all())


import math
N = int(input())
x = [0 for i in range(N)]
y = [0 for i in range(N)]
p = []
for i in range(N):
	(x[i], y[i]) = map(int, input().split())
	p.append((x[i], y[i]))

def dist(p, q):
	(a, b) = p
	(c, d) = q
	return math.sqrt((a - c) ** 2 + (b - d) ** 2)

def check(R):
	Q = []
	for i in range(N):
		for j in range(i + 1, N):
			d = dist(p[i], p[j]) / 2
			if R < d:
				return False
			h = math.sqrt(R * R - d * d)
			(nx, ny) = (x[j] - x[i], y[j] - y[i])
			nr = math.sqrt(nx ** 2 + ny ** 2)
			(dx, dy) = (h * nx / nr, h * ny / nr)
			(mx, my) = ((x[i] + x[j]) / 2, (y[i] + y[j]) / 2)
			Q.append((mx + dy, my - dx))
			Q.append((mx - dy, my + dx))
	for pa in Q:
		flag = 1
		for i in range(N):
			if dist(pa, p[i]) > R + 9e-07:
				flag = 0
				break
		if flag == 1:
			return True
	return False
low = 0
high = 2000
for line in range(50):
	mid = (low + high) / 2
	if check(mid):
		high = mid
	else:
		low = mid
print(mid)


def f_enclose_all():
	from itertools import combinations
	N = int(input())
	Pos_complex = [complex(*map(int, input().split())) for j in range(N)]

	def find_circumcenter(z0, z1, z2):
		z1 -= z0
		z2 -= z0
		if abs((z1 * z2.conjugate()).imag) < 0.5:
			return None
		numerator = z1 * z2 * (z1 - z2).conjugate()
		denominator = z1.conjugate() * z2 - z1 * z2.conjugate()
		return numerator / denominator + z0
	candidate = [(z1 + z2) / 2 for (z1, z2) in combinations(Pos_complex, 2)]
	candidate.extend([find_circumcenter(*comb) for comb in combinations(Pos_complex, 3)])
	ans = min((max((abs(z - c) for z in Pos_complex)) for c in candidate if c is not None))
	return round(ans, 10)
print(f_enclose_all())


import math
n = int(input())
xy = [list(map(int, input().split())) for _ in range(n)]
point = []
r = 0
for i in range(n - 1):
	(x1, y1) = xy[i]
	for j in range(i + 1, n):
		(x2, y2) = xy[j]
		d = ((x1 - x2) / 2) ** 2 + ((y1 - y2) / 2) ** 2
		if r ** 2 > d:
			if y1 - y2 != 0:
				a = -(x1 - x2) / (y1 - y2)
				x = math.sqrt((r ** 2 - d) / (a ** 2 + 1)) // 10 ** (-6) * 10 ** (-6)
				point.append([(x1 + x2) / 2 + x, (y1 + y2) / 2 + a * x])
				point.append([(x1 + x2) / 2 - x, (y1 + y2) / 2 - a * x])
			else:
				x = math.sqrt(r ** 2 - d) // 1 // 10 ** (-6) * 10 ** (-6)
				point.append([(x1 + x2) / 2, (y1 + y2) / 2 + x])
				point.append([(x1 + x2) / 2, (y1 + y2) / 2 - x])
		elif r ** 2 == d:
			point.append([(x1 + x2) / 2, (y1 + y2) / 2])
r_o = 800
r_i = 0
while r_o - r_i > 10 ** (-8):
	judge = 0
	while point:
		(x, y) = point.pop()
		c = 0
		for (i, j) in xy:
			if (x - i) ** 2 + (y - j) ** 2 > r ** 2:
				c = 1
				break
		if c == 0:
			judge = 1
			break
	if judge == 1:
		r_o = r
	else:
		r_i = r
	r = (r_o + r_i) / 2
	point = []
	for i in range(n - 1):
		(x1, y1) = xy[i]
		for j in range(i + 1, n):
			(x2, y2) = xy[j]
			d = ((x1 - x2) / 2) ** 2 + ((y1 - y2) / 2) ** 2
			if r ** 2 > d:
				if y1 - y2 != 0:
					a = -(x1 - x2) / (y1 - y2)
					x = math.sqrt((r ** 2 - d) / (a ** 2 + 1)) // 10 ** (-6) * 10 ** (-6)
					point.append([(x1 + x2) / 2 + x, (y1 + y2) / 2 + a * x])
					point.append([(x1 + x2) / 2 - x, (y1 + y2) / 2 - a * x])
				else:
					x = math.sqrt(r ** 2 - d) // 10 ** (-6) * 10 ** (-6)
					point.append([(x1 + x2) / 2, (y1 + y2) / 2 + x])
					point.append([(x1 + x2) / 2, (y1 + y2) / 2 - x])
			elif r ** 2 == d:
				point.append([(x1 + x2) / 2, (y1 + y2) / 2])
print(r)


import numpy as np
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
N = int(input())
(X, Y) = ([], [])
for _ in range(N):
	(tx, ty) = list(map(int, input().split()))
	X.append(tx)
	Y.append(ty)
X = np.array(X)
Y = np.array(Y)

def dist(cx, cy):
	tmp = ((X - cx) ** 2 + (Y - cy) ** 2) ** 0.5
	return max(tmp)

def g(cx):
	(ll, rr) = (0, 1000)
	for _ in range(80):
		cll = (ll * 2 + rr) / 3
		crr = (ll + rr * 2) / 3
		if dist(cx, cll) >= dist(cx, crr):
			ll = cll
		else:
			rr = crr
	return dist(cx, ll)
(l, r) = (0, 1000)
for _ in range(80):
	cl = (l * 2 + r) / 3
	cr = (l + r * 2) / 3
	if g(cl) >= g(cr):
		l = cl
	else:
		r = cr
ans = g(l)
print(ans)


import sys
sys.setrecursionlimit(10 ** 9)
input = lambda : sys.stdin.readline().rstrip()
inpl = lambda : list(map(int, input().split()))
N = int(input())
x = []
y = []
for i in range(N):
	xy = inpl()
	x.append(xy[0])
	y.append(xy[1])
ans2 = 10 ** 12
for i in range(N - 2):
	for j in range(i + 1, N - 1):
		for k in range(j + 1, N):
			a = 2 * (x[j] - x[i])
			c = 2 * (x[k] - x[j])
			b = 2 * (y[j] - y[i])
			d = 2 * (y[k] - y[j])
			P = x[j] ** 2 - x[i] ** 2 + y[j] ** 2 - y[i] ** 2
			Q = x[k] ** 2 - x[j] ** 2 + y[k] ** 2 - y[j] ** 2
			det = a * d - b * c
			if det == 0:
				continue
			Cx = (d * P - b * Q) / det
			Cy = (a * Q - c * P) / det
			r2 = (Cx - x[i]) ** 2 + (Cy - y[i]) ** 2
			for p in range(N):
				if p in (i, j, k):
					continue
				if (Cx - x[p]) ** 2 + (Cy - y[p]) ** 2 > r2:
					break
			else:
				if r2 < ans2:
					ans2 = r2
for i in range(N - 1):
	for j in range(i + 1, N):
		Cx = (x[i] + x[j]) / 2
		Cy = (y[i] + y[j]) / 2
		r2 = ((x[i] - x[j]) ** 2 + (y[i] - y[j]) ** 2) / 4
		for p in range(N):
			if p in (i, j):
				continue
			if (Cx - x[p]) ** 2 + (Cy - y[p]) ** 2 > r2:
				break
		else:
			if r2 < ans2:
				ans2 = r2
print(ans2 ** 0.5)


import math

def f(a, b, x, y):
	ans = math.sqrt((a - x) * (a - x) + (b - y) * (b - y))
	return ans

def circumcenter(ax, ay, bx, by, cx, cy):
	d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by))
	if d == 0:
		return (-1, -1)
	ux = ((ax * ax + ay * ay) * (by - cy) + (bx * bx + by * by) * (cy - ay) + (cx * cx + cy * cy) * (ay - by)) / d
	uy = ((ax * ax + ay * ay) * (cx - bx) + (bx * bx + by * by) * (ax - cx) + (cx * cx + cy * cy) * (bx - ax)) / d
	return (ux, uy)
n = int(input())
x = []
y = []
for i in range(n):
	(u, v) = map(int, input().split())
	x.append(u)
	y.append(v)
if n == 2:
	ans = f(x[0], y[0], x[1], y[1]) / 2
	print('%0.12f' % ans)
else:
	radius = 20000
	for i in range(n):
		for j in range(i + 1, n):
			for k in range(j + 1, n):
				(a, b) = circumcenter(x[i], y[i], x[j], y[j], x[k], y[k])
				if a == -1 and b == -1:
					continue
				r = f(a, b, x[i], y[i])
				ff = 1
				for l in range(n):
					if f(a, b, x[l], y[l]) > r:
						ff = 0
						break
				if ff:
					radius = min(radius, r)
	for i in range(n):
		for j in range(i + 1, n):
			a = (x[i] + x[j]) / 2
			b = (y[i] + y[j]) / 2
			r = f(x[i], y[i], x[j], y[j]) / 2
			ff = 1
			for k in range(n):
				if f(a, b, x[k], y[k]) > r:
					ff = 0
					break
			if ff:
				radius = min(r, radius)
	print('%0.12f' % radius)


from math import sqrt

def dist(x1, y1, x2, y2):
	return sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2) + 10 ** (-7)

def max_dist(p, x, y):
	res = 0
	for i in range(len(p)):
		dis = dist(p[i][0], p[i][1], x, y)
		if res < dis:
			res = dis
	return res

def calc(p, x):
	(yL, yR) = (0, 1000)
	while yL + 10 ** (-7) < yR:
		(yl, yr) = ((2 * yL + yR) / 3, (yL + 2 * yR) / 3)
		(ql, qr) = (max_dist(p, x, yl), max_dist(p, x, yr))
		if ql < qr:
			yR = yr
		else:
			yL = yl
	return (qr, yR)

def main():
	n = int(input())
	p = [list(map(int, input().split())) for _ in range(n)]
	(xL, xR) = (0, 1000)
	while xL + 10 ** (-7) < xR:
		(xl, xr) = ((2 * xL + xR) / 3, (xL + 2 * xR) / 3)
		(ql, yl) = calc(p, xl)
		(qr, yr) = calc(p, xr)
		if ql < qr:
			xR = xr
		else:
			xL = xl
	print(max_dist(p, xR, yr))
main()


from fractions import Fraction
from math import sqrt
n = int(input())
p = []
for i in range(n):
	p.append(list(map(int, input().split())))
ans = 0
for i in range(n - 1):
	for j in range(i + 1, n):
		flag = True
		(x1, y1) = (p[i][0], p[i][1])
		(x2, y2) = (p[j][0], p[j][1])
		d = (x2 - x1) ** 2 + (y2 - y1) ** 2
		for k in range(n):
			if i == k or j == k:
				continue
			(x3, y3) = (p[k][0], p[k][1])
			e = (x3 - x1) ** 2 + (y3 - y1) ** 2 + (x3 - x2) ** 2 + (y3 - y2) ** 2
			if d < e:
				flag = False
				break
		if flag:
			ans = sqrt(d) / 2.0
if ans != 0:
	print(ans)
	return
ans = 100000000
for i in range(n - 2):
	for j in range(i + 1, n - 1):
		for k in range(j + 1, n):
			(a, b) = (p[i][0], p[i][1])
			(c, d) = (p[j][0], p[j][1])
			(e, f) = (p[k][0], p[k][1])
			if a == c == e or b == d == f:
				continue
			ny = (e - a) * (a * a + b * b - c * c - d * d) - (c - a) * (a * a + b * b - e * e - f * f)
			dy = 2 * (e - a) * (b - d) - 2 * (c - a) * (b - f)
			if dy == 0:
				continue
			py = Fraction(ny, dy)
			if c != a:
				px = 2 * (b - d) * py - a * a - b * b + c * c + d * d
				px /= 2 * (c - a)
			else:
				px = 2 * (b - f) * py - a * a - b * b + e * e + f * f
				px /= 2 * (e - a)
			r = (c - px) ** 2 + (d - py) ** 2
			flag = True
			for l in range(n):
				if l == i or l == j or l == k:
					continue
				(x, y) = (p[l][0], p[l][1])
				s = (x - px) ** 2 + (y - py) ** 2
				if r < s:
					flag = False
					break
			if flag:
				q = r.numerator / r.denominator
				q = sqrt(q)
				ans = min(ans, q)
print(ans)


import itertools
import math

def distance(a, b):
	(a_x, a_y) = a
	(b_x, b_y) = b
	d = ((a_x - b_x) ** 2 + (a_y - b_y) ** 2) ** 0.5
	return d

def edges(a, b, c, sort=False):
	(a_x, a_y) = a
	(b_x, b_y) = b
	(c_x, c_y) = c
	d1 = ((a_x - b_x) ** 2 + (a_y - b_y) ** 2) ** 0.5
	d2 = ((b_x - c_x) ** 2 + (b_y - c_y) ** 2) ** 0.5
	d3 = ((c_x - a_x) ** 2 + (c_y - a_y) ** 2) ** 0.5
	if sort:
		(d1, d2, d3) = sorted([d1, d2, d3], reverse=True)
	return (d1, d2, d3)

def is_acute(d1, d2, d3):
	(d1, d2, d3) = sorted([d1, d2, d3], reverse=True)
	return d1 ** 2 < d2 ** 2 + d3 ** 2
N = int(input())
xy = tuple((tuple((int(i) for i in input().split())) for _ in range(N)))
if N == 2:
	ans = distance(xy[0], xy[1]) / 2
else:
	ans = 0
	for (p1, p2, p3) in itertools.combinations(xy, 3):
		(d1, d2, d3) = edges(p1, p2, p3)
		if is_acute(d1, d2, d3):
			r = d1 * d2 * d3 / ((d1 + d2 + d3) * (d1 + d2 - d3) * (d1 - d2 + d3) * (-d1 + d2 + d3)) ** 0.5
			ans = max(ans, r)
		else:
			r = max(d1, d2, d3) / 2
			ans = max(ans, r)
print(ans)


from math import sqrt
n = int(input())
points = []
for i in range(n):
	(x, y) = map(float, input().split())
	points.append((x, y))
lower = 0
upper = 10000

def get_cross_point(p1, p2, r):
	(x, y) = p2
	x -= p1[0]
	y -= p1[1]
	a = (x ** 2 + y ** 2) / 2
	if (x ** 2 + y ** 2) * r ** 2 - a ** 2 < 0:
		return None
	x1 = (a * x + y * sqrt((x ** 2 + y ** 2) * r ** 2 - a ** 2)) / (x ** 2 + y ** 2)
	y1 = (a * y - x * sqrt((x ** 2 + y ** 2) * r ** 2 - a ** 2)) / (x ** 2 + y ** 2)
	x2 = (a * x - y * sqrt((x ** 2 + y ** 2) * r ** 2 - a ** 2)) / (x ** 2 + y ** 2)
	y2 = (a * y + x * sqrt((x ** 2 + y ** 2) * r ** 2 - a ** 2)) / (x ** 2 + y ** 2)
	x1 += p1[0]
	x2 += p1[0]
	y1 += p1[1]
	y2 += p1[1]
	return ((x1, y1), (x2, y2))

def square_dist(p0, p1):
	return (p0[0] - p1[0]) ** 2 + (p0[1] - p1[1]) ** 2

def check_all_in_r(p, r):
	for q in points:
		if square_dist(p, q) > r ** 2 + 1e-07:
			return False
	return True

def check(r):
	for i in range(n):
		for j in range(i + 1, n):
			cross_points = get_cross_point(points[i], points[j], r)
			if cross_points is None:
				return False
			for p in cross_points:
				if check_all_in_r(p, r):
					return True
	return False
for _ in range(100):
	middle = (upper + lower) / 2
	if check(middle):
		upper = middle
	else:
		lower = middle
print(middle)


def dis(x1, y1, x2, y2):
	return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
N = int(input())
xy = []
rmax = 2000
r = 1000
rmin = 0
eps = 1e-09
for i in range(N):
	(x, y) = map(int, input().split())
	xy.append((x, y))
for i in range(50):
	intersections = []
	for i in range(N):
		(xi, yi) = xy[i]
		for j in range(N):
			if i < j:
				(xj, yj) = xy[j]
				xc = (xi + xj) / 2
				yc = (yi + yj) / 2
				dc = dis(xc, yc, xi, yi)
				if r > dc:
					d = (r ** 2 - dc ** 2) ** 0.5
					intersections.append((xc + (yc - yi) * d / dc, yc - (xc - xi) * d / dc))
					intersections.append((xc - (yc - yi) * d / dc, yc + (xc - xi) * d / dc))
	ans = False
	for (x, y) in intersections:
		for i in range(N):
			(xi, yi) = xy[i]
			if dis(x, y, xi, yi) > r + eps:
				break
		else:
			ans = True
	if ans:
		rmax = r
	else:
		rmin = r
	r = (rmax + rmin) / 2
print(r)


import math

def calc_max_distance(guess_x, guess_y, data):
	max_distance = 0
	for (x, y) in data:
		distance = math.sqrt((guess_x - x) ** 2 + (guess_y - y) ** 2)
		max_distance = max(max_distance, distance)
	return max_distance
EPS = pow(10, -9)

def iterate(x, data):
	left = 0.0
	right = 1000.0
	while right - left > EPS:
		left_mid = left + (right - left) / 3
		right_mid = right - (right - left) / 3
		if calc_max_distance(x, left_mid, data) > calc_max_distance(x, right_mid, data):
			left = left_mid
		else:
			right = right_mid
	return calc_max_distance(x, left, data)

def outer_iterate(data):
	left = 0.0
	right = 1000.0
	while right - left > EPS:
		left_mid = left + (right - left) / 3
		right_mid = right - (right - left) / 3
		if iterate(left_mid, data) > iterate(right_mid, data):
			left = left_mid
		else:
			right = right_mid
	return iterate(left, data)
n = int(input())
data = []
for _ in range(n):
	(a, b) = map(int, input().split())
	data.append([a, b])
print(outer_iterate(data))


from scipy.optimize import fmin
n = int(input())
l = []
for i in range(n):
	(x, y) = [int(j) for j in input().split()]
	l.append((x, y))

def f(s):
	(x, y) = s
	maxi = 0
	for (i, j) in l:
		maxi = max(maxi, (i - x) ** 2 + (j - y) ** 2)
	return maxi
(x, y) = fmin(f, [100, 100], xtol=10 ** (-9), disp=0)
ans = f((x, y)) ** 0.5
print(ans)


import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

def II():
	return int(sys.stdin.readline())

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

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

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def main():
	n = II()
	xy = [LI() for _ in range(n)]
	sx = sy = 1000
	bx = by = 0
	for (x, y) in xy:
		if x < sx:
			sx = x
		if x > bx:
			bx = x
		if y < sy:
			sy = y
		if y > by:
			by = y
	x0 = (sx + bx) / 2
	y0 = (sy + by) / 2
	m = 100
	roop = 10000
	for _ in range(roop):
		maxd = 0
		for (x, y) in xy:
			d = (x - x0) ** 2 + (y - y0) ** 2
			if d > maxd:
				maxd = d
				vx = x - x0
				vy = y - y0
		rate = m / (vx ** 2 + vy ** 2) ** 0.5
		x0 += vx * rate
		y0 += vy * rate
		m *= 0.998
	print(maxd ** 0.5)
main()


from math import hypot
N = int(input())
XY = [tuple(map(int, input().split())) for i in range(N)]
if N == 2:
	d = hypot(XY[0][0] - XY[1][0], XY[0][1] - XY[1][1])
	print(d / 2)
	exit()

def center(a, b, c, d, e, f):
	aa = a * a
	bb = b * b
	cc = c * c
	dd = d * d
	ee = e * e
	ff = f * f
	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 = hypot(px - a, py - b)
	return (r, px, py)
eps = 10 ** (-10)
ans = float('inf')
for i in range(N - 2):
	(x1, y1) = XY[i]
	for j in range(i + 1, N - 1):
		(x2, y2) = XY[j]
		for k in range(j + 1, N):
			(x3, y3) = XY[k]
			try:
				(r, px, py) = center(x1, y1, x2, y2, x3, y3)
			except ZeroDivisionError:
				continue
			for (x, y) in XY:
				d = hypot(px - x, py - y)
				if d <= r + eps:
					continue
				break
			else:
				ans = min(ans, r)
for i in range(N - 1):
	for j in range(i + 1, N):
		(x1, y1) = XY[i]
		(x2, y2) = XY[j]
		x = (x1 + x2) / 2
		y = (y1 + y2) / 2
		r = hypot(x1 - x, y1 - y)
		for (x3, y3) in XY:
			d = hypot(x - x3, y - y3)
			if d <= r + eps:
				continue
			break
		else:
			ans = min(ans, r)
print(ans)


import numpy as np
import sys, math

def circle3p(ps):
	A = []
	B = []
	for (x, y) in ps:
		Ai = [x, y, 1]
		A.append(Ai)
		B.append(-x * x - y * y)
	try:
		x = np.linalg.solve(A, B)
		return (x[0], x[1], x[2])
	except np.linalg.LinAlgError:
		return None

def circle2p(ps):
	(xy0, xy1) = ps
	return [(xy0[0] + xy1[0]) / 2.0, (xy0[1] + xy1[1]) / 2.0, ((xy0[0] - xy1[0]) ** 2 + (xy0[1] - xy1[1]) ** 2) / 4.0]
eps = 1e-07

def main():
	N = int(sys.stdin.readline())
	ps = []
	for i in range(N):
		(x, y) = list(map(int, sys.stdin.readline().split()))
		ps.append((x, y))
	n = len(ps)
	ok = False
	res = int(1000000000.0)
	if n == 2:
		(x0, y0) = ps[0]
		(x1, y1) = ps[1]
		print('%.9f' % (math.sqrt((x0 - x1) ** 2 + (y0 - y1) ** 2) / 2.0))
		return
	for i in range(n):
		for j in range(i + 1, n):
			for k in range(j + 1, n):
				circle = circle3p([ps[i], ps[j], ps[k]])
				if circle is None:
					continue
				(a, b, c) = circle
				for l in range(n):
					if l in {i, j, k}:
						continue
					(x, y) = ps[l]
					if x * x + y * y + a * x + b * y + c > eps:
						break
				else:
					res = min(res, a * a / 4 + b * b / 4 - c)
	for i in range(n):
		for j in range(i + 1, n):
			circle = circle2p([ps[i], ps[j]])
			if circle is None:
				continue
			(a, b, c) = circle
			for l in range(n):
				if l in {i, j}:
					continue
				(x, y) = ps[l]
				if (x - a) ** 2 + (y - b) ** 2 > c + eps:
					break
			else:
				res = min(res, c)
	print('%.9f' % float(math.sqrt(float(res))))

def __starting_point():
	main()
__starting_point()


import math
N = int(input())
xy = []
for i in range(N):
	xy.append([int(p) for p in input().split()])

def dist(a, b):
	return math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2)

def max_dist(a):
	max_d = 0
	for b in xy:
		max_d = max(max_d, dist(a, b))
	return max_d

def g(a):
	ly = 0
	ry = 1000
	for j in range(100):
		c1 = (ly * 2 + ry) / 3
		c2 = (ly + ry * 2) / 3
		if max_dist([a, c1]) > max_dist([a, c2]):
			ly = c1
		else:
			ry = c2
	return max_dist([a, ly])
lx = 0
rx = 1000
for i in range(100):
	c1 = (lx * 2 + rx) / 3
	c2 = (lx + rx * 2) / 3
	if g(c1) > g(c2):
		lx = c1
	else:
		rx = c2
print(g(lx))


import sys
import cmath
from itertools import combinations
inf = float('inf')
(n, *xy) = map(int, sys.stdin.read().split())
xy = zip(*[iter(xy)] * 2)
z = [x + y * 1j for (x, y) in xy]

def circumcenter(z1, z2, z3):
	a = z2 - z1
	b = z3 - z1
	numerator = a * b * (b.conjugate() - a.conjugate())
	denominator = a * b.conjugate() - a.conjugate() * b
	o = numerator / denominator + z1
	return o

def center(z1, z2):
	return (z1 + z2) / 2

def main():
	cand = []
	for comb in combinations(z, 3):
		try:
			cand.append(circumcenter(*comb))
		except:
			pass
	for comb in combinations(z, 2):
		cand.append(center(*comb))
	res = inf
	for o in cand:
		r = 0
		for i in z:
			r = max(r, abs(o - i))
		res = min(res, r)
	return res
ans = main()
print(ans)


from math import sin
N = int(input())
XY = [tuple(map(int, input().split())) for _ in range(N)]

def dist(x, y, u, v):
	return ((x - u) ** 2 + (y - v) ** 2) ** 0.5
ans = 10 ** 10
for i in range(N):
	for j in range(i + 1, N):
		(xi, yi) = XY[i]
		(xj, yj) = XY[j]
		cx = (xi + xj) / 2
		cy = (yi + yj) / 2
		d = 0
		for (x, y) in XY:
			d = max(d, dist(x, y, cx, cy))
		ans = min(ans, d)
		for k in range(j + 1, N):
			(xi, yi) = XY[i]
			(xj, yj) = XY[j]
			(xk, yk) = XY[k]
			c = dist(xi, yi, xj, yj)
			a = dist(xj, yj, xk, yk)
			b = dist(xk, yk, xi, yi)
			S = a ** 2 * (b ** 2 + c ** 2 - a ** 2) + b ** 2 * (c ** 2 + a ** 2 - b ** 2) + c ** 2 * (a ** 2 + b ** 2 - c ** 2)
			if S == 0:
				continue
			cx = a ** 2 * (b ** 2 + c ** 2 - a ** 2) * xi + b ** 2 * (c ** 2 + a ** 2 - b ** 2) * xj + c ** 2 * (a ** 2 + b ** 2 - c ** 2) * xk
			cy = a ** 2 * (b ** 2 + c ** 2 - a ** 2) * yi + b ** 2 * (c ** 2 + a ** 2 - b ** 2) * yj + c ** 2 * (a ** 2 + b ** 2 - c ** 2) * yk
			cx /= S
			cy /= S
			d = 0
			for (x, y) in XY:
				d = max(d, dist(x, y, cx, cy))
			ans = min(ans, d)
print(ans)


N = int(input())
points = [list(map(int, input().split())) for i in range(N)]

def dist(cx, cy, nx, ny):
	return ((cx - nx) ** 2 + (cy - ny) ** 2) ** 0.5

def circumcenter(x1, x2, x3, y1, y2, y3):
	a2 = (x2 - x3) ** 2 + (y2 - y3) ** 2
	b2 = (x1 - x3) ** 2 + (y1 - y3) ** 2
	c2 = (x2 - x1) ** 2 + (y2 - y1) ** 2
	area = ((x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1)) / 2
	if area == 0:
		d1 = dist(x1, y1, x2, y2)
		d2 = dist(x1, y1, x3, y3)
		d3 = dist(x2, y2, x3, y3)
		if max(d1, d2, d3) == d1:
			return ((x1 + x2) / 2, (y1 + y2) / 2)
		elif max(d1, d2, d3) == d2:
			return ((x1 + x3) / 2, (y1 + y3) / 2)
		else:
			return ((x2 + x3) / 2, (y2 + y3) / 2)
	x = (a2 * (b2 + c2 - a2) * x1 + b2 * (c2 + a2 - b2) * x2 + c2 * (a2 + b2 - c2) * x3) / (16 * area * area)
	y = (a2 * (b2 + c2 - a2) * y1 + b2 * (c2 + a2 - b2) * y2 + c2 * (a2 + b2 - c2) * y3) / (16 * area * area)
	return (x, y)
ans = float('inf')
for i in range(N):
	for j in range(N):
		for k in range(N):
			(x1, y1) = points[i]
			(x2, y2) = points[j]
			(x3, y3) = points[k]
			(cx, cy) = circumcenter(x1, x2, x3, y1, y2, y3)
			tmp_ans = 0
			for (nx, ny) in points:
				tmp_ans = max(tmp_ans, dist(cx, cy, nx, ny))
			ans = min(ans, tmp_ans)
print(ans)


import math

def exist_same_point(a, b, c, d, e, f):
	return (a, b) == (c, d) or (c, d) == (e, f) or (e, f) == (a, b)

def three_points_on_a_line(a, b, c, d, e, f):
	dx1 = a - c
	dy1 = b - d
	dx2 = a - e
	dy2 = b - f
	return dx2 * dy1 == dx1 * dy2

def circumcenter(a, b, c, d, e, f):
	if exist_same_point(a, b, c, d, e, f) or three_points_on_a_line(a, b, c, d, e, f):
		return (None, None, None)
	aa = a * a
	bb = b * b
	cc = c * c
	dd = d * d
	ee = e * e
	ff = f * f
	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)
	return (px, py, r)

def in_c(x, y, r):
	for i in range(N):
		if math.hypot(x - xy[i][0], y - xy[i][1]) > r + 10 ** (-6):
			return False
	return True
N = int(input())
xy = []
ans = float('inf')
for i in range(N):
	(x, y) = map(int, input().split())
	xy.append([x, y])
for i in range(N):
	for j in range(i):
		nx = (xy[i][0] + xy[j][0]) / 2
		ny = (xy[i][1] + xy[j][1]) / 2
		nr = math.hypot(xy[i][0] - xy[j][0], xy[i][1] - xy[j][1]) / 2
		if in_c(nx, ny, nr):
			ans = min(ans, nr)
for i in range(N):
	for j in range(i):
		for k in range(j):
			(nx, ny, nr) = circumcenter(xy[i][0], xy[i][1], xy[j][0], xy[j][1], xy[k][0], xy[k][1])
			if nx != None and in_c(nx, ny, nr):
				ans = min(ans, nr)
print(ans)


import sys
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines

def main():
	n = int(input())
	x = []
	y = []
	for _ in range(n):
		(xin, yin) = map(int, input().split())
		x.append(xin)
		y.append(yin)
	li = [[0] * n for _ in range(n)]
	for i in range(n):
		for j in range(n):
			if i > j:
				li[i][j] = ((x[i] + x[j]) / 2, (y[i] + y[j]) / 2, ((x[j] - x[i]) ** 2 + (y[j] - y[i]) ** 2) ** 0.5)
				li[j][i] = (-(y[j] - y[i]), x[j] - x[i])
	l = 0
	h = 1000
	for ii in range(100):
		m = (l + h) / 2
		ko = []
		for i in range(n):
			for j in range(n):
				if i > j:
					k = 4 * m ** 2 - li[i][j][2] ** 2
					if k > 0:
						k = k / (4 * li[i][j][2] ** 2)
						k = k ** 0.5
						ko.append((li[i][j][0] + k * li[j][i][0], li[i][j][1] + k * li[j][i][1]))
						ko.append((li[i][j][0] - k * li[j][i][0], li[i][j][1] - k * li[j][i][1]))
		if len(ko) == 0:
			l = m
			continue
		for point in ko:
			f = 0
			for i in range(n):
				length = ((point[0] - x[i]) ** 2 + (point[1] - y[i]) ** 2) ** 0.5
				if length - 1e-13 > m:
					f = 1
					break
			if f == 0:
				h = m
				break
		else:
			l = m
	print(l)
main()


import math
N = int(input())
C = [tuple(map(int, input().split())) for _ in range(N)]
e = 10 ** (-10)

def dist2(p1, p2):
	return (p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2

def max_dist_xy(x, y):
	max_dist = 0
	p = (x, y)
	for c in C:
		max_dist = max(max_dist, dist2(p, c))
	return max_dist

def max_dist_x(x):
	l = 0
	r = 1000
	for _ in range(80):
		m1 = (2 * l + r) / 3
		m2 = (l + 2 * r) / 3
		d1 = max_dist_xy(x, m1)
		d2 = max_dist_xy(x, m2)
		if d1 > d2:
			l = m1
		else:
			r = m2
	return max_dist_xy(x, l)

def solve():
	l = 0
	r = 1000
	for _ in range(80):
		m1 = (2 * l + r) / 3
		m2 = (l + 2 * r) / 3
		d1 = max_dist_x(m1)
		d2 = max_dist_x(m2)
		if d1 > d2:
			l = m1
		else:
			r = m2
	return math.sqrt(max_dist_x(l))
print(solve())


from math import hypot
MAX = 1000
n = int(input())
a = [tuple(map(int, input().split())) for _ in range(n)]

def dist(x1, y1, x2, y2):
	return hypot(x1 - x2, y1 - y2)

def maxDist(x, y):
	res = 0
	for (xx, yy) in a:
		res = max(res, dist(x, y, xx, yy))
	return res

def f(x):
	(left, right) = (0, MAX)
	for _ in range(80):
		y1 = (left * 2 + right) / 3
		y2 = (left + right * 2) / 3
		if maxDist(x, y1) > maxDist(x, y2):
			left = y1
		else:
			right = y2
	return maxDist(x, left)
(left, right) = (0, MAX)
for _ in range(80):
	x1 = (left * 2 + right) / 3
	x2 = (left + right * 2) / 3
	if f(x1) > f(x2):
		left = x1
	else:
		right = x2
print(f(left))


import sys
input = sys.stdin.buffer.readline
from itertools import combinations
from math import hypot
n = int(input())
P = [tuple(map(int, input().split())) for _ in range(n)]
ans = 1000000000.0
for (p1, p2) in combinations(P, 2):
	(X, Y) = ((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2)
	r = 0
	for (x, y) in P:
		t = hypot(X - x, Y - y)
		if r < t:
			r = t
	if ans > r:
		ans = r
if n > 2:
	ans_ = 1000000000.0
	for (p1, p2, p3) in combinations(P, 3):
		a = hypot(p2[0] - p3[0], p2[1] - p3[1])
		b = hypot(p3[0] - p1[0], p3[1] - p1[1])
		c = hypot(p1[0] - p2[0], p1[1] - p2[1])
		if a + b + c - 2 * max(a, b, c) < 1e-08:
			continue
		(s, t, u) = ((-a * a + b * b + c * c) * a * a, (a * a - b * b + c * c) * b * b, (a * a + b * b - c * c) * c * c)
		X = (s * p1[0] + t * p2[0] + u * p3[0]) / (s + t + u)
		Y = (s * p1[1] + t * p2[1] + u * p3[1]) / (s + t + u)
		r = 0
		for (x, y) in P:
			t = hypot(X - x, Y - y)
			if r < t:
				r = t
		if ans_ > r:
			ans_ = r
	ans = min(ans, ans_)
print(ans)


import numpy, scipy.optimize as s
(i, j) = numpy.loadtxt(open(0), skiprows=1).T
f = lambda x: max((x[0] - i) ** 2 + (x[1] - j) ** 2)
print(f(s.fmin(f, (9, 9), disp=0)) ** 0.5)


printn = lambda x: print(x, end='')
inn = lambda : int(input())
inl = lambda : list(map(int, input().split()))
inm = lambda : map(int, input().split())
ins = lambda : input().strip()
DBG = True
BIG = 10 ** 18
R = 10 ** 9 + 7

def ddprint(x):
	if DBG:
		print(x)
import math

def dist(xx, yy, u, v):
	return math.sqrt((xx - u) ** 2 + (yy - v) ** 2)

def do2(x1, y1, x2, y2):
	return ((x1 + x2) / 2, (y1 + y2) / 2, dist(x1, y1, x2, y2) / 2)

def do3(x1, y1, x2, y2, x3, y3):
	p = (x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1)
	if p == 0:
		return (0, 0, -1)
	x1s = x1 ** 2
	y1s = y1 ** 2
	x2s = x2 ** 2
	y2s = y2 ** 2
	x3s = x3 ** 2
	y3s = y3 ** 2
	u = ((x2s + y2s - x1s - y1s) * (y3 - y1) - (x3s + y3s - x1s - y1s) * (y2 - y1)) / (2 * p)
	v = -((x2s + y2s - x1s - y1s) * (x3 - x1) - (x3s + y3s - x1s - y1s) * (x2 - x1)) / (2 * p)
	r = dist(u, v, x1, y1)
	return (u, v, r)
eps = 10 ** (-13)

def fit(u, v, r):
	for i in range(n):
		if dist(x[i], y[i], u, v) > r + eps:
			return False
	return True
n = inn()
x = []
y = []
for i in range(n):
	(xx, yy) = inm()
	x.append(xx)
	y.append(yy)
mn = 2000.0
for i in range(n - 1):
	for j in range(i + 1, n):
		(u, v, r) = do2(x[i], y[i], x[j], y[j])
		if r > 0 and fit(u, v, r):
			mn = min(mn, r)
for i in range(n - 2):
	for j in range(i + 1, n - 1):
		for k in range(j + 1, n):
			(u, v, r) = do3(x[i], y[i], x[j], y[j], x[k], y[k])
			if r > 0 and fit(u, v, r):
				mn = min(mn, r)
print(mn)