//#include "bits/stdc++.h"

#define _USE_MATH_DEFINES
#include<cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <deque>
#include <algorithm>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <iterator>
#include<iomanip>
#include<unordered_set>
#include<bitset>
#include<complex>

using namespace std;

#define rep(i,a,b) for(int i=(a), i##_len=(b);i<i##_len;i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define all(c) begin(c),end(c)

#define int ll
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair

//typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<double, double> pdd;
typedef vector< vector<int> > mat;

template<class T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (b < a) { a = b; return true; } return false; }

const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD =  (int)1e9 + 7;
const double EPS = 1e-9;

pdd trans(pdd input, double a, double b, double c, double d)
{
	pdd output;
	output.first = a * input.first + b * input.second;
	output.second = c * input.first + d * input.second;
	return output;
}

bool crossPoint(const pdd &p1, const pdd &p2, const pdd &p3, const pdd &p4, pdd &ap1)
{
	double dev = (p2.second - p1.second)*(p4.first - p3.first) - (p2.first - p1.first)*(p4.second - p3.second);
	if (abs(dev) < EPS)
	{
		return false;
	}

	double d1, d2;

	d1 = (p3.second*p4.first - p3.first*p4.second);
	d2 = (p1.second*p2.first - p1.first*p2.second);

	ap1.first = d1 * (p2.first - p1.first) - d2 * (p4.first - p3.first);
	ap1.first /= dev;
	ap1.second = d1 * (p2.second - p1.second) - d2 * (p4.second - p3.second);
	ap1.second /= dev;
	return true;
}

signed main()
{
	cin.tie(0);
	ios::sync_with_stdio(false);
	
	int N;
	pdd P[60];

	cin >> N;
	rep(i, 0, N)
	{
		cin >> P[i].first >> P[i].second;
	}

	double ans = INF;
	rep(i, 0, N)rep(j, i + 1, N)
	{
		double dx = P[i].first - P[j].first, dy = P[i].second - P[j].second;
		double d = sqrt(dx*dx + dy * dy) / 2.0;
		pdd C = mp((P[i].first + P[j].first) / 2.0, (P[i].second + P[j].second) / 2.0);
		bool ok = true;
		rep(k, 0, N)
		{
			dx = P[k].first - C.first, dy = P[k].second - C.second;
			double md = sqrt(dx*dx + dy * dy);
			if (md > d + EPS)
			{
				ok = false;
			}
		}
		if (ok)
		{
			chmin(ans, d);
		}
	}
	/*
	if (ans < INF)
	{
		cout << fixed << setprecision(12) << ans << endl;
		return 0;
	}*/

	rep(i, 0, N)rep(j, i + 1, N)rep(k, j + 1, N)
	{
		pdd m1 = mp(P[i].first - P[j].first, P[i].second - P[j].second);
		pdd m2 = mp(P[i].first - P[k].first, P[i].second - P[k].second);
	
		m1 = trans(m1, 0.0, -1.0, 1.0, 0.0);
		m2 = trans(m2, 0.0, -1.0, 1.0, 0.0);

		pdd c1a = mp((P[i].first + P[j].first) / 2.0, (P[i].second + P[j].second) / 2.0);
		pdd c2a = mp((P[i].first + P[k].first) / 2.0, (P[i].second + P[k].second) / 2.0);
		pdd c1b = mp(c1a.first + m1.first, c1a.second + m1.second);
		pdd c2b = mp(c2a.first + m2.first, c2a.second + m2.second);

		pdd C;
		if (crossPoint(c1a, c1b, c2a, c2b, C))
		{
			double dx = P[i].first - C.first, dy = P[i].second - C.second;
			double d = sqrt(dx*dx + dy * dy);

			bool ok = true;
			rep(l, 0, N)
			{
				dx = P[l].first - C.first, dy = P[l].second - C.second;
				double md = sqrt(dx*dx + dy * dy);
				if (md > d + EPS)
				{
					ok = false;
				}
			}
			if (ok)
			{
				chmin(ans, d);
			}
		}
	}

	cout << fixed << setprecision(12) << ans << endl;

	return 0;
}

Measured memory_bytes: 256