#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <queue>
#include <cstring>
#include <string>
#include <cmath>
#include <ctime>
#pragma comment (linker, "/STACK:256000000")

using namespace std;

struct pt {
	int x, y;
};

bool cmp (pt a, pt b) {
	return a.x < b.x || a.x == b.x && a.y < b.y;
}

bool cw (pt a, pt b, pt c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) < 0;
}

bool ccw (pt a, pt b, pt c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) > 0;
}

void convex_hull (vector<pt> & a) {
	if (a.size() == 1)  return;
	sort (a.begin(), a.end(), &cmp);
	pt p1 = a[0],  p2 = a.back();
	vector<pt> up, down;
	up.push_back (p1);
	down.push_back (p1);
	for (size_t i=1; i<a.size(); ++i) {
		if (i==a.size()-1 || cw (p1, a[i], p2)) {
			while (up.size()>=2 && !cw (up[up.size()-2], up[up.size()-1], a[i]))
				up.pop_back();
			up.push_back (a[i]);
		}
		if (i==a.size()-1 || ccw (p1, a[i], p2)) {
			while (down.size()>=2 && !ccw (down[down.size()-2], down[down.size()-1], a[i]))
				down.pop_back();
			down.push_back (a[i]);
		}
	}
	a.clear();
	for (size_t i=0; i<up.size(); ++i)
		a.push_back (up[i]);
	for (size_t i=down.size()-2; i>0; --i)
		a.push_back (down[i]);
}

const int maxN = 110;
int n;
int x[maxN], y[maxN];
double d[maxN][maxN];
int dd[maxN][maxN];
int a[maxN][maxN][maxN];

double dist(double x1, double y1, double x2, double y2) {
	double dx = x1 - x2;
	double dy = y1 - y2;
	return sqrt(dx * dx + dy * dy);
}

double res = 0.0;
const double eps = 1e-9;

int getScalar(int i, int j, int k) {
	return (x[i] - x[j]) * (x[i] - x[k]) + (y[i] - y[j]) * (y[i] - y[k]);
}

void getCenter(int i, int j, int k, double& u, double& v) {
	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (double)(::a[i][j][k]) / 2.0;
	S = 8.0 * S * S;

	double A = (a * a) / S * getScalar(i, j, k);
	double B = (b * b) / S * getScalar(j, i, k);
	double C = (c * c) / S * getScalar(k, i, j);

	u = (double)(x[i]) * A + (double)(x[j]) * B + (double)(x[k]) * C;
	v = (double)(y[i]) * A + (double)(y[j]) * B + (double)(y[k]) * C;
}

vector < pt > w;
double wS;

double solve(int i, int j, int k) {
	/*int p = dd[i][j];
	int q = dd[i][k];
	int r = dd[j][k];
	if (p > q) {
		swap(p, q);
	}
	if (p > r) {
		swap(p, r);
	}
	if (q > r) {
		swap(q, r);
	}
	if (p + q - r < 0) {
		return 0.0;
	}*/

	double cx, cy;
	getCenter(i, j, k, cx, cy);

	double area = 0.0;
	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		double x1 = (double)(w[i].x) - cx;
		double y1 = (double)(w[i].y) - cy;
		double x2 = (double)(w[j].x) - cx;
		double y2 = (double)(w[j].y) - cy;
		area += fabs(x1 * y2 - x2 * y1);
	}

	if (fabs(area - wS) > eps) {
		return 0.0;
	}

	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		double d = dist(w[i].x, w[i].y, w[j].x, w[j].y);
		double a = dist(w[i].x, w[i].y, cx, cy);
		double b = dist(w[j].x, w[j].y, cx, cy);
		if (fabs(d - a - b) < eps) {
			return 0.0;
		}
	}

	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	S = fabs(S) / 2.0;

	if (fabs(S) < eps) {
		return 0.0;
	}

	double R = (a * b * c) / (4.0 * S);
	double L = max(a, max(b, c)) / 2.0;

	for (int t = 1; t <= n; ++t) {
		double current = dist(x[t], y[t], cx, cy);
		if (current < R - 1e-6) {
			return 0.0;
			//R = min(R, current);
		}
	}

	return R;
}

int getArea(int i, int j, int k) {
	int S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	return (S > 0 ? S : -S);
}

int main() {
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d%d", &x[i], &y[i]);
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			d[i][j] = dist(x[i], y[i], x[j], y[j]);
			dd[i][j] = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
		}
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			for (int k = 1; k <= n; ++k) {
				a[i][j][k] = getArea(i, j, k);
			}
		}
	}

	for (int i = 1; i <= n; ++i) {
		pt p;
		p.x = x[i];
		p.y = y[i];
		w.push_back(p);
	}
	convex_hull(w);
	wS = 0.0;
	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		wS += w[i].x * w[j].y - w[i].y * w[j].x;
	}
	wS = fabs(wS);

	for (int i = 1; i <= n; ++i) {
		for (int j = i + 1; j <= n; ++j) {
			for (int k = j + 1; k <= n; ++k) {
				res = max(res, solve(i, j, k));
				//int S = a[i][j][k];
				//bool nice = true;

				/*for (int l = 1; l <= n; ++l) {
					if (l == i || l == j || l == k) {
						continue;
					}
					if (a[i][j][l] + a[i][k][l] + a[j][k][l] == S) {
						nice = false;
						break;
					}
				}*/

				//if (nice) {
				//	res = max(res, solve(i, j, k));
				//}
			}
		}
	}

	if (res < eps) {
		printf("-1\n");
		return 0;
	}

	printf("%.10lf\n", res);

	return 0;
}


#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <functional>
#include <utility>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstdio>

using namespace std;

#define REP(i,n) for((i)=0;(i)<(int)(n);(i)++)
#define snuke(c,itr) for(__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++)

#define eps 1.0E-12

int N;
int x[110],y[110];
int dist[110][110];
double sdist[110][110];

struct point {double x,y;};
point P[110];

double func(double a, double b, double c){
    a = sqrt(a); b = sqrt(b); c = sqrt(c);
    return a * b * c / sqrt((a+b+c) * (-a+b+c) * (a-b+c) * (a+b-c));
}

point circumcenter(point P, point Q, point R){
    double x1 = Q.x - P.x, y1 = Q.y - P.y, x2 = R.x - P.x, y2 = R.y - P.y;
    double x = (y2 * (x1*x1 + y1*y1) - y1 * (x2*x2 + y2*y2)) / 2.0 / (x1*y2 - x2*y1);
    double y = -(x2 * (x1*x1 + y1*y1) - x1 * (x2*x2 + y2*y2)) / 2.0 / (x1*y2 - x2*y1);
    point ans = {P.x + x, P.y + y};
    return ans;
}

bool check(point P, double D){
    double x2 = P.x, y2 = P.y;
    int i;
    REP(i,N){
        double dx = x[i] - x2, dy = y[i] - y2;
        if((dx * dx + dy * dy) / D < 1.0 - eps) return false;
    }
    return true;
}

int main(void){
    int i,j,k,l;

    cin >> N;
    REP(i,N) cin >> x[i] >> y[i];

    REP(i,N){
        P[i].x = x[i];
        P[i].y = y[i];
    }

    double ans = -1.0;

    REP(i,N) REP(j,N){
        int dx = x[i] - x[j], dy = y[i] - y[j];
        dist[i][j] = dx * dx + dy * dy;
        sdist[i][j] = sqrt(dist[i][j]*1.0);
    }

    REP(k,N) REP(j,k) REP(i,j){
        int d1 = dist[i][j], d2 = dist[j][k], d3 = dist[k][i];
        if(d1 + d2 > d3 && d2 + d3 > d1 && d3 + d1 > d2){
            double tmp = func(d1, d2, d3);
            point O = circumcenter(P[i], P[j], P[k]);
            if(check(O, tmp * tmp)) ans = max(ans, tmp);
        }
    }

    REP(i,N) REP(j,i){
        bool found = false;
        REP(k,N) REP(l,k){
            if(!found && dist[i][j] == dist[k][l] && dist[i][k] == dist[j][l] && dist[i][l] == dist[j][k] && dist[i][j] > dist[i][k] && dist[i][j] > dist[i][l]){
                found = true;
                double tmp = sdist[i][j] / 2.0;
                point O = {(x[i] + x[j]) / 2.0, (y[i] + y[j]) / 2.0};
                if(check(O, tmp * tmp)) ans = max(ans, tmp);
            }
        }
    }

    if(ans < -0.5){
        cout << "-1" << endl;
    } else {
        printf("%.9f\n", ans);
    }

    return 0;
}


#pragma warning(disable:4996)
#include <iostream>
#include <cstdio>
#include <vector>
#include <map>
#include <algorithm>
#include <cmath>
#include <sstream>
#include <set>
#include <queue>
#include <cstring>
#include <string>
#include <ctime>
#include <cstdlib>
using namespace std;
typedef long long int64;
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
inline double sqr(double x)
{
	return x*x;
}
int cmp(double x)
{
	if (fabs(x)<eps) return 0;
	if (x>0) return 1;
	return -1;
}
int n;
struct point
{
	double x, y;
	point() {}
	point(double a, double b) :x(a), y(b) {}
	void input()
	{
		scanf("%lf%lf", &x, &y);
	}
	friend point operator +(const point &a, const point &b)
	{
		return point(a.x + b.x, a.y + b.y);
	}
	friend point operator -(const point &a, const point &b)
	{
		return point(a.x - b.x, a.y - b.y);
	}
	friend bool operator == (const point &a, const point &b)
	{
		return cmp(a.x - b.x) == 0 && cmp(a.y - b.y) == 0;
	}
	friend point operator * (const point &a, const double &b)
	{
		return point(a.x*b, a.y*b);
	}
	friend point operator * (const double &a, const point &b)
	{
		return point(a*b.x, a*b.y);
	}
	friend point operator /(const point &a, const double &b)
	{
		return point(a.x / b, a.y / b);
	}
	double norm()                       //x*x+y*y
	{
		return sqrt(sqr(x) + sqr(y));
	}
	double norm1()                       //x*x+y*y
	{
		return sqr(x) + sqr(y);
	}
}P[200];
double det(const point &a, const point &b)
{
	return a.x*b.y - a.y*b.x;
}
point Cir(point a, point b, point c)
{
	point cp;
	double a1 = b.x - a.x, b1 = b.y - a.y, c1 = (a1*a1 + b1*b1) / 2;
	double a2 = c.x - a.x, b2 = c.y - a.y, c2 = (a2*a2 + b2*b2) / 2;
	double d = a1*b2 - a2*b1;
	cp.x = a.x + (c1*b2 - c2*b1) / d;
	cp.y = a.y + (a1*c2 - a2*c1) / d;
	return cp;
}
double dot(const point &a, const point &b)
{
	return a.x*b.y + a.y*b.x;
}
double dist(const point &a, const point &b)
{
	return (a - b).norm();
}
double dist2(const point &a, const point &b)
{
	return (a - b).norm1();
}
bool JudgeRet(int a, int b, int c)
{
	double dis1 = dist2(P[a], P[b]);
	double dis2 = dist2(P[a], P[c]);
	double dis3 = dist2(P[b], P[c]);
	if (((dis1+dis2>dis3)&&(dis2+dis3>dis1)&&(dis1+dis3>dis2)))
		return true;
	else if (dis1 + dis2 == dis3 || dis1 + dis3 == dis2 || dis2 + dis3 == dis1)
	{
		if (dis1 + dis2 == dis3)
		{
			for (int i = 1; i <= n; i++) {
				if (P[i].x == (P[b].x + P[c].x - P[a].x) && P[i].y == (P[b].y + P[c].y - P[a].y)) { return true; break; }
			}
		}
		else if (dis1 + dis3 == dis2)
		{
			for (int i = 1; i <= n; i++) {
				if (P[i].x == (P[a].x + P[c].x - P[b].x) && P[i].y == (P[a].y + P[c].y - P[b].y)) { return true; break; }
			}
		}
		else {
			for (int i = 1; i <= n; i++) {
				if (P[i].x == (P[a].x + P[b].x - P[c].x) && P[i].y == (P[a].y + P[b].y - P[c].y)) { return true; break; }
			}
		}
		return false;
	}
	else return false;
}

/*double getDis(point &p)
{
	double ans = 1e20;
	double step = 100.0;
	double dm;
	p = point(0, 0);
	while (step > eps)
	{
		int now = q[1];
		dm = dist(p, P[now]);
		for (int i = 2; i <= 3; i++)
		{
			double t = dist(p, P[q[i]]);
			if (t > dm)
			{
				dm = t;
				now =q[i];
			}
		}
		ans = min(ans, dm);
		p.x += (P[now].x - p.x) / dm*step;
		p.y += (P[now].y - p.y) / dm*step;
		step *= 0.98;
	}
	return ans;
}*/
void Compute()
{
	double Max = -1;
	for (int i = 1; i <= n; i++)
	{
		for (int j = i + 1; j <= n; j++)
		{
			for (int k = j + 1; k <= n; k++)
			{
				if (JudgeRet(i, j, k))
				{
					point center = Cir(P[i], P[j], P[k]);
					double r = dist(center, P[i]);
					//double temp = getDis(p);
					bool ret = true;
					for (int i = 1; i <= n; i++)
					{
						if (dist(center, P[i]) < r) {
							ret = false; break;
						}
					}
					if(ret) Max = max(Max, r);
				}
			}
		}
	}
	if (Max == -1) printf("-1\n");
	else printf("%.6f\n", Max);
}
int main()
{
	double x, y;
	while (~scanf("%d", &n))
	{
		for (int i = 1; i <= n; i++)
		{
			scanf("%lf%lf", &x, &y);
			P[i] = point(x, y);
		}
		Compute();
	}
	return 0;
}


