#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <queue>
#include <set>
#include <algorithm>
#include <string>
#include <math.h>
#include <limits.h>
#include <stack>
#include <complex>
#include <stdlib.h>
#include <stdio.h>
#include <functional>
#include <cfloat>
#include <math.h>
#include <numeric>
#include <string.h>
#include <sys/time.h>
#include <random>


#define fs first
#define sc second

using namespace std;

typedef long long ll;
typedef pair<double, double> P;

double dis(P x1, P x2){
    return sqrt((x1.fs - x2.fs) * (x1.fs - x2.fs) + (x1.sc - x2.sc) * (x1.sc - x2.sc));
}


bool isPointOnSegment(int x, int y, int x1, int y1, int x2, int y2)
{
    int d;
    if (x1 > x2) {
        d = x1, x1 = x2, x2 = d;
        d = y1, y1 = y2, y2 = d;
    }
    return x1 <= x && x <= x2 &&
           ((y1 <= y2 && y1 <= y && y <= y2) ||
            (y1 > y2 && y2 <= y && y <= y1))
           && (y-y1)*(x2-x1) == (y2-y1)*(x-x1);
}


pair<P, double> calc(P x1, P x2, P x3){
    double u1 = x1.fs * x1.fs - x2.fs * x2.fs + x1.sc * x1.sc - x2.sc * x2.sc;
    double u2 = x2.fs * x2.fs - x3.fs * x3.fs + x2.sc * x2.sc - x3.sc * x3.sc;

    double p1 = x2.fs - x1.fs; p1 *= 2.0;
    double p2 = x3.fs - x2.fs; p2 *= 2.0;
    double q1 = x2.sc - x1.sc; q1 *= 2.0;
    double q2 = x3.sc - x2.sc; q2 *= 2.0;

    double cx = (u2 * q1 - u1 * q2) / (p1 * q2 - p2 * q1);
    double cy = (p2 * u1 - p1 * u2) / (p1 * q2 - p2 * q1);

    double r = max(dis(x1, P(cx, cy)), max(dis(x2, P(cx, cy)), dis(x3, P(cx, cy))));
    return pair<P, double>(P(cx, cy), r);
};



int main(){
    int n;  cin >> n;
    pair<int, int> r2[100];
    P r[100];
    for(int i = 0; i < n; i++){
        cin >> r2[i].fs >> r2[i].sc;
        r[i].fs = (double)(r2[i].fs); r[i].sc = (double)(r2[i].sc);
    }

    if(n == 2){
        double res =  dis(r[0], r[1]) / 2;
        printf("%.10f\n", res);

        return 0;
    }

    double res = DBL_MAX;
    for(int i = 0; i < n; i++){
        for(int j = i+1; j < n; j++){
            for(int k = j+1; k < n; k++){
                P cent; double rad;
                if(isPointOnSegment(r2[i].fs, r2[i].sc, r2[j].fs, r2[j].sc, r2[k].fs, r2[k].sc)){
                    cent = P((r[j].fs + r[k].fs) / 2.0, (r[j].sc + r[k].sc) / 2.0);
                    rad = dis(r[j], r[k]) / 2.0;
                }
                else if(isPointOnSegment(r2[j].fs, r2[j].sc, r2[i].fs, r2[i].sc, r2[k].fs, r2[k].sc)){
                    cent = P((r[i].fs + r[k].fs) / 2.0, (r[i].sc + r[k].sc) / 2.0);
                    rad = dis(r[i], r[k]) / 2.0;
                }
                else if(isPointOnSegment(r2[k].fs, r2[k].sc, r2[i].fs, r2[i].sc, r2[j].fs, r2[j].sc)){
                    cent = P((r[i].fs + r[j].fs) / 2.0, (r[i].sc + r[j].sc) / 2.0);
                    rad = dis(r[i], r[j]) / 2.0;
                }
                else {
                    P cent1 = P((r[i].fs + r[j].fs) / 2, (r[i].sc + r[j].sc) / 2);
                    P cent2 = P((r[i].fs + r[k].fs) / 2, (r[i].sc + r[k].sc) / 2);
                    P cent3 = P((r[j].fs + r[k].fs) / 2, (r[j].sc + r[k].sc) / 2);
                    double rx = dis(r[i], r[j]) / 2;
                    double ry = dis(r[i], r[k]) / 2;
                    double rz = dis(r[j], r[k]) / 2;

                    if(dis(cent1, r[k]) + 1e-08 < rx){
                        cent = cent1;
                        rad = rx;
                    }
                    else if(dis(cent2, r[j]) + 1e-08 < ry){
                        cent = cent2;
                        rad = ry;
                    }
                    else if(dis(cent3, r[i]) + 1e-08 < rz){
                        cent = cent3;
                        rad = rz;
                    }
                    else {

                        pair<P, double> xx = calc(r[i], r[j], r[k]);
                        cent = xx.fs;
                        rad = xx.sc;

                    }
                }
                bool ok = true;
                for(int l = 0; l < n; l++){
                    if(dis(cent, r[l]) - 1e-08 > rad){
                        ok = false;
                        break;
                    }
                }
                if(ok){
                    res = min(res, rad);
                }
            }
        }
    }

    printf("%.10f\n", res);


    return 0;
}


Measured memory_bytes: 256