//#include <bits/stdc++.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
#include <map>
#include <iomanip>
#include <stdlib.h>
#include <queue>
#include <deque>
#include <set>
#include <stack>
#include <time.h>
 
using namespace std;
 
typedef long long ll;
const ll nmax = 1e9 + 7;
const ll MOD = 998244353;
const double PI = 2 * asin(1);

pair <double , pair<double, double> > Outer(double x1, double y1, double x2, double y2, double x3, double y3){
  
  int dx1 = x1 - x2, dy1 = y1 - y2;
  int dx2 = x1 - x3, dy2 = y1 - y3;

  if (dx1 * dy2 - dx2 * dy1 == 0){
    double mx = min(x1, min(x2, x3)), my = min(y1, min(y2, y3));
    double MX = max(x1, max(x2, x3)), MY = max(y1, max(y2, y3));
    
    double X = (mx + MX) / 2, Y = (my + MY) / 2;
    double R = sqrt(pow(X - x1, 2) + pow(Y - y1, 2));
    R = max(R, sqrt(pow(X - x2, 2) + pow(Y - y2, 2)));
    
    return make_pair(R, make_pair(X, Y));
  }else{
    double A = x1 * x1 + y1 * y1 - x2 * x2 - y2 * y2;
    double B = x1 * x1 + y1 * y1 - x3 * x3 - y3 * y3;

    double X = (y1 - y3) * A - (y1 - y2) * B;
    X /= 2 * (x1 - x2) * (y1 - y3) - 2 * (x1 - x3) * (y1 - y2);

    double Y = (x1 - x3) * A - (x1 - x2) * B;
    Y /= 2 * (y1 - y2) * (x1 - x3) - 2 * (y1 - y3) * (x1 - x2);

    double dist = sqrt(pow(X - x1, 2) + pow(Y - y1, 2));
    return make_pair(dist, make_pair(X, Y));
  }
}

int main(){
  int N; cin >> N;

  vector <double> X(N), Y(N);
  for (int i = 0; i < N; i++){
    cin >> X[i] >> Y[i];
  }

  if (N == 2){
    double rx = (X[0] + X[1]) / 2, ry = (Y[0] + Y[1]) / 2;
    double R = sqrt(pow((rx - X[0]), 2) + pow(ry - Y[0], 2));
    cout << setprecision(32) << R << endl;
    return 0;
  }
  
  double ans = 1e9;
  for (int i = 0; i < N; i++){
    for (int j = i + 1; j < N; j++){
      for (int k = j + 1; k < N; k++){
        pair < double, pair<double, double> > NOW = Outer(X[i], Y[i], X[j], Y[j], X[k], Y[k]);
        double R = pow(NOW.first, 2);
        pair <double, double> now = NOW.second;

        bool flag = true;
        for (int i1 = 0; i1 < N; i1++){
          if (i1 == i || i1 == j || i1 == k) continue;
          double dist = pow(X[i1] - now.first, 2) + pow(Y[i1] - now.second, 2);
          if (dist > R) flag = false;
        }
        if (flag == true) ans = min(ans, sqrt(R));

        flag = true;
        double dist1 = pow(X[i] - X[j], 2) + pow(Y[i] - Y[j], 2);
        double dist2 = pow(X[j] - X[k], 2) + pow(Y[j] - Y[k], 2);
        double dist3 = pow(X[k] - X[i], 2) + pow(Y[k] - Y[i], 2);

        if (dist1 + dist2 < dist3){
          now = make_pair((X[k] + X[i]) / 2, (Y[k] + Y[i]) / 2);
          R = dist3 / 4;
        }else if (dist2 + dist3 < dist1){
          now = make_pair((X[i] + X[j]) / 2, (Y[i] + Y[j]) / 2);
          R = dist1 / 4;
        }else if (dist3 + dist1 < dist2){
          now = make_pair((X[j] + X[k]) / 2, (Y[j] + Y[k]) / 2);
          R = dist2 / 4;
        }
        for (int i1 = 0; i1 < N; i1++){
          if (i1 == i || i1 == j || i1 == k) continue;
          double dist = pow(X[i1] - now.first, 2) + pow(Y[i1] - now.second, 2);
          if (dist > R) flag = false;
        }
        if (flag == true) ans = min(ans, sqrt(R));        

      }
    }    
  }
  cout << setprecision(32) << ans << endl;

  return 0;
}


Measured memory_bytes: 256