#pragma warning(disable:4996)
#include <iostream>
#include <cstdio>
#include <vector>
#include <map>
#include <algorithm>
#include <cmath>
#include <sstream>
#include <set>
#include <queue>
#include <cstring>
#include <string>
#include <ctime>
#include <cstdlib>
using namespace std;
typedef long long int64;
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
inline double sqr(double x)
{
	return x*x;
}
int cmp(double x)
{
	if (fabs(x)<eps) return 0;
	if (x>0) return 1;
	return -1;
}
int n;
struct point
{
	double x, y;
	point() {}
	point(double a, double b) :x(a), y(b) {}
	void input()
	{
		scanf("%lf%lf", &x, &y);
	}
	friend point operator +(const point &a, const point &b)
	{
		return point(a.x + b.x, a.y + b.y);
	}
	friend point operator -(const point &a, const point &b)
	{
		return point(a.x - b.x, a.y - b.y);
	}
	friend bool operator == (const point &a, const point &b)
	{
		return cmp(a.x - b.x) == 0 && cmp(a.y - b.y) == 0;
	}
	friend point operator * (const point &a, const double &b)
	{
		return point(a.x*b, a.y*b);
	}
	friend point operator * (const double &a, const point &b)
	{
		return point(a*b.x, a*b.y);
	}
	friend point operator /(const point &a, const double &b)
	{
		return point(a.x / b, a.y / b);
	}
	double norm()                       //x*x+y*y
	{
		return sqrt(sqr(x) + sqr(y));
	}
	double norm1()                       //x*x+y*y
	{
		return sqr(x) + sqr(y);
	}
}P[200];
double det(const point &a, const point &b)
{
	return a.x*b.y - a.y*b.x;
}
point Cir(point a, point b, point c)
{
	point cp;
	double a1 = b.x - a.x, b1 = b.y - a.y, c1 = (a1*a1 + b1*b1) / 2;
	double a2 = c.x - a.x, b2 = c.y - a.y, c2 = (a2*a2 + b2*b2) / 2;
	double d = a1*b2 - a2*b1;
	cp.x = a.x + (c1*b2 - c2*b1) / d;
	cp.y = a.y + (a1*c2 - a2*c1) / d;
	return cp;
}
double dot(const point &a, const point &b)
{
	return a.x*b.y + a.y*b.x;
}
double dist(const point &a, const point &b)
{
	return (a - b).norm();
}
double dist2(const point &a, const point &b)
{
	return (a - b).norm1();
}
bool JudgeRet(int a, int b, int c)
{
	double dis1 = dist2(P[a], P[b]);
	double dis2 = dist2(P[a], P[c]);
	double dis3 = dist2(P[b], P[c]);
	if ((cmp(dis1+dis2-dis3)==1)&&(cmp(dis2+dis3-dis1)==1)&&(cmp(dis1+dis3-dis2)==1))
		return true;
	else if (cmp(dis1 + dis2 - dis3)==0 || cmp(dis1 + dis3 - dis2)==0 || cmp(dis2 + dis3 - dis1)==0)
	{
		if (cmp(dis1 + dis2 - dis3)==0)
		{
			for (int i = 1; i <= n; i++) {
				if (cmp(P[i].x - (P[b].x + P[c].x - P[a].x))==0 && cmp(P[i].y - (P[b].y + P[c].y - P[a].y))==0) { return true; }
			}
		}
		else if (cmp(dis1 + dis3 - dis2)==0)
		{
			for (int i = 1; i <= n; i++) {
				if (cmp(P[i].x - (P[a].x + P[c].x - P[b].x))==0 && cmp(P[i].y - (P[a].y + P[c].y - P[b].y))==0) { return true; }
			}
		}
		else {
			for (int i = 1; i <= n; i++) {
				if (cmp(P[i].x - (P[a].x + P[b].x - P[c].x))==0 && cmp(P[i].y - (P[a].y + P[b].y - P[c].y))==0) {
					return true; }
			}
		}
		return false;
	}
	else return false;
}
void Compute()
{
	double Max = -1;
	JudgeRet(2, 3, 5);
	for (int i = 1; i <= n; i++)
	{
		for (int j = i + 1; j <= n; j++)
		{
			for (int k = j + 1; k <= n; k++)
			{
				if (JudgeRet(i, j, k))
				{
					point center = Cir(P[i], P[j], P[k]);
					double r = dist(center, P[i]);
					//double temp = getDis(p);
					bool ret = true;
					for (int i = 1; i <= n; i++)
					{
						if (cmp(dist(center, P[i]) - r)==-1) {
							ret = false; break;
						}
					}
					if(ret)
						Max = max(Max, r);
				}
			}
		}
	}
	if (Max == -1) printf("-1\n");
	else printf("%.6f\n", Max);
}
int main()
{
	double x, y;
	while (~scanf("%d", &n))
	{
		for (int i = 1; i <= n; i++)
		{
			scanf("%lf%lf", &x, &y);
			P[i] = point(x, y);
		}
		Compute();
	}
	return 0;
}


#pragma warning(disable:4996)
#include <iostream>
#include <cstdio>
#include <vector>
#include <map>
#include <algorithm>
#include <cmath>
#include <sstream>
#include <set>
#include <queue>
#include <cstring>
#include <string>
#include <ctime>
#include <cstdlib>
using namespace std;
typedef long long int64;
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
inline double sqr(double x)
{
	return x*x;
}
int cmp(double x)
{
	if (fabs(x)<eps) return 0;
	if (x>0) return 1;
	return -1;
}
int n;
struct point
{
	double x, y;
	point() {}
	point(double a, double b) :x(a), y(b) {}
	void input()
	{
		scanf("%lf%lf", &x, &y);
	}
	friend point operator +(const point &a, const point &b)
	{
		return point(a.x + b.x, a.y + b.y);
	}
	friend point operator -(const point &a, const point &b)
	{
		return point(a.x - b.x, a.y - b.y);
	}
	friend bool operator == (const point &a, const point &b)
	{
		return cmp(a.x - b.x) == 0 && cmp(a.y - b.y) == 0;
	}
	friend point operator * (const point &a, const double &b)
	{
		return point(a.x*b, a.y*b);
	}
	friend point operator * (const double &a, const point &b)
	{
		return point(a*b.x, a*b.y);
	}
	friend point operator /(const point &a, const double &b)
	{
		return point(a.x / b, a.y / b);
	}
	double norm()                       //x*x+y*y
	{
		return sqrt(sqr(x) + sqr(y));
	}
	double norm1()                       //x*x+y*y
	{
		return sqr(x) + sqr(y);
	}
}P[200];
double det(const point &a, const point &b)
{
	return a.x*b.y - a.y*b.x;
}
point Cir(point a, point b, point c)
{
	point cp;
	double a1 = b.x - a.x, b1 = b.y - a.y, c1 = (a1*a1 + b1*b1) / 2;
	double a2 = c.x - a.x, b2 = c.y - a.y, c2 = (a2*a2 + b2*b2) / 2;
	double d = a1*b2 - a2*b1;
	cp.x = a.x + (c1*b2 - c2*b1) / d;
	cp.y = a.y + (a1*c2 - a2*c1) / d;
	return cp;
}
double dot(const point &a, const point &b)
{
	return a.x*b.y + a.y*b.x;
}
double dist(const point &a, const point &b)
{
	return (a - b).norm();
}
double dist2(const point &a, const point &b)
{
	return (a - b).norm1();
}
bool JudgeRet(int a, int b, int c)
{
	double dis1 = dist2(P[a], P[b]);
	double dis2 = dist2(P[a], P[c]);
	double dis3 = dist2(P[b], P[c]);
	if ((cmp(dis1+dis2-dis3)==1)&&(cmp(dis2+dis3-dis1)==1)&&(cmp(dis1+dis3-dis2)==1))
		return true;
	else if (cmp(dis1 + dis2 - dis3)==0 || cmp(dis1 + dis3 - dis2)==0 || cmp(dis2 + dis3 - dis1)==0)
	{
		if (cmp(dis1 + dis2 - dis3)==0)
		{
			for (int i = 1; i <= n; i++) {
				if (cmp(P[i].x - (P[b].x + P[c].x - P[a].x))==0 && cmp(P[i].y - (P[b].y + P[c].y - P[a].y))==0) { return true; }
			}
		}
		else if (cmp(dis1 + dis3 - dis2)==0)
		{
			for (int i = 1; i <= n; i++) {
				if (cmp(P[i].x - (P[a].x + P[c].x - P[b].x))==0 && cmp(P[i].y - (P[a].y + P[c].y - P[b].y))==0) { return true; }
			}
		}
		else {
			for (int i = 1; i <= n; i++) {
				if (cmp(P[i].x - (P[a].x + P[b].x - P[c].x))==0 && cmp(P[i].y == (P[a].y + P[b].y - P[c].y))==0) { return true; }
			}
		}
		return false;
	}
	else return false;
}
void Compute()
{
	double Max = -1;
	for (int i = 1; i <= n; i++)
	{
		for (int j = i + 1; j <= n; j++)
		{
			for (int k = j + 1; k <= n; k++)
			{
				if (JudgeRet(i, j, k))
				{
					point center = Cir(P[i], P[j], P[k]);
					double r = dist(center, P[i]);
					//double temp = getDis(p);
					bool ret = true;
					for (int i = 1; i <= n; i++)
					{
						if (cmp(dist(center, P[i]) - r)==-1) {
							ret = false; break;
						}
					}
					if(ret) Max = max(Max, r);
				}
			}
		}
	}
	if (Max == -1) printf("-1\n");
	else printf("%.6f\n", Max);
}
int main()
{
	double x, y;
	while (~scanf("%d", &n))
	{
		for (int i = 1; i <= n; i++)
		{
			scanf("%lf%lf", &x, &y);
			P[i] = point(x, y);
		}
		Compute();
	}
	return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

struct point {
  double x, y;
  point() {
    x = y = 0;
  }
  point(double x, double y) : x(x), y(y) {}
  void read() {
    cin >> x >> y;
  }
};

double dist(const point& a, const point& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

point operator + (const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}

point operator - (const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}

point operator * (const point& a, double x) {
  return point(a.x * x, a.y * x);
}

point operator * (double x, const point& a) {
  return a * x;
}

point operator / (const point& a, double x) {
  return point(a.x / x, a.y / x);
}

struct line {
  double a, b, c;
  line(point x, point y) {
    a = x.y - y.y;
    b = y.x - x.x;
    c = x.x * y.y - x.y * y.x;
  }

  line(double nx, double ny, point x) {
    b = -nx;
    a = ny;
    c = -a * x.x - b * x.y;
  }
};

point intersect(line a, line b) {
  double d = a.a * b.b - a.b * b.a;
  double d1 = -a.c * b.b + a.b * b.c;
  double d2 = -a.a * b.c + a.c * b.a;

  return point(d1 / d, d2 / d);
}

point circumc(point a, point b, point c) {
  line x(a, b);
  line midab = line(x.a, x.b, (a + b) / 2.);
  line y(b, c);
  line midbc = line(y.a, y.b, (b + c) / 2.);
  return intersect(midab, midbc);
}

const int maxN = 110;

int n;
point a[maxN];

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  cin >> n;
  for (int i = 0; i < n; ++i) {
    a[i].read();
  }

  double res = 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 A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);

        if (A * A + B * B < C * C - 1e-9) continue;
        if (A * A + C * C < B * B - 1e-9) continue;
        if (B * B + C * C < A * A - 1e-9) continue;

        point cand = circumc(a[i], a[j], a[k]);
        double cd = 1e10;
        for (int l = 0; l < n; ++l) {
          cd = min(cd, dist(a[l], cand));
        }
        res = max(res, cd);
      }
    }
  }

  if (res < 1e-9) {
    printf("-1\n");
    return 0;
  }
  printf("%.10lf\n", res);
  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-9;

struct point {
  double x, y;
  point() {
    x = y = 0;
  }
  point(double x, double y) : x(x), y(y) {}
  void read() {
    cin >> x >> y;
  }

  bool operator == (const point& other) const {
    return fabs(x - other.x) < eps && fabs(y - other.y) < eps;
  }
};

