// Slower C++ solution:
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

#define ll long long

#define iiii tuple<int, int, int, int>

#define iii tuple<int, int, int>

#define ii pair<int, int>

#define dd pair<double, double>

#define fi first

#define vi vector<int>

#define vvi vector<vector<int>>

#define se second



using namespace std;

using namespace __gnu_pbds;



template <typename T>

using ordered_set =

    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;



const int M = 1e3;

double e = 1e-8;



double f(vector<ii>& a, double x, double y) {

    double res = 0;

    for (auto& i : a)

        res = max(res, (i.fi - x) * (i.fi - x) + (i.se - y) * (i.se - y));

    return sqrt(res);

}



double dx(vector<ii>& a, double x, double y) {

    return (f(a, x + e, y) - f(a, x - e, y)) / e;

}



double dy(vector<ii>& a, double x, double y) {

    return (f(a, x, y + e) - f(a, x, y - e)) / e;

}



bool test(vector<ii>& a, double L, double x, double y) {

    return f(a, x, y) > f(a, x - dx(a, x, y) * L, y - dy(a, x, y) * L);

}



double cal_L(vector<ii>& a, double x, double y, double tdx, double tdy) {

    double lef = 0, rig = 1000;

    int cnt = 100;

    while (cnt--) {

        double l1 = (lef + lef + rig) / 3;

        double l2 = (lef + rig + rig) / 3;

        if (f(a, x - tdx * l1, y - tdy * l1) > f(a, x - tdx * l2, y - tdy * l2))

            lef = l1;

        else

            rig = l2;

    }

    return lef;

}



void solve() {

    int n;

    cin >> n;

    vector<ii> a(n);

    for (int i = 0; i < n; ++i) cin >> a[i].fi >> a[i].se;



    int cnt = 1000;

    double L = 1000, x = 0, y = 0;

    while (cnt--) {

        double tdx = dx(a, x, y), tdy = dy(a, x, y);



        L = cal_L(a, x, y, tdx, tdy);



        x -= tdx * L;

        y -= tdy * L;

    }

    cout << fixed << setprecision(15) << f(a, x, y) << '\n';

}



int main() {

    ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

    // freopen("in", "r", stdin);



    int t = 1;

    // cin >> t;

    while (t--) solve();



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.8284345470472445x):
// Use gradient descent

#include <bits/stdc++.h>

#define X first

#define Y second

using namespace std;

typedef pair<double,double> pi;

vector<pi> point;

int n;



double dis(pi A,pi B){

    return sqrt((A.X - B.X)*(A.X - B.X) + (A.Y - B.Y)*(A.Y - B.Y));

}



double f(pi p){

    double res = 0;

    for (pi x: point) res = max(res,dis(p,x));

    return res;

}



int main(){

    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

    cin >> n;

    point.resize(n);

    for (int i = 0; i < n; i++) cin >> point[i].X >> point[i].Y;

    

    double ans = 200000;

    double px = 0, py = 0, alpha = 1e2, delta = 1e-7;

    for (int Loop = 0; Loop < 20000; Loop++){

        double dx = (f(pi(px + delta,py)) - f(pi(px - delta,py)))/(2*delta);

        double dy = (f(pi(px,py + delta)) - f(pi(px,py - delta)))/(2*delta);

        px -= alpha*dx;

        py -= alpha*dy;

        alpha *= 0.999;

    }

    cout << fixed << setprecision(8) << f(pi(px,py));



    return 0;

}