#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <functional>
#include <numeric>

using namespace std;
using lint = int64_t;
using P = pair<int, int>;
using D = pair<double, double>;

#define rep(i, n) for (lint i = 0; i < (n); ++i)
#define rep1(i, n) for (lint i = 1; i < (n); ++i)
#define repn(i, a, b) for(lint i = (a); i < (b); ++i)
#define Rep(i, n) for (lint i = (n); i >= 0; --i)
#define All(vec) vec.begin(), vec.end()
#define cend printf("\n")

//constexpr lint mod = 998'244'353LL;
constexpr lint mod = 1000'000'007LL;
constexpr lint inf = 3LL * mod * mod;
const double Pi = 2.0 * acos(0.0);

template<class T> using prique     = priority_queue<T>;
template<class T> using prique_inv = priority_queue<T, vector<T>, greater<T>>;
template<class T, class U>inline istream& operator>>(istream& is, pair<T, U>& rhs) { return is >> rhs.first >> rhs.second; }
template<class T, class U>inline ostream& operator<<(ostream& os, const pair<T, U>& rhs) { return os << rhs.first << " " << rhs.second << "\n"; }
template<class InputIterator> void arrin(InputIterator first, InputIterator last) { for (; first != last; ++first) cin >> (*first); }
template<class InputIterator> void arrout(InputIterator first, InputIterator last) {
	for (; first != last; ++first) {
		cout << (*first) << " ";
	}
	cout << "\n";
}

constexpr bool pri(lint x) { for (lint i = 2; i * i <= x; ++i) if (x % i == 0) return false; return 1 < x; }

inline double dis(D a, D b) { return hypot(a.first - b.first, a.second - b.second); }

lint fact[3000000];
void fact_init(lint n) {
	if (3000000 <= n) return;
	fact[0] = fact[1] = 1;
	for (lint i = 2; i <= n; ++i) {
		fact[i] = i * fact[i - 1];
		if (mod <= fact[i]) fact[i] %= mod;
	}
}

lint modpow(lint x, lint n, lint m = mod) {
	lint res = 1;
	while (n > 0) {
		if (n & 1) {
			res *= x;
			if (m <= res) res %= m;
		}
		x *= x;
		if (m <= x) x %= m;
		n >>= 1;
	}
	return res;
}

lint intpow(lint x, lint n) {
	lint res = 1;
	while (n > 0) {
		if (n & 1) res *= x;
		x *= x;
		n >>= 1;
	}
	return res;
}

lint comb(lint n, lint r) {
	if (r == 0 || r == n) return 1;
	lint res = fact[n] * modpow(fact[n - r], mod - 2, mod) % mod * modpow(fact[r], mod - 2, mod) % mod;
	return res < 0 ? res + mod : res;
}

map<lint, lint> factring(lint n) {
	map<lint, lint> res;
	for (lint i = 2; i * i <= n; ++i) {
		while (n % i == 0) {
			n /= i;
			++res[i];
		}
	}
	if (n != 1) ++res[n];
	return res;
}

struct Point {
	double x, y;

	Point() = default;
	Point(double x_, double y_): x(x_), y(y_) {}

	Point operator+(const Point& rhs) const { return Point(x + rhs.x, y + rhs.y); }
	Point operator-(const Point& rhs) const { return Point(x - rhs.x, y - rhs.y); }
	Point operator*(double scalar) const { return Point(x * scalar, y * scalar); }
	Point operator/(double scalar) const { return Point(x / scalar, y / scalar); }

	double dot(const Point& rhs) const { return x * rhs.x + y * rhs.y; }
	double length() const { return std::sqrt(lengthSq()); }
	double lengthSq() const { return dot(*this); }
	double distanceFrom(const Point& rhs) const { return (*this - rhs).length(); }
	double distanceFromSq(const Point& rhs) const { return (*this - rhs).lengthSq(); }

	friend Point operator*(double scalar, const Point& rhs) { return Point(scalar * rhs.x, scalar * rhs.y); }
	friend std::istream& operator>>(std::istream& is, Point& rhs) { return is >> rhs.x >> rhs.y; }
};

struct Triangle {
	Point a, b, c;
	
