#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>
#include <bitset>

long long mod = 1e9+7;
class Mint {
public:
  long long x;
  Mint(){}; // 引数なしでも定義できるように引数なしコンストラクタも用意しておく
  Mint(long long a){
    x = a%mod;
    while(x<0){
      x += mod;
    }
  };
  Mint& operator += (const Mint &a){
    x+=a.x;
    x%=mod;
    return *this;
  }
  Mint& operator -= (const Mint &a){
    x += (mod - a.x);
    x%=mod;
    return *this;
  }
  Mint& operator *= (const Mint &a){
    x*=a.x;
    x%=mod;
    return *this;
  }

  // a^n mod を計算する
  // Useaeg: Mint z = y.pow(y, n);
  Mint pow(Mint a, long long n) const {
    Mint y(1);
    Mint b(a);
    while (n > 0) {
      if (n & 1) y *= b;
      b *= b;
      n >>= 1;
    }
    return y;
  }

  // a^{-1} mod を計算する
  Mint modinv(const Mint &a) const {
    return pow(a, mod-2);
  }

  Mint& operator /= (const Mint &a) {
    x *= modinv(a).x;
    x %= mod;
    return *this;
  }

  Mint operator + (Mint &a) const {
    Mint y(*this);
    y += a;
    return y;
  }

  Mint operator - (Mint &a) const {
    Mint y(*this);
    y -= a;
    return y;
  }

  Mint operator * (Mint &a) const {
    Mint y(*this);
    y *= a;
    return y;
  }

  Mint operator / (Mint &a) const {
    Mint y(*this);
    y/=a;
    return y.x;
  }

  // nCk @mod を計算する
  Mint nCk(Mint &n, const long long k) const {
    Mint y = Mint(1);
    Mint one = Mint(1);
    for (Mint i(0); (i.x)<k; i.x++){
      y *= (n-i);
      y /= (i + one);
    }
    return y;
  }

  // nPk @mod を計算する
  Mint nPk(Mint &n, long long k) const {
    Mint y(1);
    for (Mint i(0); (i.x)<k; i.x++){
      y *= (n-i);
    }
    return y;
  }
};

// modを取らないnCkの計算
// 全体としてはオーバーフローしないはずでも、先に分子だけ計算したときに
// オーバーフローする可能性があることに注意                                                                                            
long long NCK[54][54];
void init(int n=54)	{
  for (int i=0; i<n; i++) {
    for (int j=0; j<=i; j++) {
      if (j==0 || j==i) {
        NCK[i][j] = 1;
      } else {
        // パスカルの三角形の性質 nCk = (n-1)C(k-1) + (n-1)Ck を利用
        NCK[i][j] = NCK[i-1][j-1] + NCK[i-1][j];
      }
    }
  }
  return;
}

struct edge {
  int cost;
  int x1;
  int y1;
  int x2;
  int y2;
};


struct data {
  int v;
  int min;
  int p;
};

// vector sort用
bool MySort (const data &p1, const data &p2){
  return p1.min < p2.min;
}

// priority_queue 用
class CompareFirst {
public:
  bool operator()(data n1, data n2) {
    return n1.min < n2.min;
  }
};

struct point {
  int x;
  int y;
};

struct pointD {
  double x;
  double y;
};

double getrad(point p1, point p2, point p3) {
  //printf("(%d, %d), (%d, %d), (%d, %d)\n", p1.x, p1.y, p2.x, p2.y, p3.x, p3.y);
  double d1 = sqrt(pow(p2.x-p3.x,2)+pow(p2.y-p3.y, 2));
  double d2 = sqrt(pow(p3.x-p1.x,2)+pow(p3.y-p1.y, 2));
  double d3 = sqrt(pow(p2.x-p1.x,2)+pow(p2.y-p1.y, 2));
  if ((p2.x-p1.x)*(p3.y-p1.y) == (p2.y-p1.y)*(p3.x-p1.x)) {
    return std::max(d3, std::max(d1,d2)) / 2.0;
  } else {
    double rad = 1e18;
    pointD c1;
    c1.x = (double)(p2.x+p3.x)/2.0;
    c1.y = (double)(p2.y+p3.y)/2.0;
    double r1 = sqrt(pow(c1.x-p2.x,2)+pow(c1.y-p2.y,2));
    double l1 = sqrt(pow(c1.x-p1.x,2)+pow(c1.y-p1.y,2));
    pointD c2;
    c2.x = (double)(p1.x+p3.x)/2.0;
    c2.y = (double)(p1.y+p3.y)/2.0;
    double r2 = sqrt(pow(c2.x-p3.x,2)+pow(c2.y-p3.y,2));
    double l2 = sqrt(pow(c2.x-p2.x,2)+pow(c2.y-p2.y,2));
    pointD c3;
    c3.x = (double)(p2.x+p1.x)/2.0;
    c3.y = (double)(p2.y+p1.y)/2.0;
    double r3 = sqrt(pow(c3.x-p1.x,2)+pow(c3.y-p1.y,2)); 
    double l3 = sqrt(pow(c3.x-p3.x,2)+pow(c3.y-p3.y,2));
    bool find = false;
    // printf("(%lf, %lf): r1=%lf\n", c1.x, c1.y, r1);
    // printf("r2=%lf\n", r2);
    // printf("r3=%lf\n", r3);
    if (r1>=l1) {
      rad = std::min(rad, r1);
      find = true;
    }
    if (r2>=l2) {
      rad = std::min(rad, r2);
      find = true;
    }
    if (r3>=l3) {
      rad = std::min(rad, r3);
      find = true;
    }
    // printf("find=%d\n", find);
    if (find) return rad;
    
    double cos1 = ((p2.x-p1.x)*(p3.x-p1.x)+(p2.y-p1.y)*(p3.y-p1.y))/ (d2*d3);
    double sin1 = sqrt(1-cos1*cos1);
    // printf("sin1=%lf, cos1=%lf\n", sin1, cos1);
    rad = d1 * 0.5 / sin1;
    // printf("rad=%lf\n", rad);
    return rad;
  }
}

int main() {
  int N;
  std::cin >> N;
  std::vector<int > x(N), y(N);
  for (int i=0; i<N; i++) {
    std::cin >> x[i] >> y[i];
  }
  if (N==2) {
    double ans = sqrt(pow(x[0]-x[1], 2) + pow(y[0]-y[1], 2)) / 2.0;
    printf("%.15lf\n", ans);
    return 0;
  }
  double ans = 0.0;
  for (int i=0; i<N; i++) {
    for (int j=i+1; j<N; j++) {
      for (int k=j+1; k<N; k++) {
        double rad = getrad((point){x[i], y[i]},
                            (point){x[j], y[j]},
                            (point){x[k], y[k]});
        ans = std::max(ans, rad);
      }
    }
  }
  printf("%.15lf\n", ans);
  return 0;
}

Measured memory_bytes: 3220