double dist(const point& a, const point& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

point operator + (const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}

point operator - (const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}

point operator * (const point& a, double x) {
  return point(a.x * x, a.y * x);
}

point operator * (double x, const point& a) {
  return a * x;
}

point operator / (const point& a, double x) {
  return point(a.x / x, a.y / x);
}

struct line {
  double a, b, c;
  line(point x, point y) {
    a = x.y - y.y;
    b = y.x - x.x;
    c = x.x * y.y - x.y * y.x;
  }

  line(double nx, double ny, point x) {
    b = -nx;
    a = ny;
    c = -a * x.x - b * x.y;
  }
};

point intersect(line a, line b) {
  double d = a.a * b.b - a.b * b.a;
  double d1 = -a.c * b.b + a.b * b.c;
  double d2 = -a.a * b.c + a.c * b.a;

  return point(d1 / d, d2 / d);
}

point circumc(point a, point b, point c) {
  line x(a, b);
  line midab = line(x.a, x.b, (a + b) / 2.);
  line y(b, c);
  line midbc = line(y.a, y.b, (b + c) / 2.);
  return intersect(midab, midbc);
}

const int maxN = 110;

int n;
point a[maxN];

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  cin >> n;
  for (int i = 0; i < n; ++i) {
    a[i].read();
  }

  double res = 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 A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);

        if (A * A + B * B < C * C + 1e-9) continue;
        if (A * A + C * C < B * B + 1e-9) continue;
        if (B * B + C * C < A * A + 1e-9) continue;

        point cand = circumc(a[i], a[j], a[k]);
        double cd = 1e10;
        for (int l = 0; l < n; ++l) {
          cd = min(cd, dist(a[l], cand));
        }
        res = max(res, cd);
      }
    }
  }

  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      for (int k = j + 1; k < n; ++k) {
        double A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);
        if (fabs(A * A + B * B - C * C) < eps ||
            fabs(A * A + C * C - B * B) < eps ||
            fabs(B * B + C * C - A * A) < eps) {
          if (fabs(A - B) < eps || fabs(A - C) < eps || fabs(B - C) < eps) {
            point d;
            if (fabs(C - B) < eps) {
              point buf = (a[i] + a[j]) / 2. - a[k];
              d = a[k] + 2. * buf;
            } else if (fabs(A - C) < eps) {
              point buf = (a[j] + a[k]) / 2. - a[i];
              d = a[i] + 2. * buf;
            } else {
              point buf = (a[i] + a[k]) / 2. - a[j];
              d = a[j] + 2. * buf;
            }

            int ok = false;
            for (int l = 0; l < n; ++l) {
              if (d == a[l]) {
                ok = true;
                break;
              }
            }
            if (ok) {
              point cand = circumc(a[i], a[j], a[k]);
              double cd = 1e10;
              for (int l = 0; l < n; ++l) {
                cd = min(cd, dist(a[l], cand));
              }
              res = max(res, cd);
            }
          }
        }
      }
    }
  }

  if (res < 1e-9) {
    printf("-1\n");
    return 0;
  }
  printf("%.10lf\n", res);
  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-9;

struct point {
  double x, y;
  point() {
    x = y = 0;
  }
  point(double x, double y) : x(x), y(y) {}
  void read() {
    cin >> x >> y;
  }

  bool operator == (const point& other) const {
    return fabs(x - other.x) < eps && fabs(y - other.y) < eps;
  }
};

double dist(const point& a, const point& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

point operator + (const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}

point operator - (const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}

point operator * (const point& a, double x) {
  return point(a.x * x, a.y * x);
}

point operator * (double x, const point& a) {
  return a * x;
}

point operator / (const point& a, double x) {
  return point(a.x / x, a.y / x);
}

struct line {
  double a, b, c;
  line(point x, point y) {
    a = x.y - y.y;
    b = y.x - x.x;
    c = x.x * y.y - x.y * y.x;
  }

  line(double nx, double ny, point x) {
    b = -nx;
    a = ny;
    c = -a * x.x - b * x.y;
  }
};

point intersect(line a, line b) {
  double d = a.a * b.b - a.b * b.a;
  double d1 = -a.c * b.b + a.b * b.c;
  double d2 = -a.a * b.c + a.c * b.a;
  if (fabs(d) < eps) return point(-1e10, -1e10);

  return point(d1 / d, d2 / d);
}

point circumc(point a, point b, point c) {
  line x(a, b);
  line midab = line(x.a, x.b, (a + b) / 2.);
  line y(b, c);
  line midbc = line(y.a, y.b, (b + c) / 2.);
  return intersect(midab, midbc);
}

const int maxN = 110;

int n;
point a[maxN];

bool is_in(point a, point b, point c) {
  return fabs(dist(a, b) - dist(a, c) - dist(b, c)) < eps;
}

bool is_good(int x, int y, int z) {
  double A = dist(a[x], a[y]);
  double B = dist(a[x], a[z]);
  double C = dist(a[y], a[z]);

  return fabs(A * A + B * B - C * C) < eps ||
         fabs(A * A + C * C - B * B) < eps ||
         fabs(B * B + C * C - A * A) < eps;
}

bool cmp (point a, point b) {
	return a.x < b.x || a.x == b.x && a.y < b.y;
}

bool cw (point a, point b, point c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) < 0;
}

bool ccw (point a, point b, point c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) > 0;
}

void convex_hull (vector<point> & a) {
	if (a.size() == 1)  return;
	sort (a.begin(), a.end(), &cmp);
	point p1 = a[0],  p2 = a.back();
	vector<point> up, down;
	up.push_back (p1);
	down.push_back (p1);
	for (size_t i=1; i<a.size(); ++i) {
		if (i==a.size()-1 || cw (p1, a[i], p2)) {
			while (up.size()>=2 && !cw (up[up.size()-2], up[up.size()-1], a[i]))
				up.pop_back();
			up.push_back (a[i]);
		}
		if (i==a.size()-1 || ccw (p1, a[i], p2)) {
			while (down.size()>=2 && !ccw (down[down.size()-2], down[down.size()-1], a[i]))
				down.pop_back();
			down.push_back (a[i]);
		}
	}
	a.clear();
	for (size_t i=0; i<up.size(); ++i)
		a.push_back (up[i]);
	for (size_t i=down.size()-2; i>0; --i)
		a.push_back (down[i]);
}

bool is_good(vector<point>& v, point x) {
  v.push_back(v[0]);
  for (int i = 0; i + 1 < v.size(); ++i) {
    if (is_in(v[i], v[i + 1], x)) {
      v.pop_back();
      return false;
    }
  }
  v.pop_back();
  return true;
}

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  cin >> n;
  vector <point> v;
  for (int i = 0; i < n; ++i) {
    a[i].read();
    v.push_back(a[i]);
  }

  convex_hull(v);

  double res = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      for (int k = j + 1; k < n; ++k) {
        if (a[i] == a[j]) continue;
        if (a[i] == a[k]) continue;
        if (a[j] == a[k]) continue;
        double A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);

        if (A * A + B * B < C * C - eps) continue;
        if (A * A + C * C < B * B - eps) continue;
        if (B * B + C * C < A * A - eps) continue;

        point cand = circumc(a[i], a[j], a[k]);
        double cdist = dist(a[i], cand);
        if (!is_good(v, cand)) continue;
        double cd = 1e10;
        for (int l = 0; l < n; ++l) {
          if (dist(a[l], cand) < cdist - eps) {
            cd = -1;
            break;
          }
          cd = min(cd, dist(a[l], cand));
        }
        res = max(res, cd);
      }
    }
  }

  if (res < eps) {
    printf("-1\n");
    return 0;
  }
  printf("%.10lf\n", res);
  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-9;

struct point {
  double x, y;
  point() {
    x = y = 0;
  }
  point(double x, double y) : x(x), y(y) {}
  void read() {
    cin >> x >> y;
  }

  bool operator == (const point& other) const {
    return fabs(x - other.x) < eps && fabs(y - other.y) < eps;
  }
};

double dist(const point& a, const point& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

point operator + (const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}

point operator - (const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}

point operator * (const point& a, double x) {
  return point(a.x * x, a.y * x);
}

point operator * (double x, const point& a) {
  return a * x;
}

point operator / (const point& a, double x) {
  return point(a.x / x, a.y / x);
}

struct line {
  double a, b, c;
  line(point x, point y) {
    a = x.y - y.y;
    b = y.x - x.x;
    c = x.x * y.y - x.y * y.x;
  }

  line(double nx, double ny, point x) {
    b = -nx;
    a = ny;
    c = -a * x.x - b * x.y;
  }
};

point intersect(line a, line b) {
  double d = a.a * b.b - a.b * b.a;
  double d1 = -a.c * b.b + a.b * b.c;
  double d2 = -a.a * b.c + a.c * b.a;
  if (fabs(d) < eps) return point(-1e10, -1e10);

  return point(d1 / d, d2 / d);
}

point circumc(point a, point b, point c) {
  line x(a, b);
  line midab = line(x.a, x.b, (a + b) / 2.);
  line y(b, c);
  line midbc = line(y.a, y.b, (b + c) / 2.);
  return intersect(midab, midbc);
}

const int maxN = 110;

int n;
point a[maxN];

bool is_in(point a, point b, point c) {
  return fabs(dist(a, b) - dist(a, c) - dist(b, c)) < eps;
}

bool is_good(int x, int y, int z) {
  double A = dist(a[x], a[y]);
  double B = dist(a[x], a[z]);
  double C = dist(a[y], a[z]);

  return fabs(A * A + B * B - C * C) < eps ||
         fabs(A * A + C * C - B * B) < eps ||
         fabs(B * B + C * C - A * A) < eps;
}

bool cmp (point a, point b) {
	return a.x < b.x || a.x == b.x && a.y < b.y;
}

bool cw (point a, point b, point c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) < 0;
}

bool ccw (point a, point b, point c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) > 0;
}

void convex_hull (vector<point> & a) {
	if (a.size() == 1)  return;
	sort (a.begin(), a.end(), &cmp);
	point p1 = a[0],  p2 = a.back();
	vector<point> up, down;
	up.push_back (p1);
	down.push_back (p1);
	for (size_t i=1; i<a.size(); ++i) {
		if (i==a.size()-1 || cw (p1, a[i], p2)) {
			while (up.size()>=2 && !cw (up[up.size()-2], up[up.size()-1], a[i]))
				up.pop_back();
			up.push_back (a[i]);
		}
		if (i==a.size()-1 || ccw (p1, a[i], p2)) {
			while (down.size()>=2 && !ccw (down[down.size()-2], down[down.size()-1], a[i]))
				down.pop_back();
			down.push_back (a[i]);
		}
	}
	a.clear();
	for (size_t i=0; i<up.size(); ++i)
		a.push_back (up[i]);
	for (size_t i=down.size()-2; i>0; --i)
		a.push_back (down[i]);
}

bool is_good(vector<point>& v, point x) {
  v.push_back(v[0]);
  for (int i = 0; i + 1 < v.size(); ++i) {
    if (is_in(v[i], v[i + 1], x)) {
      v.pop_back();
      return false;
    }
  }
  v.pop_back();
  return true;
}

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  cin >> n;
  vector <point> v;
  for (int i = 0; i < n; ++i) {
    a[i].read();
    v.push_back(a[i]);
  }

  convex_hull(v);

  double res = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      for (int k = j + 1; k < n; ++k) {
        if (a[i] == a[j]) continue;
        if (a[i] == a[k]) continue;
        if (a[j] == a[k]) continue;
        double A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);

        if (A * A + B * B < C * C - eps) continue;
        if (A * A + C * C < B * B - eps) continue;
        if (B * B + C * C < A * A - eps) continue;

        point cand = circumc(a[i], a[j], a[k]);
        if (cand.x < -1e8) continue;
        if (!is_good(v, cand)) continue;
        double cd = 1e10;
        for (int l = 0; l < n; ++l) {
          cd = min(cd, dist(a[l], cand));
        }
        res = max(res, cd);
      }
    }
  }

  if (res < eps) {
    printf("-1\n");
    return 0;
  }
  printf("%.10lf\n", res);
  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-9;

struct point {
  long long x, y;
  point() {
  }
  point(long long x, long long y) :x(x), y(y) {}

  void read() {
    cin >> x >> y;
  }
};

struct dpoint {
  double x, y;
  dpoint() {
  }
  dpoint(double x, double y) : x(x), y(y) {}
};

