#include <bits/stdc++.h>
using namespace std;
int n, x[1042], y[1042];
double eps = 0.00000001;
int dist2(int x1, int y1, int x2, int y2) {
  return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}
double dist(double x1, double y1, double x2, double y2) {
  return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
int cross(int a, int b, int c) {
  return (x[a] - x[b]) * (y[c] - y[b]) - (x[c] - x[b]) * (y[a] - y[b]);
}
bool acute(int a, int b, int c) {
  if (cross(a, b, c) == 0) {
    return 0;
  }
  int dAB = dist2(x[a], y[a], x[b], y[b]);
  int dBC = dist2(x[b], y[b], x[c], y[c]);
  int dAC = dist2(x[a], y[a], x[c], y[c]);
  if (dAB >= dBC + dAC) {
    return 0;
  }
  if (dAC >= dBC + dAB) {
    return 0;
  }
  if (dBC >= dAC + dAB) {
    return 0;
  }
  return 1;
}
bool r(int a, int b, int c) {
  int dAB = dist2(x[a], y[a], x[b], y[b]);
  int dBC = dist2(x[b], y[b], x[c], y[c]);
  int dAC = dist2(x[a], y[a], x[c], y[c]);
  if (dAB == dBC + dAC) {
    return 1;
  }
  if (dAC == dBC + dAB) {
    return 1;
  }
  if (dBC == dAC + dAB) {
    return 1;
  }
  return 0;
}
bool covered(double cx, double cy, double t) {
  for (int i = 0; i < n; i++) {
    if (dist(cx, cy, x[i], y[i]) < t) {
      return 1;
    }
  }
  return 0;
}
pair<double, double> getCirC(int a, int b, int c) {
  int dx1 = x[a] - x[b], dx2 = x[b] - x[c], dx3 = x[c] - x[a];
  int dy1 = y[a] - y[b], dy2 = y[b] - y[c], dy3 = y[c] - y[a];
  double xc1 = (x[a] + x[b]) / 2., xc2 = (x[b] + x[c]) / 2.,
         xc3 = (x[c] + x[a]) / 2.;
  double yc1 = (y[a] + y[b]) / 2., yc2 = (y[b] + y[c]) / 2.,
         yc3 = (y[c] + y[a]) / 2.;
  if (dy1 == 0) {
    swap(dx1, dx3);
    swap(dy1, dy3);
    swap(xc1, xc3);
    swap(yc1, yc3);
  }
  if (dy2 == 0) {
    swap(dx2, dx3);
    swap(dy2, dy3);
    swap(xc2, xc3);
    swap(yc2, yc3);
  }
  double n1 = -1. * dx1 / (double)dy1, n2 = -1. * dx2 / (double)dy2;
  double x = (yc2 - yc1 + n1 * xc1 - n2 * xc2) / (n1 - n2);
  double y = n1 * (x - xc1) + yc1;
  return make_pair(x, y);
}
int main() {
  cin >> n;
  for (int i = 0; i < n; i++) {
    cin >> x[i] >> y[i];
  }
  double ans = -1;
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      for (int k = j + 1; k < n; k++) {
        if (acute(i, j, k)) {
          pair<double, double> crr = getCirC(i, j, k);
          double px = crr.first, py = crr.second;
          double d = dist(px, py, x[i], y[i]);
          if (!covered(px, py, d - eps)) {
            ans = max(ans, d);
          }
        }
      }
    }
  }
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      vector<int> ids;
      ids.clear();
      for (int k = 0; k < n; k++) {
        if (k == i || k == j) {
          continue;
        }
        if (dist2(x[i], y[i], x[k], y[k]) != dist2(x[j], y[j], x[k], y[k])) {
          continue;
        }
        if (!r(i, j, k)) {
          continue;
        }
        ids.push_back(k);
      }
      if (ids.size() < 2) {
        continue;
      }
      int k = ids[0];
      int cc = ids[1];
      double px = (x[i] + x[j] + x[k] + x[cc]) / 4.;
      double py = (y[i] + y[j] + y[k] + y[cc]) / 4.;
      double d = dist(x[i], y[i], px, py);
      if (!covered(px, py, d - eps)) {
        ans = max(ans, d);
      }
    }
  }
  cout << ans << "\n";
  return 0;
}