	Triangle(const Point& a_, const Point& b_, const Point& c_) :a(a_), b(b_), c(c_) {}

	double getAngleA() const {
		double
			dist_a = b.distanceFrom(c),
			dist_b = c.distanceFrom(a),
			dist_c = a.distanceFrom(b);
		return acos((-dist_a * dist_a + dist_b * dist_b + dist_c * dist_c) / (2 * dist_b * dist_c));
	}
	
	double getAngleB() const {
		double
			dist_a = b.distanceFrom(c),
			dist_b = c.distanceFrom(a),
			dist_c = a.distanceFrom(b);
		return acos((dist_a * dist_a - dist_b * dist_b + dist_c * dist_c) / (2 * dist_c * dist_a));
	}

	double getAngleC() const { 
		return acos(-1.0) - getAngleA() - getAngleB(); 
	}

	//重心
	Point getCentroid() const {
		return (a + b + c) / 3;
	}

	//外心
	Point getCircumCenter() const {
		double
			sin2a = sin(2 * getAngleA()),
			sin2b = sin(2 * getAngleB()),
			sin2c = sin(2 * getAngleC());
		return (sin2a * a + sin2b * b + sin2c * c) / (sin2a + sin2b + sin2c);
	}

	//内心
	Point getInnerCenter() const {
		double 
			dist_a = b.distanceFrom(c),
			dist_b = c.distanceFrom(a),
			dist_c = a.distanceFrom(b);
		return (dist_a * a + dist_b * b + dist_c * c) / (dist_a + dist_b + dist_c);
	}

	//垂心
	Point getOrthoCenter() const {
		return a + b + c - 2 * getCircumCenter();
	}

	//傍心 A
	Point getExcenterA() const {
		double
			dist_a = b.distanceFrom(c),
			dist_b = c.distanceFrom(a),
			dist_c = a.distanceFrom(b);
		return (-dist_a * a + dist_b * b + dist_c * c) / (-dist_a + dist_b + dist_c);
	}

	//傍心 B
	Point getExcenterB() const {
		double
			dist_a = b.distanceFrom(c),
			dist_b = c.distanceFrom(a),
			dist_c = a.distanceFrom(b);
		return (dist_a * a - dist_b * b + dist_c * c) / (dist_a - dist_b + dist_c);
	}

	//傍心 C
	Point getExcenterC() const {
		double
			dist_a = b.distanceFrom(c),
			dist_b = c.distanceFrom(a),
			dist_c = a.distanceFrom(b);
		return (dist_a * a + dist_b * b - dist_c * c) / (dist_a + dist_b - dist_c);
	}

	friend std::istream& operator>>(std::istream& is, Triangle& rhs) { return is >> rhs.a >> rhs.b >> rhs.c; }
};

int main() {
	int n;
	cin >> n;
	vector<Point>p(n);
	for (Point& e : p) cin >> e;
	if (n == 2) {
		printf("%.12lf\n", 0.5 * p[0].distanceFrom(p[1]));
	}
	else {
		double ans = 1e4;
		rep(i, n - 2) {
			repn(j, i + 1, n - 1) {
				repn(k, j + 1, n) {
					Triangle tri(p[i], p[j], p[k]);
					Point center;
					double r;

					if (0.5 * Pi + 1e-12 < tri.getAngleA()) {
						center = 0.5 * (p[j] + p[k]);
						r = 0.5 * p[j].distanceFrom(p[k]);
					}
					else if (0.5 * Pi + 1e-12 < tri.getAngleB()) {
						center = 0.5 * (p[k] + p[i]);
						r = 0.5 * p[k].distanceFrom(p[i]);
					}
					else if (0.5 * Pi + 1e-12 < tri.getAngleC()) {
						center = 0.5 * (p[i] + p[j]);
						r = 0.5 * p[i].distanceFrom(p[j]);
					}
					else {
						center = tri.getCircumCenter();
						r = p[i].distanceFrom(center);
					}

					bool can = true;
					for (const Point& e : p) {
						if (r + 1e-12 < e.distanceFrom(center)) {
							can = false;
							break;
						}
					}
					if (can) ans = min(ans, r);
				}
			}
		}
		printf("%.12lf\n", ans);
	}
}

Measured memory_bytes: 4380