double dist(dpoint a, dpoint b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

double is_in(dpoint a, dpoint b, dpoint c) {
  return fabs(dist(a, b) - dist(a, c) - dist(b, c)) < eps;
}

const int maxN = 110;

point x[maxN];
int n;
int used[maxN][maxN];

double get(dpoint a, dpoint b, dpoint c) {
  if (is_in(a, b, c)) return dist(a, c);
  if (dist(a, c) < dist(b, c)) return 0;
  return dist(a, b);
}

bool check(double t) {
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      if (used[i][j]) {
        dpoint a = dpoint(x[i].x, x[i].y);
        dpoint b = dpoint(x[j].x, x[j].y);
        double d = dist(a, b);
        if (2 * t > d) continue;

        vector <pair<double, double> > segs;

        double A = a.y - b.y;
        double B = b.x - a.x;
        double C = a.x * b.y - a.y * b.x;
        double sq = sqrt(A * A + B * B);

        double dx = -B / sq;
        double dy = A / sq;
        for (int k = 0; k < n; ++k) {
          double d = (A * x[k].x + B * x[k].y + C) / sq;
          if (d > t) continue;
          double nx = x[k].x - d * A / sq;
          double ny = x[k].y - d * B / sq;

          double len = sqrt(t * t - d * d);
          dpoint p1 = dpoint(nx + dx * len, ny + dy * len);
          dpoint p2 = dpoint(nx - dx * len, ny - dy * len);
          double g1 = get(a, b, p1);
          double g2 = get(a, b, p2);
          segs.push_back(make_pair(g1, g2));
        }

        if (segs.size() == 0) return true;
        sort(segs.begin(), segs.end());
        double cr = segs[0].second;
        for (int k = 1; k < segs.size(); ++k) {
          if (segs[k].first > cr + eps) {
            return true;
          }
          cr = max(cr, segs[k].second);
        }
      }
    }
  }
  return false;
}

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  scanf("%d", &n);
  for (int i = 0; i < n; ++i) {
    x[i].read();
  }

  int fnd = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      long long A = x[i].y - x[j].y;
      long long B = x[j].x - x[i].x;
      long long C = x[i].x * x[j].y - x[i].y * x[j].x;

      long long mx = -1;
      long long mn = 1;
      for (int k = 0; k < n; ++k) {
        long long val = A * x[k].x + B * x[k].y + C;
        if (val > 0) mx = max(mx, val);
        if (val < 0) mn = min(mn, val);
      }
      if (mx > 0 && mn < 0) {
        used[i][j] = used[j][i] = true;
        fnd = 1;
      }
    }
  }

  if (!fnd) {
    printf("-1\n");
    return 0;
  }

  double l = 0, r = 1e6;

  for (int i = 0; i < 50; ++i) {
    double key = (l + r) / 2;
    if (check(key)) {
      l = key;
    } else {
      r = key;
    }
  }

  printf("%.10lf\n", (l + r) / 2.);

  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-9;

struct point {
  double x, y;
  point() {
    x = y = 0;
  }
  point(double x, double y) : x(x), y(y) {}
  void read() {
    cin >> x >> y;
  }

  bool operator == (const point& other) const {
    return fabs(x - other.x) < eps && fabs(y - other.y) < eps;
  }
};

double dist(const point& a, const point& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

point operator + (const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}

point operator - (const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}

point operator * (const point& a, double x) {
  return point(a.x * x, a.y * x);
}

point operator * (double x, const point& a) {
  return a * x;
}

point operator / (const point& a, double x) {
  return point(a.x / x, a.y / x);
}

struct line {
  double a, b, c;
  line(point x, point y) {
    a = x.y - y.y;
    b = y.x - x.x;
    c = x.x * y.y - x.y * y.x;
  }

  line(double nx, double ny, point x) {
    b = -nx;
    a = ny;
    c = -a * x.x - b * x.y;
  }
};

point intersect(line a, line b) {
  double d = a.a * b.b - a.b * b.a;
  double d1 = -a.c * b.b + a.b * b.c;
  double d2 = -a.a * b.c + a.c * b.a;

  return point(d1 / d, d2 / d);
}

point circumc(point a, point b, point c) {
  line x(a, b);
  line midab = line(x.a, x.b, (a + b) / 2.);
  line y(b, c);
  line midbc = line(y.a, y.b, (b + c) / 2.);
  return intersect(midab, midbc);
}

const int maxN = 110;

int n;
point a[maxN];

bool is_in(point a, point b, point c) {
  return fabs(dist(a, b) - dist(a, c) - dist(b, c)) < eps;
}

bool is_good(int x, int y, int z) {
  double A = dist(a[x], a[y]);
  double B = dist(a[x], a[z]);
  double C = dist(a[y], a[z]);

  return fabs(A * A + B * B - C * C) < eps ||
         fabs(A * A + C * C - B * B) < eps ||
         fabs(B * B + C * C - A * A) < eps;
}

bool cmp (point a, point b) {
	return a.x < b.x || a.x == b.x && a.y < b.y;
}

bool cw (point a, point b, point c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) < 0;
}

bool ccw (point a, point b, point c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) > 0;
}

void convex_hull (vector<point> & a) {
	if (a.size() == 1)  return;
	sort (a.begin(), a.end(), &cmp);
	point p1 = a[0],  p2 = a.back();
	vector<point> up, down;
	up.push_back (p1);
	down.push_back (p1);
	for (size_t i=1; i<a.size(); ++i) {
		if (i==a.size()-1 || cw (p1, a[i], p2)) {
			while (up.size()>=2 && !cw (up[up.size()-2], up[up.size()-1], a[i]))
				up.pop_back();
			up.push_back (a[i]);
		}
		if (i==a.size()-1 || ccw (p1, a[i], p2)) {
			while (down.size()>=2 && !ccw (down[down.size()-2], down[down.size()-1], a[i]))
				down.pop_back();
			down.push_back (a[i]);
		}
	}
	a.clear();
	for (size_t i=0; i<up.size(); ++i)
		a.push_back (up[i]);
	for (size_t i=down.size()-2; i>0; --i)
		a.push_back (down[i]);
}

bool is_good(vector<point>& v, point x) {
  v.push_back(v[0]);
  for (int i = 0; i + 1 < v.size(); ++i) {
    if (is_in(v[i], v[i + 1], x)) {
      v.pop_back();
      return false;
    }
  }
  v.pop_back();
  return true;
}

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  cin >> n;
  vector <point> v;
  for (int i = 0; i < n; ++i) {
    a[i].read();
    v.push_back(a[i]);
  }

  convex_hull(v);

  double res = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      for (int k = j + 1; k < n; ++k) {
        if (a[i] == a[j]) continue;
        if (a[i] == a[k]) continue;
        if (a[j] == a[k]) continue;
        double A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);

        if (A * A + B * B < C * C - eps) continue;
        if (A * A + C * C < B * B - eps) continue;
        if (B * B + C * C < A * A - eps) continue;

        point cand = circumc(a[i], a[j], a[k]);
        if (!is_good(v, cand)) continue;
        double cd = 1e10;
        for (int l = 0; l < n; ++l) {
          cd = min(cd, dist(a[l], cand));
        }
        res = max(res, cd);
      }
    }
  }

  if (res < eps) {
    printf("-1\n");
    return 0;
  }
  printf("%.10lf\n", res);
  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-9;

struct point {
  double x, y;
  point() {
    x = y = 0;
  }
  point(double x, double y) : x(x), y(y) {}
  void read() {
    cin >> x >> y;
  }

  bool operator == (const point& other) const {
    return fabs(x - other.x) < eps && fabs(y - other.y) < eps;
  }
};

double dist(const point& a, const point& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

point operator + (const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}

point operator - (const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}

point operator * (const point& a, double x) {
  return point(a.x * x, a.y * x);
}

point operator * (double x, const point& a) {
  return a * x;
}

point operator / (const point& a, double x) {
  return point(a.x / x, a.y / x);
}

struct line {
  double a, b, c;
  line(point x, point y) {
    a = x.y - y.y;
    b = y.x - x.x;
    c = x.x * y.y - x.y * y.x;
  }

  line(double nx, double ny, point x) {
    b = -nx;
    a = ny;
    c = -a * x.x - b * x.y;
  }
};

point intersect(line a, line b) {
  double d = a.a * b.b - a.b * b.a;
  double d1 = -a.c * b.b + a.b * b.c;
  double d2 = -a.a * b.c + a.c * b.a;
  if (fabs(d) < eps) return point(-1e10, -1e10);

  return point(d1 / d, d2 / d);
}

point circumc(point a, point b, point c) {
  line x(a, b);
  line midab = line(x.a, x.b, (a + b) / 2.);
  line y(b, c);
  line midbc = line(y.a, y.b, (b + c) / 2.);
  return intersect(midab, midbc);
}

const int maxN = 110;

int n;
point a[maxN];

bool is_in(point a, point b, point c) {
  return fabs(dist(a, b) - dist(a, c) - dist(b, c)) < eps;
}

bool is_good(int x, int y, int z) {
  double A = dist(a[x], a[y]);
  double B = dist(a[x], a[z]);
  double C = dist(a[y], a[z]);

  return fabs(A * A + B * B - C * C) < eps ||
         fabs(A * A + C * C - B * B) < eps ||
         fabs(B * B + C * C - A * A) < eps;
}

bool cmp (point a, point b) {
	return a.x < b.x || a.x == b.x && a.y < b.y;
}

bool cw (point a, point b, point c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) < 0;
}

bool ccw (point a, point b, point c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) > 0;
}

void convex_hull (vector<point> & a) {
	if (a.size() == 1)  return;
	sort (a.begin(), a.end(), &cmp);
	point p1 = a[0],  p2 = a.back();
	vector<point> up, down;
	up.push_back (p1);
	down.push_back (p1);
	for (size_t i=1; i<a.size(); ++i) {
		if (i==a.size()-1 || cw (p1, a[i], p2)) {
			while (up.size()>=2 && !cw (up[up.size()-2], up[up.size()-1], a[i]))
				up.pop_back();
			up.push_back (a[i]);
		}
		if (i==a.size()-1 || ccw (p1, a[i], p2)) {
			while (down.size()>=2 && !ccw (down[down.size()-2], down[down.size()-1], a[i]))
				down.pop_back();
			down.push_back (a[i]);
		}
	}
	a.clear();
	for (size_t i=0; i<up.size(); ++i)
		a.push_back (up[i]);
	for (size_t i=down.size()-2; i>0; --i)
		a.push_back (down[i]);
}

bool is_good(vector<point>& v, point x) {
  v.push_back(v[0]);
  for (int i = 0; i + 1 < v.size(); ++i) {
    if (is_in(v[i], v[i + 1], x)) {
      v.pop_back();
      return false;
    }
  }
  v.pop_back();
  return true;
}

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  cin >> n;
  vector <point> v;
  for (int i = 0; i < n; ++i) {
    a[i].read();
    v.push_back(a[i]);
  }

  convex_hull(v);

  double res = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      for (int k = j + 1; k < n; ++k) {
        if (a[i] == a[j]) continue;
        if (a[i] == a[k]) continue;
        if (a[j] == a[k]) continue;
        double A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);
        if (is_good(i, j, k)) continue;

        if (A * A + B * B < C * C - eps) continue;
        if (A * A + C * C < B * B - eps) continue;
        if (B * B + C * C < A * A - eps) continue;

        point cand = circumc(a[i], a[j], a[k]);
        if (cand.x < -1e8) continue;
        if (!is_good(v, cand)) continue;
        double cd = 1e10;
        for (int l = 0; l < n; ++l) {
          cd = min(cd, dist(a[l], cand));
        }
        res = max(res, cd);
      }
    }
  }

  if (res < eps) {
    for (int i = 0; i < n; ++i) {
      for (int j = i + 1; j < n; ++j) {
        for (int k = j + 1; k < n; ++k) {
          if (a[i] == a[j]) continue;
          if (a[i] == a[k]) continue;
          if (a[j] == a[k]) continue;
          double A = dist(a[i], a[j]);
          double B = dist(a[j], a[k]);
          double C = dist(a[k], a[i]);
          if (!is_good(i, j, k)) continue;

          if (A * A + B * B < C * C - eps) continue;
          if (A * A + C * C < B * B - eps) continue;
          if (B * B + C * C < A * A - eps) continue;

          point cand = circumc(a[i], a[j], a[k]);
          if (cand.x < -1e8) continue;
          if (!is_good(v, cand)) continue;
          double cd = 1e10;
          for (int l = 0; l < n; ++l) {
            cd = min(cd, dist(a[l], cand));
          }
          res = max(res, cd);
        }
      }
    }
  }
  if (res < eps) {
    printf("-1\n");
    return 0;
  }
  printf("%.10lf\n", res);
  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-6;

struct point {
  double x, y;
  point() {
    x = y = 0;
  }
  point(double x, double y) : x(x), y(y) {}
  void read() {
    cin >> x >> y;
  }

  bool operator == (const point& other) const {
    return fabs(x - other.x) < eps && fabs(y - other.y) < eps;
  }
};

