#include <bits/stdc++.h>
#include <math.h>
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 0

using namespace std;
#define ll long long
#define rep(i,n) for (int i = 0; i < n; i++)
#define rrep(i,n) for (int i = n-1; i >= 0; i--)
#define MOD (1000000007)
#define vi vector<int>
#define vl vector<ll>
#define vb vector<bool>
#define vvi vector<vi>
#define vvl vector<vl>
#define pii pair<int, int>
#define pli pair<ll, int>a
#define pb push_back
#define sz(x) int(x.size())

#define mp make_pair
#define all(a) (a).begin(),(a).end()

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

ll gcd(ll a, ll b) {
    if (b == 0) return a;
    else return gcd(b, a % b);
}

ll keta(ll n){
  string s = to_string(n);
  ll num = s.size();
  return num;
}

const ll INF = 1LL << 60;

const int dh[4] = {1,0,-1,0};
const int dw[4] = {0,1,0,-1};

struct Edge{
  int to;
  int weight;
  Edge(int t, int w) : to(t), weight(w){}
};
using Graph = vector<vector<Edge>>;
using P = pair<ll, int>;

class UnionFind{
public:
  vi Parent;
  UnionFind(int n){
    Parent = vi(n,-1);
  }

  int root(int a){
    if(Parent[a] < 0) return a;
    else return Parent[a] = root(Parent[a]);
  }

  int size(int a){
    return -Parent[root(a)];
  }

  bool merge(int a, int b){
    a = root(a);
    b = root(b);
    if(a == b) return false;

    if(size(a) < size(b)) swap(a,b);
    Parent[a] += Parent[b];
    Parent[b] = a;

    return true;
  }
};

class Factrial{
public:
  vl Fac;
  Factrial(int MAX){
    Fac = vl(MAX+1);
    rep(i,MAX) {
      if(i == 0) Fac[i+1] = 1;
      else Fac[i+1] = ((i+1)*Fac[i])%MOD;
    }
  }
};

double dist(double a1, double b1, double a2, double b2){
  return sqrt((a1-a2)*(a1-a2) + (b1-b2)*(b1-b2));
}

int main(){
  int n; cin >> n;
  vector<double> x(n), y(n);
  rep(i,n) cin >> x[i] >> y[i];

  double ans = INF;
  rep(i,n) rep(j,n){
    if(i == j) continue;
    double cx = (x[i] + x[j])/2.0;
    double cy = (y[i] + y[j])/2.0;
    double r = dist(cx,cy,x[i],y[i]);
    //printf("r:%f cx:%f cy:%f\n", r, cx, cy);
    bool ok = true;
    rep(k,n){
      double d = dist(cx, cy, x[k], y[k]);
      if(d > r){
        ok = false;
        break;
      }
    }
    if(ok) chmin(ans, r);
    //printf("ans:%f\n", ans);
  }

  if(n == 2){
    cout << fixed << setprecision(10) << ans << endl;
    return 0;
  }


  rep(i,n) rep(j,n) rep(k,n) {
    if(i == j || j == k || k == i) continue;
    double tmp = (x[i]-x[j])*(y[j]-y[k]) - (x[j]-x[k])*(y[i]-y[j]);
    tmp *= 2.0;
    double X1 = x[i]*x[i] + y[i]*y[i];
    double X2 = x[j]*x[j] + y[j]*y[j];
    double X3 = x[k]*x[k] + y[k]*y[k];
    double cx = (y[j]-y[k])*(X1-X2) + (y[j]-y[i])*(X2-X3);
    cx /= tmp;
    double cy = (x[k]-x[j])*(X1-X2) + (x[i]-x[j])*(X2-X3);
    cy /= tmp;
    double r = dist(cx,cy,x[i],y[i]);
    //printf("r:%f cx:%f cy:%f\n", r, cx, cy);
    bool ok = true;
    rep(k,n){
      double d = dist(cx, cy, x[k], y[k]);
      if(d > r){
        ok = false;
        break;
      }
    }
    if(ok) chmin(ans, r);
    //printf("ans:%f\n", ans);
  }
  cout << fixed << setprecision(10) << ans << endl;
}

Measured memory_bytes: 256