/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author
 */

#include <iostream>
#include <fstream>

#include "bits/stdc++.h"

#define REP(i,x,y) for(int i=(x);i<(y);i++)
#define RREP(i,x,y) for(int i=(y)-1;i>=(x);i--)
#define all(x) (x).begin(),(x).end()
//#define int long long

using namespace std;

// conversion
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}

#define dump(x)  cout << #x << " = " << (x) << endl
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl

typedef long long ll;

const ll MOD = 1e9 + 7;

// This pair is used to store the X and Y
// coordinate of a point respectively
#define pdd pair<double, double>

// Function to find the line given two points
void lineFromPoints(pdd P, pdd Q, double &a,
                    double &b, double &c)
{
    a = Q.second - P.second;
    b = P.first - Q.first;
    c = a*(P.first)+ b*(P.second);
}

// Function which converts the input line to its
// perpendicular bisector. It also inputs the points
// whose mid-point lies on the bisector
void perpendicularBisectorFromLine(pdd P, pdd Q,
                                   double &a, double &b, double &c)
{
    pdd mid_point = make_pair((P.first + Q.first)/2,
                              (P.second + Q.second)/2);

    // c = -bx + ay
    c = -b*(mid_point.first) + a*(mid_point.second);

    double temp = a;
    a = -b;
    b = temp;
}

// Returns the intersection point of two lines
pdd lineLineIntersection(double a1, double b1, double c1,
                         double a2, double b2, double c2)
{
    double determinant = a1*b2 - a2*b1;
    if (determinant == 0)
    {
        // The lines are parallel. This is simplified
        // by returning a pair of FLT_MAX
        return make_pair(FLT_MAX, FLT_MAX);
    }

    else
    {
        double x = (b2*c1 - b1*c2)/determinant;
        double y = (a1*c2 - a2*c1)/determinant;
        return make_pair(x, y);
    }
}

pair<double, double> findCircumCenter(pdd P, pdd Q, pdd R)
{
    // Line PQ is represented as ax + by = c
    double a, b, c;
    lineFromPoints(P, Q, a, b, c);

    // Line QR is represented as ex + fy = g
    double e, f, g;
    lineFromPoints(Q, R, e, f, g);

    // Converting lines PQ and QR to perpendicular
    // vbisectors. After this, L = ax + by = c
    // M = ex + fy = g
    perpendicularBisectorFromLine(P, Q, a, b, c);
    perpendicularBisectorFromLine(Q, R, e, f, g);

    // The point of intersection of L and M gives
    // the circumcenter
    pdd circumcenter =
            lineLineIntersection(a, b, c, e, f, g);

    if (circumcenter.first == FLT_MAX &&
        circumcenter.second == FLT_MAX)
    {
        return {FLT_MAX, FLT_MAX};
    }

    else
    {
        return {circumcenter.first, circumcenter.second};
    }
}

class FEncloseAll {
public:
    void solve(std::istream& in, std::ostream& out) {
        int N;
        in >> N;
        vector<double> x(N), y(N);
        REP(i,0,N) in >> x[i] >> y[i];

        if (N == 2) {
            out << fixed << setprecision(16) << pow(pow(x[0] - x[1], 2) + pow(y[0] - y[1], 2), 0.5) * 0.5 << "\n";
            return;
        }

        double answer = FLT_MAX;
        REP(i,0,N) {
            REP(j,i+1,N) {
                pair<double, double> center = {(x[i] + x[j]) / 2, (y[i] + y[j]) / 2};
                double r = pow(pow(x[i] - center.first, 2) + pow(y[i] - center.second, 2), 0.5);
                bool isValid = true;
                REP(l,0,N) {
                    double rr = pow(pow(x[l] - center.first, 2) + pow(y[l] - center.second, 2), 0.5);
                    if (r < rr) {
                        isValid = false;
                        break;
                    }
                }
                if (isValid) {
                    answer = r;
                    continue;
                }

                REP(k,j+1,N) {
                    pair<double, double> circumCenter = findCircumCenter({x[i], y[i]}, {x[j], y[j]}, {x[k], y[k]});
                    if (circumCenter.first == FLT_MAX && circumCenter.second == FLT_MAX) {
                        double r1 = pow(pow(x[i] - x[j], 2) + pow(y[i] - y[j], 2), 0.5) * 0.5;
                        double r2 = pow(pow(x[j] - x[k], 2) + pow(y[j] - y[k], 2), 0.5) * 0.5;
                        double r3 = pow(pow(x[k] - x[i], 2) + pow(y[k] - y[i], 2), 0.5) * 0.5;
                        r = max(max(r1, r2), r3);
                    } else {
                        r = pow(pow(x[i] - circumCenter.first, 2) + pow(y[i] - circumCenter.second, 2), 0.5);
                    }
                    if (r > answer) continue;

                    isValid = true;
                    REP(l,0,N) {
                        double rr = pow(pow(x[l] - circumCenter.first, 2) + pow(y[l] - circumCenter.second, 2), 0.5);
                        if (r < rr) {
                            isValid = false;
                            break;
                        }
                    }
                    if (isValid) {
                        answer = r;
                    }
                }
            }
        }
        out << fixed << setprecision(16) << answer << "\n";
    }
};


signed main() {
    FEncloseAll solver;
    std::istream& in(std::cin);
	std::ostream& out(std::cout);
	solver.solve(in, out);
	return 0;
}


Measured memory_bytes: 384