double dist(const point& a, const point& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

point operator + (const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}

point operator - (const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}

point operator * (const point& a, double x) {
  return point(a.x * x, a.y * x);
}

point operator * (double x, const point& a) {
  return a * x;
}

point operator / (const point& a, double x) {
  return point(a.x / x, a.y / x);
}

struct line {
  double a, b, c;
  line(point x, point y) {
    a = x.y - y.y;
    b = y.x - x.x;
    c = x.x * y.y - x.y * y.x;
  }

  line(double nx, double ny, point x) {
    b = -nx;
    a = ny;
    c = -a * x.x - b * x.y;
  }
};

point intersect(line a, line b) {
  double d = a.a * b.b - a.b * b.a;
  double d1 = -a.c * b.b + a.b * b.c;
  double d2 = -a.a * b.c + a.c * b.a;

  return point(d1 / d, d2 / d);
}

point circumc(point a, point b, point c) {
  line x(a, b);
  line midab = line(x.a, x.b, (a + b) / 2.);
  line y(b, c);
  line midbc = line(y.a, y.b, (b + c) / 2.);
  return intersect(midab, midbc);
}

const int maxN = 110;

int n;
point a[maxN];

bool is_in(point a, point b, point c) {
  return fabs(dist(a, b) - dist(a, c) - dist(b, c)) < eps;
}

bool is_good(int x, int y, int z) {
  double A = dist(a[x], a[y]);
  double B = dist(a[x], a[z]);
  double C = dist(a[y], a[z]);

  return fabs(A * A + B * B - C * C) < eps ||
         fabs(A * A + C * C - B * B) < eps ||
         fabs(B * B + C * C - A * A) < eps;
}

bool cmp (point a, point b) {
	return a.x < b.x || a.x == b.x && a.y < b.y;
}

bool cw (point a, point b, point c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) < 0;
}

bool ccw (point a, point b, point c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) > 0;
}

void convex_hull (vector<point> & a) {
	if (a.size() == 1)  return;
	sort (a.begin(), a.end(), &cmp);
	point p1 = a[0],  p2 = a.back();
	vector<point> up, down;
	up.push_back (p1);
	down.push_back (p1);
	for (size_t i=1; i<a.size(); ++i) {
		if (i==a.size()-1 || cw (p1, a[i], p2)) {
			while (up.size()>=2 && !cw (up[up.size()-2], up[up.size()-1], a[i]))
				up.pop_back();
			up.push_back (a[i]);
		}
		if (i==a.size()-1 || ccw (p1, a[i], p2)) {
			while (down.size()>=2 && !ccw (down[down.size()-2], down[down.size()-1], a[i]))
				down.pop_back();
			down.push_back (a[i]);
		}
	}
	a.clear();
	for (size_t i=0; i<up.size(); ++i)
		a.push_back (up[i]);
	for (size_t i=down.size()-2; i>0; --i)
		a.push_back (down[i]);
}

bool is_good(vector<point>& v, point x) {
  v.push_back(v[0]);
  for (int i = 0; i + 1 < v.size(); ++i) {
    if (is_in(v[i], v[i + 1], x)) {
      v.pop_back();
      return false;
    }
  }
  v.pop_back();
  return true;
}

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  cin >> n;
  vector <point> v;
  for (int i = 0; i < n; ++i) {
    a[i].read();
    v.push_back(a[i]);
  }

  convex_hull(v);

  double res = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      for (int k = j + 1; k < n; ++k) {
        if (a[i] == a[j]) continue;
        if (a[i] == a[k]) continue;
        if (a[j] == a[k]) continue;
        double A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);

        if (A * A + B * B < C * C - eps) continue;
        if (A * A + C * C < B * B - eps) continue;
        if (B * B + C * C < A * A - eps) continue;

        point cand = circumc(a[i], a[j], a[k]);
        if (!is_good(v, cand)) continue;
        double cd = 1e10;
        for (int l = 0; l < n; ++l) {
          cd = min(cd, dist(a[l], cand));
        }
        res = max(res, cd);
      }
    }
  }

  if (res < eps) {
    printf("-1\n");
    return 0;
  }
  printf("%.10lf\n", res);
  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-6;

struct point {
  double x, y;
  point() {
    x = y = 0;
  }
  point(double x, double y) : x(x), y(y) {}
  void read() {
    cin >> x >> y;
  }

  bool operator == (const point& other) const {
    return fabs(x - other.x) < eps && fabs(y - other.y) < eps;
  }
};

double dist(const point& a, const point& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

point operator + (const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}

point operator - (const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}

point operator * (const point& a, double x) {
  return point(a.x * x, a.y * x);
}

point operator * (double x, const point& a) {
  return a * x;
}

point operator / (const point& a, double x) {
  return point(a.x / x, a.y / x);
}

struct line {
  double a, b, c;
  line(point x, point y) {
    a = x.y - y.y;
    b = y.x - x.x;
    c = x.x * y.y - x.y * y.x;
  }

  line(double nx, double ny, point x) {
    b = -nx;
    a = ny;
    c = -a * x.x - b * x.y;
  }
};

point intersect(line a, line b) {
  double d = a.a * b.b - a.b * b.a;
  double d1 = -a.c * b.b + a.b * b.c;
  double d2 = -a.a * b.c + a.c * b.a;

  return point(d1 / d, d2 / d);
}

point circumc(point a, point b, point c) {
  line x(a, b);
  line midab = line(x.a, x.b, (a + b) / 2.);
  line y(b, c);
  line midbc = line(y.a, y.b, (b + c) / 2.);
  return intersect(midab, midbc);
}

const int maxN = 110;

int n;
point a[maxN];

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  cin >> n;
  for (int i = 0; i < n; ++i) {
    a[i].read();
  }

  double res = 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 A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);

        if (A * A + B * B < C * C + eps) continue;
        if (A * A + C * C < B * B + eps) continue;
        if (B * B + C * C < A * A + eps) continue;

        point cand = circumc(a[i], a[j], a[k]);
        double cd = 1e10;
        for (int l = 0; l < n; ++l) {
          cd = min(cd, dist(a[l], cand));
        }
        res = max(res, cd);
      }
    }
  }

  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      for (int k = j + 1; k < n; ++k) {
        double A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);
        if (fabs(A * A + B * B - C * C) < eps ||
            fabs(A * A + C * C - B * B) < eps ||
            fabs(B * B + C * C - A * A) < eps) {
          if (fabs(A - B) < eps || fabs(A - C) < eps || fabs(B - C) < eps) {
            point d;
            if (fabs(C - B) < eps) {
              point buf = (a[i] + a[j]) / 2. - a[k];
              d = a[k] + 2. * buf;
            } else if (fabs(A - C) < eps) {
              point buf = (a[j] + a[k]) / 2. - a[i];
              d = a[i] + 2. * buf;
            } else {
              point buf = (a[i] + a[k]) / 2. - a[j];
              d = a[j] + 2. * buf;
            }

            int ok = false;
            for (int l = 0; l < n; ++l) {
              if (d == a[l]) {
                ok = true;
                break;
              }
            }
            if (ok) {
              point cand = circumc(a[i], a[j], d);
              double cd = 1e10;
              for (int l = 0; l < n; ++l) {
                cd = min(cd, dist(a[l], cand));
              }
              res = max(res, cd);
            }
          }
        }
      }
    }
  }

  if (res < eps) {
    printf("-1\n");
    return 0;
  }
  printf("%.10lf\n", res);
  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-6;

struct point {
  double x, y;
  point() {
    x = y = 0;
  }
  point(double x, double y) : x(x), y(y) {}
  void read() {
    cin >> x >> y;
  }

  bool operator == (const point& other) const {
    return fabs(x - other.x) < eps && fabs(y - other.y) < eps;
  }
};

double dist(const point& a, const point& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

point operator + (const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}

point operator - (const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}

point operator * (const point& a, double x) {
  return point(a.x * x, a.y * x);
}

point operator * (double x, const point& a) {
  return a * x;
}

point operator / (const point& a, double x) {
  return point(a.x / x, a.y / x);
}

struct line {
  double a, b, c;
  line(point x, point y) {
    a = x.y - y.y;
    b = y.x - x.x;
    c = x.x * y.y - x.y * y.x;
  }

  line(double nx, double ny, point x) {
    b = -nx;
    a = ny;
    c = -a * x.x - b * x.y;
  }
};

point intersect(line a, line b) {
  double d = a.a * b.b - a.b * b.a;
  double d1 = -a.c * b.b + a.b * b.c;
  double d2 = -a.a * b.c + a.c * b.a;

  return point(d1 / d, d2 / d);
}

point circumc(point a, point b, point c) {
  line x(a, b);
  line midab = line(x.a, x.b, (a + b) / 2.);
  line y(b, c);
  line midbc = line(y.a, y.b, (b + c) / 2.);
  return intersect(midab, midbc);
}

const int maxN = 110;

int n;
point a[maxN];

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  cin >> n;
  for (int i = 0; i < n; ++i) {
    a[i].read();
  }

  double res = 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 A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);

        if (A * A + B * B < C * C + eps) continue;
        if (A * A + C * C < B * B + eps) continue;
        if (B * B + C * C < A * A + eps) continue;

        point cand = circumc(a[i], a[j], a[k]);
        double cd = 1e10;
        for (int l = 0; l < n; ++l) {
          cd = min(cd, dist(a[l], cand));
        }
        res = max(res, cd);
      }
    }
  }

  /*for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      for (int k = j + 1; k < n; ++k) {
        double A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);
        if (fabs(A * A + B * B - C * C) < eps ||
            fabs(A * A + C * C - B * B) < eps ||
            fabs(B * B + C * C - A * A) < eps) {
          if (fabs(A - B) < eps || fabs(A - C) < eps || fabs(B - C) < eps) {
            point d;
            if (fabs(C - B) < eps) {
              point buf = (a[i] + a[j]) / 2. - a[k];
              d = a[k] + 2. * buf;
            } else if (fabs(A - C) < eps) {
              point buf = (a[j] + a[k]) / 2. - a[i];
              d = a[i] + 2. * buf;
            } else {
              point buf = (a[i] + a[k]) / 2. - a[j];
              d = a[j] + 2. * buf;
            }

            int ok = false;
            for (int l = 0; l < n; ++l) {
              if (d == a[l]) {
                ok = true;
                break;
              }
            }
            if (ok) {
              point cand = circumc(a[i], a[j], a[k]);
              double cd = 1e10;
              for (int l = 0; l < n; ++l) {
                cd = min(cd, dist(a[l], cand));
              }
              res = max(res, cd);
            }
          }
        }
      }
    }
  }*/

  if (res < eps) {
    printf("-1\n");
    return 0;
  }
  printf("%.10lf\n", res);
  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-6;

struct point {
  double x, y;
  point() {
    x = y = 0;
  }
  point(double x, double y) : x(x), y(y) {}
  void read() {
    cin >> x >> y;
  }

  bool operator == (const point& other) const {
    return fabs(x - other.x) < eps && fabs(y - other.y) < eps;
  }
};

double dist(const point& a, const point& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

point operator + (const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}

point operator - (const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}

point operator * (const point& a, double x) {
  return point(a.x * x, a.y * x);
}

point operator * (double x, const point& a) {
  return a * x;
}

point operator / (const point& a, double x) {
  return point(a.x / x, a.y / x);
}

struct line {
  double a, b, c;
  line(point x, point y) {
    a = x.y - y.y;
    b = y.x - x.x;
    c = x.x * y.y - x.y * y.x;
  }

  line(double nx, double ny, point x) {
    b = -nx;
    a = ny;
    c = -a * x.x - b * x.y;
  }
};

point intersect(line a, line b) {
  double d = a.a * b.b - a.b * b.a;
  double d1 = -a.c * b.b + a.b * b.c;
  double d2 = -a.a * b.c + a.c * b.a;

  return point(d1 / d, d2 / d);
}

point circumc(point a, point b, point c) {
  line x(a, b);
  line midab = line(x.a, x.b, (a + b) / 2.);
  line y(b, c);
  line midbc = line(y.a, y.b, (b + c) / 2.);
  return intersect(midab, midbc);
}

const int maxN = 110;

int n;
point a[maxN];

bool is_in(point a, point b, point c) {
  return fabs(dist(a, b) - dist(a, c) - dist(b, c)) < eps;
}

bool is_good(int x, int y, int z) {
  double A = dist(a[x], a[y]);
  double B = dist(a[x], a[z]);
  double C = dist(a[y], a[z]);

  return fabs(A * A + B * B - C * C) < eps ||
         fabs(A * A + C * C - B * B) < eps ||
         fabs(B * B + C * C - A * A) < eps;
}

bool cmp (point a, point b) {
	return a.x < b.x || a.x == b.x && a.y < b.y;
}

bool cw (point a, point b, point c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) < 0;
}

bool ccw (point a, point b, point c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) > 0;
}

void convex_hull (vector<point> & a) {
	if (a.size() == 1)  return;
	sort (a.begin(), a.end(), &cmp);
	point p1 = a[0],  p2 = a.back();
	vector<point> up, down;
	up.push_back (p1);
	down.push_back (p1);
	for (size_t i=1; i<a.size(); ++i) {
		if (i==a.size()-1 || cw (p1, a[i], p2)) {
			while (up.size()>=2 && !cw (up[up.size()-2], up[up.size()-1], a[i]))
				up.pop_back();
			up.push_back (a[i]);
		}
		if (i==a.size()-1 || ccw (p1, a[i], p2)) {
			while (down.size()>=2 && !ccw (down[down.size()-2], down[down.size()-1], a[i]))
				down.pop_back();
			down.push_back (a[i]);
		}
	}
	a.clear();
	for (size_t i=0; i<up.size(); ++i)
		a.push_back (up[i]);
	for (size_t i=down.size()-2; i>0; --i)
		a.push_back (down[i]);
}

