#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
class PT {
 public:
  double x, y;
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y) {}
  double Magnitude() { return sqrt(x * x + y * y); }
  PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
  PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
  PT operator*(double c) const { return PT(x * c, y * c); }
  PT operator/(double c) const { return PT(x / c, y / c); }
};
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double dist(PT p, PT q) { return sqrt(dist2(p, q)); }
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
double myAsin(double a, double b) {
  if (a / b > 1) return pi * 0.5;
  if (a / b < -1) return -pi * 0.5;
  return asin(a / b);
}
double myAtan(double a, double b) {
  if (b == 0) return pi * 0.5;
  return atan(a / b);
}
ostream &operator<<(ostream &os, const PT &p) {
  os << "(" << p.x << "," << p.y << ")";
}
PT scale(PT p, PT pivot, double c) {
  PT trans = p - pivot;
  trans = (trans * c) / trans.Magnitude();
  return trans + pivot;
}
PT RotateCCW90(PT p) { return PT(-p.y, p.x); }
PT RotateCW90(PT p) { return PT(p.y, -p.x); }
PT RotateCCW(PT p, double t) {
  return PT(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));
}
PT RotateAroundPointCCW(PT p, PT pivot, double t) {
  PT trans = p - pivot;
  PT ret = RotateCCW(trans, t);
  ret = ret + pivot;
  return ret;
}
PT Reflection(PT ray, PT normal) {
  ray = ray / ray.Magnitude();
  normal = normal / normal.Magnitude();
  return normal * (2 * dot(ray, normal)) - ray;
}
PT ProjectPointLine(PT a, PT b, PT c) {
  return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(PT a, PT b, PT c) {
  return dist(c, ProjectPointLine(a, b, c));
}
PT ProjectPointSegment(PT a, PT b, PT c) {
  double r = dot(b - a, b - a);
  if (fabs(r) < 1e-7) return a;
  r = dot(c - a, b - a) / r;
  if (r < 0) return a;
  if (r > 1) return b;
  return a + (b - a) * r;
}
double DistancePointSegment(PT a, PT b, PT c) {
  return sqrt(dist2(c, ProjectPointSegment(a, b, c)));
}
double DistancePointPlane(double x, double y, double z, double a, double b,
                          double c, double d) {
  return fabs(a * x + b * y + c * z - d) / sqrt(a * a + b * b + c * c);
}
bool LinesParallel(PT a, PT b, PT c, PT d) {
  return fabs(cross(b - a, c - d)) < 1e-7;
}
bool LinesCollinear(PT a, PT b, PT c, PT d) {
  return LinesParallel(a, b, c, d) && fabs(cross(a - b, a - c)) < 1e-7 &&
         fabs(cross(c - d, c - a)) < 1e-7;
}
bool SegmentsIntersect(PT a, PT b, PT c, PT d) {
  if (LinesCollinear(a, b, c, d)) {
    if (dist2(a, c) < 1e-7 || dist2(a, d) < 1e-7 || dist2(b, c) < 1e-7 ||
        dist2(b, d) < 1e-7)
      return true;
    if (dot(c - a, c - b) > 0 && dot(d - a, d - b) > 0 && dot(c - b, d - b) > 0)
      return false;
    return true;
  }
  if (cross(d - a, b - a) * cross(c - a, b - a) > 0) return false;
  if (cross(a - c, d - c) * cross(b - c, d - c) > 0) return false;
  return true;
}
PT ComputeLineIntersection(PT a, PT b, PT c, PT d) {
  b = b - a;
  d = c - d;
  c = c - a;
  assert(dot(b, b) > 1e-7 && dot(d, d) > 1e-7);
  return a + b * cross(c, d) / cross(b, d);
}
PT ComputeCircleCenter(PT a, PT b, PT c) {
  b = (a + b) / 2;
  c = (a + c) / 2;
  return ComputeLineIntersection(b, b + RotateCW90(a - b), c,
                                 c + RotateCW90(a - c));
}
bool PointInPolygon(const vector<PT> &p, PT q) {
  bool c = 0;
  for (int i = 0; i < p.size(); i++) {
    int j = (i + 1) % p.size();
    if ((p[i].y <= q.y && q.y < p[j].y || p[j].y <= q.y && q.y < p[i].y) &&
        q.x < p[i].x + (p[j].x - p[i].x) * (q.y - p[i].y) / (p[j].y - p[i].y))
      c = !c;
  }
  return c;
}
bool PointOnPolygon(const vector<PT> &p, PT q) {
  for (int i = 0; i < p.size(); i++)
    if (dist2(ProjectPointSegment(p[i], p[(i + 1) % p.size()], q), q) < 1e-7)
      return true;
  return false;
}
vector<PT> CircleLineIntersection(PT a, PT b, PT c, double r) {
  vector<PT> ret;
  b = b - a;
  a = a - c;
  double A = dot(b, b);
  double B = dot(a, b);
  double C = dot(a, a) - r * r;
  double D = B * B - A * C;
  if (D < -1e-7) return ret;
  ret.push_back(c + a + b * (-B + sqrt(D + 1e-7)) / A);
  if (D > 1e-7) ret.push_back(c + a + b * (-B - sqrt(D)) / A);
  return ret;
}
vector<PT> CircleCircleIntersection(PT a, PT b, double r, double R) {
  vector<PT> ret;
  double d = sqrt(dist2(a, b));
  if (d > r + R || d + min(r, R) < max(r, R)) return ret;
  double x = (d * d - R * R + r * r) / (2 * d);
  double y = sqrt(r * r - x * x);
  PT v = (b - a) / d;
  ret.push_back(a + v * x + RotateCCW90(v) * y);
  if (y > 0) ret.push_back(a + v * x - RotateCCW90(v) * y);
  return ret;
}
double ComputeSignedArea(const vector<PT> &p) {
  double area = 0;
  for (int i = 0; i < p.size(); i++) {
    int j = (i + 1) % p.size();
    area += p[i].x * p[j].y - p[j].x * p[i].y;
  }
  return area / 2.0;
}
double ComputeArea(const vector<PT> &p) { return fabs(ComputeSignedArea(p)); }
PT ComputeCentroid(const vector<PT> &p) {
  PT c(0, 0);
  double scale = 6.0 * ComputeSignedArea(p);
  for (int i = 0; i < p.size(); i++) {
    int j = (i + 1) % p.size();
    c = c + (p[i] + p[j]) * (p[i].x * p[j].y - p[j].x * p[i].y);
  }
  return c / scale;
}
bool IsSimple(const vector<PT> &p) {
  for (int i = 0; i < p.size(); i++) {
    for (int k = i + 1; k < p.size(); k++) {
      int j = (i + 1) % p.size();
      int l = (k + 1) % p.size();
      if (i == l || j == k) continue;
      if (SegmentsIntersect(p[i], p[j], p[k], p[l])) return false;
    }
  }
  return true;
}
double PAngle(PT a, PT b, PT c) {
  PT temp1(a.x - b.x, a.y - b.y), temp2(c.x - b.x, c.y - b.y);
  double ans = asin((temp1.x * temp2.y - temp1.y * temp2.x) /
                    (temp1.Magnitude() * temp2.Magnitude()));
  if ((ans < 0 && (temp1.x * temp2.x + temp1.y * temp2.y) < 0) ||
      (ans >= 0 && (temp1.x * temp2.x + temp1.y * temp2.y) < 0))
    ans = pi - ans;
  ans = ans < 0 ? 2 * pi + ans : ans;
  return ans;
}
PT circumcentre(PT a, PT b, PT c) {
  PT mid1 = (a + b) / 2.0;
  PT mid11 = RotateAroundPointCCW(a, mid1, pi / 2.0);
  PT mid2 = (b + c) / 2.0;
  PT mid22 = RotateAroundPointCCW(b, mid2, pi / 2.0);
  PT mid3 = (c + a) / 2.0;
  PT mid33 = RotateAroundPointCCW(c, mid3, pi / 2.0);
  PT now = ComputeLineIntersection(mid1, mid11, mid2, mid22);
  return now;
}
vector<PT> v, points;
bool check(PT p, double dist) {
  int i, j;
  for (i = 0; i < v.size(); i++) {
    if (dist2(p, v[i]) < dist - 1e-7) return false;
  }
  return true;
}
int main() {
  int n, i, j, k, x, y, l;
  PT p;
  cin >> n;
  for (i = 0; i < n; i++) {
    cin >> x >> y;
    p.x = x;
    p.y = y;
    v.push_back(p);
  }
  if (n <= 2) {
    cout << -1 << endl;
    return 0;
  }
  for (i = 0; i < v.size(); i++) {
    for (j = i + 1; j < v.size(); j++) {
      for (k = j + 1; k < v.size(); k++) {
        double ang1 = PAngle(v[i], v[j], v[k]);
        if (ang1 > pi) ang1 = 2.0 * pi - ang1;
        double ang2 = PAngle(v[i], v[k], v[j]);
        if (ang2 > pi) ang2 = 2.0 * pi - ang2;
        double ang3 = PAngle(v[j], v[i], v[k]);
        if (ang3 > pi) ang3 = 2.0 * pi - ang3;
        if (LinesParallel(v[i], v[j], v[j], v[k])) {
          continue;
        }
        if (ang1 < pi / 2.0 - 1e-7 && ang2 < pi / 2.0 - 1e-7 &&
            ang3 < pi / 2.0 - 1e-7) {
          PT cen = circumcentre(v[i], v[j], v[k]);
          if (check(cen, dist2(cen, v[i]))) {
            points.push_back(cen);
          }
        }
      }
    }
  }
  for (i = 0; i < v.size(); i++) {
    for (j = 0; j < v.size(); j++) {
      if (i == j) continue;
      for (k = 0; k < v.size(); k++) {
        if (k == i || k == j) continue;
        for (l = 0; l < v.size(); l++) {
          if (l == i || l == j || l == k) continue;
          if (LinesParallel(v[i], v[j], v[j], v[k]) &&
              LinesParallel(v[j], v[k], v[k], v[l])) {
            continue;
          }
          if (dist2(v[i], v[j]) == dist2(v[k], v[l]) &&
              dist2(v[i], v[k]) == dist2(v[j], v[l]) &&
              dist2(v[i], v[j]) + dist2(v[j], v[k]) == dist2(v[i], v[k])) {
            PT cen = (v[i] + v[k]) / 2.0;
            if (check(cen, dist2(cen, v[i]))) {
              points.push_back(cen);
            }
          }
        }
      }
    }
  }
  if (points.size() == 0) {
    cout << -1 << endl;
    return 0;
  }
  double maxx = 0, minn = 1e30;
  for (i = 0; i < points.size(); i++) {
    minn = 1e30;
    for (j = 0; j < v.size(); j++) {
      double dist = dist2(points[i], v[j]);
      minn = min(minn, dist);
    }
    maxx = max(maxx, minn);
  }
  maxx = sqrt(maxx);
  if (abs(maxx) < 1e-7) {
    cout << -1 << endl;
    return 0;
  }
  printf("%.10f\n", maxx);
  return 0;
}
