#include<stdio.h>
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<string.h>

#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define NDEBUG
#define eprintf(...) do {} while (0)
#endif
#include<cassert>

using namespace std;

typedef long long LL;
typedef vector<int> VI;

#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define EACH(i,c) for(__typeof((c).begin()) i=(c).begin(),i##_end=(c).end();i!=i##_end;++i)

template<class T> inline void amin(T &x, const T &y) { if (y<x) x=y; }
template<class T> inline void amax(T &x, const T &y) { if (x<y) x=y; }
template<class Iter> void rprintf(const char *fmt, Iter begin, Iter end) {
    for (bool sp=0; begin!=end; ++begin) { if (sp) putchar(' '); else sp = true; printf(fmt, *begin); }
    putchar('\n');
}
#include<complex>
#include<cmath>
typedef double Double;
const Double EPS = 1e-8; // 0 ~~ [-EPS, EPS]
// const LL EPS = 0;
const Double INF = 1e12;
const Double PI = acos((Double)-1);

typedef complex<Double> Point;

//struct Point : complex<Double> {
//    typedef complex<Double> S;
//    int id;
//    Point() : S(), id(-1) {}
//    Point(Double x, Double y) : S(x, y), id(-1) {}
//    Point(Double x, Double y, int id_) : S(x, y), id(id_) {}
//    Point(const S &s) : S(s), id(-1) {}
//    Point(const Point &p) : S(p), id(p.id) {}
//};

// abs(P a) ::= sqrt(a.x^2 + a.y^2);
// norm(P a) ::= a.x^2 + a.y^2;
// Point polar(rho, theta=0)

const Point I(0, 1);

inline Double sq(Double x) { return x * x; }

inline int sgn(Double x) {
    if (x < -EPS) return -1;
    if (EPS < x) return 1;
    return 0;
}

namespace std {
    bool operator<(const Point &x, const Point &y) {
	return x.real() != y.real()? x.real() < y.real(): x.imag() < y.imag();
    }
};

inline int cmp(Double x, Double y) {
    return sgn(x - y);
}

Double cross(const Point &x, const Point &y) {
    return (conj(x)*y).imag();
}

Double dot(const Point &x, const Point &y) {
    return (conj(x)*y).real();
}
int ccw(Point a, Point b, Point c) {
    b-=a; c-=a;
    if (cmp(cross(b, c), 0) > 0) return 1; // counter clockwise
    if (cmp(cross(b, c), 0) < 0) return -1; // clockwise
    if (cmp(dot(b, c), 0) < 0) return 2; // c--a--b on line
    if (cmp(abs(b), abs(c)) < 0) return -2; // a--b--c on line
    return 0; // a--c--b or b == c
}



pair<Double, Double> calc(Double a0, Double b0, Double c0, Double a1, Double b1, Double c1) {
    pair<Double, Double> ret;
    if (sgn(a1) == 0) {
	ret.second = -c1 / b1;
	ret.first = (-ret.second * b0 - c0) / a0;
    } else {
	a0 /= a1;
	b0 /= a1;
	c0 /= a1;
	b1 /= a1;
	c1 /= a1;
	a1 = 1.0;
	ret.second = -(c0-c1*a0) / (b0 - b1*a0);
	ret.first = -ret.second * b1 - c1;
    }

    return ret;
}

int N;
Point P[55];

Double ans;

void solve(Point a, Point b, Point c) {
    int g = ccw(a, b, c);
    if (g == 1 || g == -1) {
	Double a0 = 2 * (a.real() - b.real());
	Double b0 = 2 * (a.imag() - b.imag());
	Double c0 = sq(b.real()) - sq(a.real()) + sq(b.imag()) - sq(a.imag());
	Double a1 = 2 * (a.real() - c.real());
	Double b1 = 2 * (a.imag() - c.imag());
	Double c1 = sq(c.real()) - sq(a.real()) + sq(c.imag()) - sq(a.imag());
	pair<Double, Double> h = calc(a0, b0, c0, a1, b1, c1);
	c = Point(h.first, h.second);
    } else {
	if (abs(a-b) < abs(a-c)) {
	    if (abs(c-a) < abs(c-b)) {
		c = (c+b)/2.0;
	    } else {
		c = (c+a)/2.0;
	    }
	} else {
	    if (abs(b-a) < abs(b-c)) {
		c = (b+c)/2.0;
	    } else {
		c = (b+a)/2.0;
	    }
	}
    }

    Double r = 0;
    REP (i, N) amax(r, abs(c - P[i]));
    amin(ans, r);
}

void MAIN() {
    scanf("%d", &N);
    REP (i, N) {
	int x, y;
	scanf("%d%d", &x, &y);
	P[i] = Point(x, y);
    }

    ans = 1e100;
    REP (a, N) REP (b, N) REP (c, N) solve(P[a], P[b], P[c]);

    printf("%.20f\n", (double)ans);
}

int main() {
    int TC = 1;
//    scanf("%d", &TC);
    REP (tc, TC) MAIN();
    return 0;
}



Measured memory_bytes: 384