bool is_good(vector<point>& v, point x) {
  v.push_back(v[0]);
  for (int i = 0; i + 1 < v.size(); ++i) {
    if (is_in(v[i], v[i + 1], x)) {
      v.pop_back();
      return false;
    }
  }
  v.pop_back();
  return true;
}

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  cin >> n;
  vector <point> v;
  for (int i = 0; i < n; ++i) {
    a[i].read();
    v.push_back(a[i]);
  }

  convex_hull(v);

  double res = 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 A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);

        if (A * A + B * B < C * C - eps) continue;
        if (A * A + C * C < B * B - eps) continue;
        if (B * B + C * C < A * A - eps) continue;

        point cand = circumc(a[i], a[j], a[k]);
        if (!is_good(v, cand)) continue;
        double cd = 1e10;
        for (int l = 0; l < n; ++l) {
          cd = min(cd, dist(a[l], cand));
        }
        res = max(res, cd);
      }
    }
  }

  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      for (int k = j + 1; k < n; ++k) {
        if (is_good(i, j, k)) {
          int ok = false;
          for (int l = 0; l < n; ++l) {
            if (l != k && l != i && l != j) {
              if (is_good(i, j, l) || is_good(i, k, l) || is_good(j, k, l)) {
                ok = true;
                break;
              }
            }
          }
          if (ok) {
            point cand = circumc(a[i], a[j], a[k]);
            double cd = 1e10;
            for (int l = 0; l < n; ++l) {
              cd = min(cd, dist(a[l], cand));
            }
            res = max(res, cd);
          }
        }
      }
    }
  }

  if (res < eps) {
    printf("-1\n");
    return 0;
  }
  printf("%.10lf\n", res);
  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-6;

struct point {
  double x, y;
  point() {
    x = y = 0;
  }
  point(double x, double y) : x(x), y(y) {}
  void read() {
    cin >> x >> y;
  }

  bool operator == (const point& other) const {
    return fabs(x - other.x) < eps && fabs(y - other.y) < eps;
  }
};

double dist(const point& a, const point& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

point operator + (const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}

point operator - (const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}

point operator * (const point& a, double x) {
  return point(a.x * x, a.y * x);
}

point operator * (double x, const point& a) {
  return a * x;
}

point operator / (const point& a, double x) {
  return point(a.x / x, a.y / x);
}

struct line {
  double a, b, c;
  line(point x, point y) {
    a = x.y - y.y;
    b = y.x - x.x;
    c = x.x * y.y - x.y * y.x;
  }

  line(double nx, double ny, point x) {
    b = -nx;
    a = ny;
    c = -a * x.x - b * x.y;
  }
};

point intersect(line a, line b) {
  double d = a.a * b.b - a.b * b.a;
  double d1 = -a.c * b.b + a.b * b.c;
  double d2 = -a.a * b.c + a.c * b.a;

  return point(d1 / d, d2 / d);
}

point circumc(point a, point b, point c) {
  line x(a, b);
  line midab = line(x.a, x.b, (a + b) / 2.);
  line y(b, c);
  line midbc = line(y.a, y.b, (b + c) / 2.);
  return intersect(midab, midbc);
}

const int maxN = 110;

int n;
point a[maxN];

bool is_good(int x, int y, int z) {
  double A = dist(a[x], a[y]);
  double B = dist(a[x], a[z]);
  double C = dist(a[y], a[z]);

  return fabs(A * A + B * B - C * C) < eps ||
         fabs(A * A + C * C - B * B) < eps ||
         fabs(B * B + C * C - A * A) < eps;
}

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  cin >> n;
  for (int i = 0; i < n; ++i) {
    a[i].read();
  }

  double res = 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 A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);

        if (A * A + B * B < C * C + eps) continue;
        if (A * A + C * C < B * B + eps) continue;
        if (B * B + C * C < A * A + eps) continue;

        point cand = circumc(a[i], a[j], a[k]);
        double cd = 1e10;
        for (int l = 0; l < n; ++l) {
          cd = min(cd, dist(a[l], cand));
        }
        res = max(res, cd);
      }
    }
  }

  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      for (int k = j + 1; k < n; ++k) {
        if (is_good(i, j, k)) {
          int ok = false;
          for (int l = 0; l < n; ++l) {
            if (l != k && l != i && l != j) {
              if (is_good(i, j, l) || is_good(i, k, l) || is_good(j, k, l)) {
                ok = true;
                break;
              }
            }
          }
          if (ok) {
            point cand = circumc(a[i], a[j], a[k]);
            double cd = 1e10;
            for (int l = 0; l < n; ++l) {
              cd = min(cd, dist(a[l], cand));
            }
            res = max(res, cd);
          }
        }
      }
    }
  }

  if (res < eps) {
    printf("-1\n");
    return 0;
  }
  printf("%.10lf\n", res);
  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-9;

struct point {
  long long x, y;
  point() {
  }
  point(long long x, long long y) :x(x), y(y) {}

  void read() {
    cin >> x >> y;
  }
};

struct dpoint {
  double x, y;
  dpoint() {
  }
  dpoint(double x, double y) : x(x), y(y) {}
};

double dist(dpoint a, dpoint b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

double is_in(dpoint a, dpoint b, dpoint c) {
  return fabs(dist(a, b) - dist(a, c) - dist(b, c)) < eps;
}

const int maxN = 110;

point x[maxN];
int n;
int used[maxN][maxN];

double get(dpoint a, dpoint b, dpoint c) {
  if (is_in(a, b, c)) return dist(a, c);
  if (dist(a, c) < dist(b, c)) return 0;
  return dist(a, b);
}

bool check(double t) {
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      if (used[i][j]) {
        dpoint a = dpoint(x[i].x, x[i].y);
        dpoint b = dpoint(x[j].x, x[j].y);
        double d = dist(a, b);
        if (2 * t > d) continue;

        vector <pair<double, double> > segs;

        double A = a.y - b.y;
        double B = b.x - a.x;
        double C = a.x * b.y - a.y * b.x;
        double sq = sqrt(A * A + B * B);

        double dx = -B / sq;
        double dy = A / sq;
        for (int k = 0; k < n; ++k) {
          double d = (A * x[k].x + B * x[k].y + C) / sq;
          if (d > t) continue;
          double nx = x[k].x - d * A / sq;
          double ny = x[k].y - d * B / sq;

          double len = sqrt(t * t - d * d);
          dpoint p1 = dpoint(nx + dx * len, ny + dy * len);
          dpoint p2 = dpoint(nx - dx * len, ny - dy * len);
          double g1 = get(a, b, p1);
          double g2 = get(a, b, p2);
          segs.push_back(make_pair(g1, g2));
        }

        if (segs.size() == 0) return true;
        sort(segs.begin(), segs.end());
        double cr = max(segs[0].second, t);
        for (int k = 1; k < segs.size(); ++k) {
          if (segs[k].first > cr && cr < d - t) {
            return true;
          }
          cr = max(cr, segs[k].second);
        }
      }
    }
  }
  return false;
}

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  scanf("%d", &n);
  for (int i = 0; i < n; ++i) {
    x[i].read();
  }

  int fnd = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      long long A = x[i].y - x[j].y;
      long long B = x[j].x - x[i].x;
      long long C = x[i].x * x[j].y - x[i].y * x[j].x;

      long long mx = -1;
      long long mn = 1;
      for (int k = 0; k < n; ++k) {
        long long val = A * x[k].x + B * x[k].y + C;
        if (val > 0) mx = max(mx, val);
        if (val < 0) mn = min(mn, val);
      }
      if (mx > 0 && mn < 0) {
        used[i][j] = used[j][i] = true;
        fnd = 1;
      }
    }
  }

  if (!fnd) {
    printf("-1\n");
    return 0;
  }

  double l = 0, r = 1e6;

  for (int i = 0; i < 100; ++i) {
    double key = (l + r) / 2;
    if (check(key)) {
      l = key;
    } else {
      r = key;
    }
  }

  printf("%.10lf\n", (l + r) / 2.);

  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-9;

struct point {
  long long x, y;
  point() {
  }
  point(long long x, long long y) :x(x), y(y) {}

  void read() {
    cin >> x >> y;
  }
};

struct dpoint {
  double x, y;
  dpoint() {
  }
  dpoint(double x, double y) : x(x), y(y) {}
};

double dist(dpoint a, dpoint b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

double is_in(dpoint a, dpoint b, dpoint c) {
  return fabs(dist(a, b) - dist(a, c) - dist(b, c)) < eps;
}

const int maxN = 110;

point x[maxN];
int n;
int used[maxN][maxN];

double get(dpoint a, dpoint b, dpoint c) {
  if (is_in(a, b, c)) return dist(a, c);
  if (dist(a, c) < dist(b, c)) return 0;
  return dist(a, b);
}

bool check(double t) {
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      if (used[i][j]) {
        dpoint a = dpoint(x[i].x, x[i].y);
        dpoint b = dpoint(x[j].x, x[j].y);
        double d = dist(a, b);
        if (2 * t > d) continue;

        vector <pair<double, double> > segs;

        double A = a.y - b.y;
        double B = b.x - a.x;
        double C = a.x * b.y - a.y * b.x;
        double sq = sqrt(A * A + B * B);

        double dx = -B / sq;
        double dy = A / sq;
        for (int k = 0; k < n; ++k) {
          double d = (A * x[k].x + B * x[k].y + C) / sq;
          if (d > t) continue;
          double nx = x[k].x - d * A / sq;
          double ny = x[k].y - d * B / sq;

          double len = sqrt(t * t - d * d);
          dpoint p1 = dpoint(nx + dx * len, ny + dy * len);
          dpoint p2 = dpoint(nx - dx * len, ny - dy * len);
          double g1 = get(a, b, p1);
          double g2 = get(a, b, p2);
          segs.push_back(make_pair(g1, g2));
        }

        if (segs.size() == 0) return true;
        sort(segs.begin(), segs.end());
        double cr = segs[0].second;
        for (int k = 1; k < segs.size(); ++k) {
          if (segs[k].first > cr) {
            return true;
          }
          cr = max(cr, segs[k].second);
        }
      }
    }
  }
  return false;
}

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  scanf("%d", &n);
  for (int i = 0; i < n; ++i) {
    x[i].read();
  }

  int fnd = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      long long A = x[i].y - x[j].y;
      long long B = x[j].x - x[i].x;
      long long C = x[i].x * x[j].y - x[i].y * x[j].x;

      long long mx = -1;
      long long mn = 1;
      for (int k = 0; k < n; ++k) {
        long long val = A * x[k].x + B * x[k].y + C;
        if (val > 0) mx = max(mx, val);
        if (val < 0) mn = min(mn, val);
      }
      if (mx > 0 && mn < 0) {
        used[i][j] = used[j][i] = true;
        fnd = 1;
      }
    }
  }

  if (!fnd) {
    printf("-1\n");
    return 0;
  }

  double l = 0, r = 1e6;

  for (int i = 0; i < 100; ++i) {
    double key = (l + r) / 2;
    if (check(key)) {
      l = key;
    } else {
      r = key;
    }
  }

  printf("%.10lf\n", (l + r) / 2.);

  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-6;

struct point {
  double x, y;
  point() {
    x = y = 0;
  }
  point(double x, double y) : x(x), y(y) {}
  void read() {
    cin >> x >> y;
  }

  bool operator == (const point& other) const {
    return fabs(x - other.x) < eps && fabs(y - other.y) < eps;
  }
};

double dist(const point& a, const point& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

point operator + (const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}

point operator - (const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}

point operator * (const point& a, double x) {
  return point(a.x * x, a.y * x);
}

point operator * (double x, const point& a) {
  return a * x;
}

point operator / (const point& a, double x) {
  return point(a.x / x, a.y / x);
}

struct line {
  double a, b, c;
  line(point x, point y) {
    a = x.y - y.y;
    b = y.x - x.x;
    c = x.x * y.y - x.y * y.x;
  }

  line(double nx, double ny, point x) {
    b = -nx;
    a = ny;
    c = -a * x.x - b * x.y;
  }
};

point intersect(line a, line b) {
  double d = a.a * b.b - a.b * b.a;
  double d1 = -a.c * b.b + a.b * b.c;
  double d2 = -a.a * b.c + a.c * b.a;

  return point(d1 / d, d2 / d);
}

point circumc(point a, point b, point c) {
  line x(a, b);
  line midab = line(x.a, x.b, (a + b) / 2.);
  line y(b, c);
  line midbc = line(y.a, y.b, (b + c) / 2.);
  return intersect(midab, midbc);
}

const int maxN = 110;

int n;
point a[maxN];

bool is_in(point a, point b, point c) {
  return fabs(dist(a, b) - dist(a, c) - dist(b, c)) < eps;
}

bool is_good(int x, int y, int z) {
  double A = dist(a[x], a[y]);
  double B = dist(a[x], a[z]);
  double C = dist(a[y], a[z]);

  return fabs(A * A + B * B - C * C) < eps ||
         fabs(A * A + C * C - B * B) < eps ||
         fabs(B * B + C * C - A * A) < eps;
}

bool cmp (point a, point b) {
	return a.x < b.x || a.x == b.x && a.y < b.y;
}

bool cw (point a, point b, point c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) < 0;
}

bool ccw (point a, point b, point c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) > 0;
}

void convex_hull (vector<point> & a) {
	if (a.size() == 1)  return;
	sort (a.begin(), a.end(), &cmp);
	point p1 = a[0],  p2 = a.back();
	vector<point> up, down;
	up.push_back (p1);
	down.push_back (p1);
	for (size_t i=1; i<a.size(); ++i) {
		if (i==a.size()-1 || cw (p1, a[i], p2)) {
			while (up.size()>=2 && !cw (up[up.size()-2], up[up.size()-1], a[i]))
				up.pop_back();
			up.push_back (a[i]);
		}
		if (i==a.size()-1 || ccw (p1, a[i], p2)) {
			while (down.size()>=2 && !ccw (down[down.size()-2], down[down.size()-1], a[i]))
				down.pop_back();
			down.push_back (a[i]);
		}
	}
	a.clear();
	for (size_t i=0; i<up.size(); ++i)
		a.push_back (up[i]);
	for (size_t i=down.size()-2; i>0; --i)
		a.push_back (down[i]);
}

bool is_good(vector<point>& v, point x) {
  v.push_back(v[0]);
  for (int i = 0; i + 1 < v.size(); ++i) {
    if (is_in(v[i], v[i + 1], x)) {
      v.pop_back();
      return false;
    }
  }
  v.pop_back();
  return true;
}

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  cin >> n;
  vector <point> v;
  for (int i = 0; i < n; ++i) {
    a[i].read();
    v.push_back(a[i]);
  }

  convex_hull(v);

  double res = 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 A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);

        if (A * A + B * B < C * C - eps) continue;
        if (A * A + C * C < B * B - eps) continue;
        if (B * B + C * C < A * A - eps) continue;

        point cand = circumc(a[i], a[j], a[k]);
        if (!is_good(v, cand)) continue;
        double cd = 1e10;
        for (int l = 0; l < n; ++l) {
          cd = min(cd, dist(a[l], cand));
        }
        res = max(res, cd);
      }
    }
  }

  if (res < eps) {
    printf("-1\n");
    return 0;
  }
  printf("%.10lf\n", res);
  return 0;
}


#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:256000000")

using namespace std;

const double eps = 1e-6;

struct point {
  double x, y;
  point() {
    x = y = 0;
  }
  point(double x, double y) : x(x), y(y) {}
  void read() {
    cin >> x >> y;
  }

  bool operator == (const point& other) const {
    return fabs(x - other.x) < eps && fabs(y - other.y) < eps;
  }
};

double dist(const point& a, const point& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

point operator + (const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}

point operator - (const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}

point operator * (const point& a, double x) {
  return point(a.x * x, a.y * x);
}

point operator * (double x, const point& a) {
  return a * x;
}

point operator / (const point& a, double x) {
  return point(a.x / x, a.y / x);
}

struct line {
  double a, b, c;
  line(point x, point y) {
    a = x.y - y.y;
    b = y.x - x.x;
    c = x.x * y.y - x.y * y.x;
  }

  line(double nx, double ny, point x) {
    b = -nx;
    a = ny;
    c = -a * x.x - b * x.y;
  }
};

point intersect(line a, line b) {
  double d = a.a * b.b - a.b * b.a;
  double d1 = -a.c * b.b + a.b * b.c;
  double d2 = -a.a * b.c + a.c * b.a;

  return point(d1 / d, d2 / d);
}

point circumc(point a, point b, point c) {
  line x(a, b);
  line midab = line(x.a, x.b, (a + b) / 2.);
  line y(b, c);
  line midbc = line(y.a, y.b, (b + c) / 2.);
  return intersect(midab, midbc);
}

const int maxN = 110;

int n;
point a[maxN];

int main() {
  //freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);

  cin >> n;
  for (int i = 0; i < n; ++i) {
    a[i].read();
  }

  double res = 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 A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);

        if (A * A + B * B < C * C + eps) continue;
        if (A * A + C * C < B * B + eps) continue;
        if (B * B + C * C < A * A + eps) continue;

        point cand = circumc(a[i], a[j], a[k]);
        double cd = 1e10;
        for (int l = 0; l < n; ++l) {
          cd = min(cd, dist(a[l], cand));
        }
        res = max(res, cd);
      }
    }
  }

  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      for (int k = j + 1; k < n; ++k) {
        double A = dist(a[i], a[j]);
        double B = dist(a[j], a[k]);
        double C = dist(a[k], a[i]);
        if (fabs(A * A + B * B - C * C) < eps ||
            fabs(A * A + C * C - B * B) < eps ||
            fabs(B * B + C * C - A * A) < eps) {
          if (fabs(A - B) < eps || fabs(A - C) < eps || fabs(B - C) < eps) {
            point d;
            if (fabs(C - B) < eps) {
              point buf = (a[i] + a[j]) / 2. - a[k];
              d = a[k] + 2. * buf;
            } else if (fabs(A - C) < eps) {
              point buf = (a[j] + a[k]) / 2. - a[i];
              d = a[i] + 2. * buf;
            } else {
              point buf = (a[i] + a[k]) / 2. - a[j];
              d = a[j] + 2. * buf;
            }

            int ok = false;
            for (int l = 0; l < n; ++l) {
              if (d == a[l]) {
                ok = true;
                break;
              }
            }
            if (ok) {
              point cand = circumc(a[i], a[j], a[k]);
              double cd = 1e10;
              for (int l = 0; l < n; ++l) {
                cd = min(cd, dist(a[l], cand));
              }
              res = max(res, cd);
            }
          }
        }
      }
    }
  }

  if (res < eps) {
    printf("-1\n");
    return 0;
  }
  printf("%.10lf\n", res);
  return 0;
}


#pragma warning(disable:4996)
#include <stdio.h>
#include <math.h>

struct point {
	double x, y, z;
	point () {}
	point (double x, double y, double z=1) : x (x), y (y), z (z) {}

	point operator * (const point& rhs) const {
		return point (y*rhs.z - z*rhs.y, z*rhs.x - x*rhs.z, x*rhs.y - y*rhs.x);
	}
	point mid (const point& rhs) const {
		return point ((x+rhs.x)/2, (y+rhs.y)/2);
	}
	point rotate () const {
		return point (y, -x, z);
	}
	point pt () const {
		return point (x/z, y/z, 1);
	}
	point operator - (const point& rhs) const {
		return point (x-rhs.x, y-rhs.y, z-rhs.z);
	}
	double dist (const point& rhs) const {
		return sqrt ((x-rhs.x) * (x-rhs.x) + (y-rhs.y) * (y-rhs.y));
	}
};

int n;
point p[110];

int ccw (point a, point b, point c)
{
	double eps = 1e-6;
	double res = (b.x-a.x)*(c.y-a.y) - (b.y-a.y)*(c.x-a.x);
	return res>eps ? 1 : res<-eps ? -1 : 0;
}

point getMidPoint (point a, point b, point c)
{
	if (ccw (a, b, c) == 0)
		return point (0, 0, 0);

	point p = a.mid (b);
	point q = b.mid (c);
	point v1 = (b-a).rotate ();
	point v2 = (c-b).rotate ();

	return ((p * v1) * (q * v2)).pt ();
}

bool inside (point a, point b, point c, point p)
{
	int c1 = ccw (a, b, p);
	int c2 = ccw (b, c, p);
	int c3 = ccw (c, a, p);
	return c1>=0 && c2>=0 && c3>=0 || c1<=0 && c2<=0 && c2<=0;
}

int main ()
{
	scanf ("%d", &n);
	for (int i=0; i<n; i++) {
		int x, y;
		scanf ("%d %d", &x, &y);
		p[i] = point (x, y);
	}

	double ans = -1.0;
	for (int i=0; i<n; i++) {
		for (int j=i+1; j<n; j++) {
			for (int k=j+1; k<n; k++) {
				point mid = getMidPoint (p[i], p[j], p[k]);
				if (mid.z == 0)
					continue;
				if (inside (p[i], p[j], p[k], mid)) {
					double md = 1e10;
					for (int a=0; a<n; a++) {
						double d = mid.dist (p[a]);
						if (md > d)
							md = d;
					}
					if (ans < md)
						ans = md;
				}
			}
		}
	}

	if (ans<0) printf ("-1\n");
	else printf ("%lf\n", ans);

	return 0;
}


#pragma warning(disable:4996)
#include <stdio.h>
#include <math.h>

struct point {
	double x, y, z;
	point () {}
	point (double x, double y, double z=1) : x (x), y (y), z (z) {}

	point operator * (const point& rhs) const {
		return point (y*rhs.z - z*rhs.y, z*rhs.x - x*rhs.z, x*rhs.y - y*rhs.x);
	}
	point mid (const point& rhs) const {
		return point ((x+rhs.x)/2, (y+rhs.y)/2);
	}
	point rotate () const {
		return point (y, -x, z);
	}
	point pt () const {
		return point (x/z, y/z, 1);
	}
	point operator - (const point& rhs) const {
		return point (x-rhs.x, y-rhs.y, z-rhs.z);
	}
	double dist (const point& rhs) const {
		return sqrt ((x-rhs.x) * (x-rhs.x) + (y-rhs.y) * (y-rhs.y));
	}
};

int n;
point p[110];

int ccw (point a, point b, point c)
{
	double eps = 1e-8;
	double res = (b.x-a.x)*(c.y-a.y) - (b.y-a.y)*(c.x-a.x);
	return res>eps ? 1 : res<-eps ? -1 : 0;
}

point getMidPoint (point a, point b, point c)
{
	if (ccw (a, b, c) == 0)
		return point (0, 0, 0);

	point p = a.mid (b);
	point q = b.mid (c);
	point v1 = (b-a).rotate ();
	point v2 = (c-b).rotate ();

	return ((p * v1) * (q * v2)).pt ();
}

bool inside (point a, point b, point c, point p)
{
	int c1 = ccw (a, b, p);
	int c2 = ccw (b, c, p);
	int c3 = ccw (c, a, p);
	return c1>=0 && c2>=0 && c3>=0 || c1<=0 && c2<=0 && c2<=0;
}

int main ()
{
	scanf ("%d", &n);
	for (int i=0; i<n; i++) {
		int x, y;
		scanf ("%d %d", &x, &y);
		p[i] = point (x, y);
	}

	double ans = -1.0;
	for (int i=0; i<n; i++) {
		for (int j=i+1; j<n; j++) {
			for (int k=j+1; k<n; k++) {
				point mid = getMidPoint (p[i], p[j], p[k]);
				if (mid.z == 0)
					continue;
				if (inside (p[i], p[j], p[k], mid)) {
					double md = 1e10;
					for (int a=0; a<n; a++) {
						double d = mid.dist (p[i]);
						if (md > d)
							md = d;
					}
					if (ans < md)
						ans = md;
				}
			}
		}
	}

	if (ans<0) printf ("-1\n");
	else printf ("%lf\n", ans);

	return 0;
}


#pragma warning(disable:4996)
#include <stdio.h>
#include <math.h>

struct point {
	double x, y, z;
	point () {}
	point (double x, double y, double z=1) : x (x), y (y), z (z) {}

	point operator * (const point& rhs) const {
		return point (y*rhs.z - z*rhs.y, z*rhs.x - x*rhs.z, x*rhs.y - y*rhs.x);
	}
	point mid (const point& rhs) const {
		return point ((x+rhs.x)/2, (y+rhs.y)/2);
	}
	point rotate () const {
		return point (y, -x, z);
	}
	point pt () const {
		return point (x/z, y/z, 1);
	}
	point operator - (const point& rhs) const {
		return point (x-rhs.x, y-rhs.y, z-rhs.z);
	}
	double dist (const point& rhs) const {
		return sqrt ((x-rhs.x) * (x-rhs.x) + (y-rhs.y) * (y-rhs.y));
	}
};

int n;
point p[110];

int ccw (point a, point b, point c)
{
	double eps = 1e-6;
	double res = (b.x-a.x)*(c.y-a.y) - (b.y-a.y)*(c.x-a.x);
	return res>eps ? 1 : res<-eps ? -1 : 0;
}

point getMidPoint (point a, point b, point c)
{
	if (ccw (a, b, c) == 0)
		return point (0, 0, 0);

	point p = a.mid (b);
	point q = b.mid (c);
	point v1 = (b-a).rotate ();
	point v2 = (c-b).rotate ();

	return ((p * v1) * (q * v2)).pt ();
}

bool inside (point a, point b, point c, point p)
{
	int c1 = ccw (a, b, p);
	int c2 = ccw (b, c, p);
	int c3 = ccw (c, a, p);
	return c1>=0 && c2>=0 && c3>=0 || c1<=0 && c2<=0 && c3<=0;
}

int main ()
{
	scanf ("%d", &n);
	for (int i=0; i<n; i++) {
		int x, y;
		scanf ("%d %d", &x, &y);
		p[i] = point (x, y);
	}

	double ans = -1.0;
	for (int i=0; i<n; i++) {
		for (int j=i+1; j<n; j++) {
			for (int k=j+1; k<n; k++) {
				point mid = getMidPoint (p[i], p[j], p[k]);
				if (mid.z == 0)
					continue;
				if (inside (p[i], p[j], p[k], mid)) {
					double md = 1e10;
					for (int a=0; a<n; a++) {
						double d = mid.dist (p[a]);
						if (md > d)
							md = d;
					}
					if (ans < md)
						ans = md;
				}
			}
		}
	}

	if (ans<0) printf ("-1\n");
	else printf ("%lf\n", ans);

	return 0;
}


#pragma warning(disable:4996)
#include <stdio.h>
#include <math.h>

struct point {
	double x, y, z;
	point () {}
	point (double x, double y, double z=1) : x (x), y (y), z (z) {}

	point operator * (const point& rhs) const {
		return point (y*rhs.z - z*rhs.y, z*rhs.x - x*rhs.z, x*rhs.y - y*rhs.x);
	}
	point mid (const point& rhs) const {
		return point ((x+rhs.x)/2, (y+rhs.y)/2);
	}
	point rotate () const {
		return point (y, -x, z);
	}
	point pt () const {
		return point (x/z, y/z, 1);
	}
	point operator - (const point& rhs) const {
		return point (x-rhs.x, y-rhs.y, z-rhs.z);
	}
	double dist (const point& rhs) const {
		return sqrt ((x-rhs.x) * (x-rhs.x) + (y-rhs.y) * (y-rhs.y));
	}
};

int n;
point p[110];

int ccw (point a, point b, point c)
{
	double eps = 1e-8;
	double res = (b.x-a.x)*(c.y-a.y) - (b.y-a.y)*(c.x-a.x);
	return res>eps ? 1 : res<-eps ? -1 : 0;
}

point getMidPoint (point a, point b, point c)
{
	if (ccw (a, b, c) == 0)
		return point (0, 0, 0);

	point p = a.mid (b);
	point q = b.mid (c);
	point v1 = (b-a).rotate ();
	point v2 = (c-b).rotate ();

	return ((p * v1) * (q * v2)).pt ();
}

bool inside (point a, point b, point c, point p)
{
	int c1 = ccw (a, b, p);
	int c2 = ccw (b, c, p);
	int c3 = ccw (c, a, p);
	return c1>=0 && c2>=0 && c3>=0 || c1<=0 && c2<=0 && c2<=0;
}

int main ()
{
	scanf ("%d", &n);
	for (int i=0; i<n; i++) {
		int x, y;
		scanf ("%d %d", &x, &y);
		p[i] = point (x, y);
	}

	double ans = -1.0;
	for (int i=0; i<n; i++) {
		for (int j=i+1; j<n; j++) {
			for (int k=j+1; k<n; k++) {
				point mid = getMidPoint (p[i], p[j], p[k]);
				if (mid.z == 0)
					continue;
				if (inside (p[i], p[j], p[k], mid)) {
					double d = mid.dist (p[i]);
					if (ans < d)
						ans = d;
				}
			}
		}
	}

	if (ans<0) printf ("-1\n");
	else printf ("%lf\n", ans);

	return 0;
}


#pragma warning(disable:4996)
#include <stdio.h>
#include <math.h>
#include <algorithm>
using namespace std;

const double PI = 3.1415926535897932384626433832795;

struct point {
	double x, y, z;
	point () {}
	point (double x, double y, double z=1) : x (x), y (y), z (z) {}

	point operator * (const point& rhs) const {
		return point (y*rhs.z - z*rhs.y, z*rhs.x - x*rhs.z, x*rhs.y - y*rhs.x);
	}
	point mid (const point& rhs) const {
		return point ((x+rhs.x)/2, (y+rhs.y)/2);
	}
	point rotate () const {
		return point (y, -x, z);
	}
	point pt () const {
		return point (x/z, y/z, 1);
	}
	point operator - (const point& rhs) const {
		return point (x-rhs.x, y-rhs.y, z-rhs.z);
	}
	double dist (const point& rhs) const {
		return sqrt ((x-rhs.x) * (x-rhs.x) + (y-rhs.y) * (y-rhs.y));
	}
};

int n;
point p[110];

int ccw (point a, point b, point c)
{
	double eps = 1e-6;
	double res = (b.x-a.x)*(c.y-a.y) - (b.y-a.y)*(c.x-a.x);
	return res>eps ? 1 : res<-eps ? -1 : 0;
}

point getMidPoint (point a, point b, point c)
{
	if (ccw (a, b, c) == 0)
		return point (0, 0, 0);

	point p = a.mid (b);
	point q = b.mid (c);
	point v1 = (b-a).rotate ();
	point v2 = (c-b).rotate ();

	return ((p * v1) * (q * v2)).pt ();
}

bool inside (point a, point b, point c, point p)
{
	int c1 = ccw (a, b, p);
	int c2 = ccw (b, c, p);
	int c3 = ccw (c, a, p);
	return c1>0 && c2>0 && c3>0 || c1<0 && c2<0 && c3<0;
}

int main ()
{
	scanf ("%d", &n);
	for (int i=0; i<n; i++) {
		int x, y;
		scanf ("%d %d", &x, &y);
		p[i] = point (x, y);
	}

	double ans = -1.0;
	for (int i=0; i<n; i++) {
		for (int j=i+1; j<n; j++) {
			for (int k=j+1; k<n; k++) {
				point mid = getMidPoint (p[i], p[j], p[k]);
				if (mid.z == 0)
					continue;

				double md = 1e10;
				static double theta[100];
				for (int a=0; a<n; a++) {
					double d = mid.dist (p[a]);
					point v = p[a] - mid;
					theta[a] = atan2 (v.y, v.x);
					if (md > d)
						md = d;
				}
				if (ans < md) {
					sort (theta, theta+n);
					bool f = false;
					for (int a=0; a<n; a++) {
						if (theta[(a+n-1)%n] < theta[a] + PI) {
							f = true;
							break;
						}
						theta[a] += 2*PI;
					}
					if (!f)
						ans = md;
				}
			}
		}
	}

	if (ans<0) printf ("-1\n");
	else printf ("%lf\n", ans);

	return 0;
}


#pragma warning(disable:4996)
#include <stdio.h>
#include <math.h>
#include <algorithm>
using namespace std;

const double PI = 3.1415926535897932384626433832795;

struct point {
	double x, y, z;
	point () {}
	point (double x, double y, double z=1) : x (x), y (y), z (z) {}

	point operator * (const point& rhs) const {
		return point (y*rhs.z - z*rhs.y, z*rhs.x - x*rhs.z, x*rhs.y - y*rhs.x);
	}
	point mid (const point& rhs) const {
		return point ((x+rhs.x)/2, (y+rhs.y)/2);
	}
	point rotate () const {
		return point (y, -x, z);
	}
	point pt () const {
		return point (x/z, y/z, 1);
	}
	point operator - (const point& rhs) const {
		return point (x-rhs.x, y-rhs.y, z-rhs.z);
	}
	double dist (const point& rhs) const {
		return sqrt ((x-rhs.x) * (x-rhs.x) + (y-rhs.y) * (y-rhs.y));
	}
};

int n;
point p[110];

int ccw (point a, point b, point c)
{
	double eps = 1e-6;
	double res = (b.x-a.x)*(c.y-a.y) - (b.y-a.y)*(c.x-a.x);
	return res>eps ? 1 : res<-eps ? -1 : 0;
}

point getMidPoint (point a, point b, point c)
{
	if (ccw (a, b, c) == 0)
		return point (0, 0, 0);

	point p = a.mid (b);
	point q = b.mid (c);
	point v1 = (b-a).rotate ();
	point v2 = (c-b).rotate ();

	return ((p * v1) * (q * v2)).pt ();
}

bool inside (point a, point b, point c, point p)
{
	int c1 = ccw (a, b, p);
	int c2 = ccw (b, c, p);
	int c3 = ccw (c, a, p);
	return c1>0 && c2>0 && c3>0 || c1<0 && c2<0 && c3<0;
}

int main ()
{
	scanf ("%d", &n);
	for (int i=0; i<n; i++) {
		int x, y;
		scanf ("%d %d", &x, &y);
		p[i] = point (x, y);
	}

	double ans = -1.0;
	for (int i=0; i<n; i++) {
		for (int j=i+1; j<n; j++) {
			for (int k=j+1; k<n; k++) {
				point mid = getMidPoint (p[i], p[j], p[k]);
				if (mid.z == 0)
					continue;

				double md = mid.dist (p[i]);
				if (ans < md) {
					static double theta[100];
					bool f = false;
					int b=0;
					for (int a=0; a<n; a++) {
						double d = mid.dist (p[a]);
						point v = p[a] - mid;
						if (md + (1e-8) > d)
							theta[b++] = atan2 (v.y, v.x);
						if (a!=i && a!=j && a!=k && md-(1e-8) > d) {
							f = true;
							break;
						}
					}
					if (f) continue;

					sort (theta, theta+b);
					for (int a=0; a<b; a++) {
						if (theta[(a+b-1)%b] < theta[a] + PI) {
							f = true;
							break;
						}
						theta[a] += 2*PI;
					}
					if (!f)
						ans = md;
				}
			}
		}
	}

	if (ans<0) printf ("-1\n");
	else printf ("%lf\n", ans);

	return 0;
}


#pragma warning(disable:4996)
#include <stdio.h>
#include <math.h>
#include <algorithm>
using namespace std;

const double PI = 3.1415926535897932384626433832795;

struct point {
	double x, y, z;
	point () {}
	point (double x, double y, double z=1) : x (x), y (y), z (z) {}

	point operator * (const point& rhs) const {
		return point (y*rhs.z - z*rhs.y, z*rhs.x - x*rhs.z, x*rhs.y - y*rhs.x);
	}
	point mid (const point& rhs) const {
		return point ((x+rhs.x)/2, (y+rhs.y)/2);
	}
	point rotate () const {
		return point (y, -x, z);
	}
	point pt () const {
		return point (x/z, y/z, 1);
	}
	point operator - (const point& rhs) const {
		return point (x-rhs.x, y-rhs.y, z-rhs.z);
	}
	double dist (const point& rhs) const {
		return sqrt ((x-rhs.x) * (x-rhs.x) + (y-rhs.y) * (y-rhs.y));
	}
};

int n;
point p[110];

int ccw (point a, point b, point c)
{
	double eps = 1e-6;
	double res = (b.x-a.x)*(c.y-a.y) - (b.y-a.y)*(c.x-a.x);
	return res>eps ? 1 : res<-eps ? -1 : 0;
}

point getMidPoint (point a, point b, point c)
{
	if (ccw (a, b, c) == 0)
		return point (0, 0, 0);

	point p = a.mid (b);
	point q = b.mid (c);
	point v1 = (b-a).rotate ();
	point v2 = (c-b).rotate ();

	return ((p * v1) * (q * v2)).pt ();
}

bool inside (point a, point b, point c, point p)
{
	int c1 = ccw (a, b, p);
	int c2 = ccw (b, c, p);
	int c3 = ccw (c, a, p);
	return c1>0 && c2>0 && c3>0 || c1<0 && c2<0 && c3<0;
}

int main ()
{
	scanf ("%d", &n);
	for (int i=0; i<n; i++) {
		int x, y;
		scanf ("%d %d", &x, &y);
		p[i] = point (x, y);
	}

	double ans = -1.0;
	for (int i=0; i<n; i++) {
		for (int j=i+1; j<n; j++) {
			for (int k=j+1; k<n; k++) {
				point mid = getMidPoint (p[i], p[j], p[k]);
				if (mid.z == 0)
					continue;

				double md = mid.dist (p[i]);
				if (ans < md) {
					static double theta[100];
					bool f = false;
					int b=0;
					for (int a=0; a<n; a++) {
						double d = mid.dist (p[a]);
						point v = p[a] - mid;
						if (md + (1e-8) > d)
							theta[b++] = atan2 (v.y, v.x);
						if (a!=i && a!=j && a!=k && md-(1e-8) > d) {
							f = true;
							break;
						}
					}
					if (f) continue;

					sort (theta, theta+b);
					for (int a=0; a<b; a++) {
						if (theta[(a+b-1)%n] < theta[a] + PI) {
							f = true;
							break;
						}
						theta[a] += 2*PI;
					}
					if (!f)
						ans = md;
				}
			}
		}
	}

	if (ans<0) printf ("-1\n");
	else printf ("%lf\n", ans);

	return 0;
}