#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 + 1e-8) {
							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 k=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[k++] = 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+k);
					for (int a=0; a<k; a++) {
						if (theta[(a+k-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;
}


#include<iostream>
#include<math.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
#include<string>
#include<stdio.h>
#include<map>

#define forn(i, n)	for(int i = 0; i < n; i++)
#define ll long long

using namespace std;

const int md = 1000000007;
const int maxn = 101010;
const ll inf = 2020202020202020202LL;

struct pt
{
	double x;
	double y;
};
int n;
double ans = -1;
vector < pt > circle;

void read()
{
	pt p;
	cin>>n;
	forn(i, n)
		{
			cin>>p.x>>p.y;
			circle.push_back(p);
		}
}

double dst(pt a, pt b)
{
	return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}

double vm(pt a, pt b, pt p)
{
	double x1 = p.x - a.x;
	double y1 = p.y - a.y;
	double x2 = p.x - b.x;
	double y2 = p.y - b.y;
	return x1 * y2 - x2 * y1;
}

int isout(pt a, pt b, pt c, pt p)
{
	double sa = vm(a, b, p);
	double sb = vm(b, c, p);
	double sc = vm(c, a, p);
	if (abs(sa + sb + sc) == (abs(sa) + abs(sb) + abs(sc)))
		return 0;
	return 1;
}
pt intr(double a1, double b1, double c1, double a2, double b2, double c2)
{
	pt u;
	double e = a1 * b2 - a2 * b1;
	if (e == 0)
		{
			u.x = md;
			u.y = md;
		}
	else
	{
		u.x = (a1 * c2 - a2 * c1) / e;
		u.x = -u.x;
		u.y = (b1 * c2 - b2 * c1) / e;
		swap(u.x, u.y);
	}
	return u;
}
pt cnt(pt a, pt b, pt c)
{
	double a1 = b.x - a.x;
	double a2 = c.x - a.x;
	double b1 = b.y - a.y;
	double b2 = c.y - a.y;
	pt o;
	o.x = 0;
	o.y = 0;
	double c1 = dst(o, a) / 2 - dst(o, b) / 2;
	double c2 = dst(o, a) / 2 - dst(o, c) / 2;
	return intr(a1, b1, c1, a2, b2, c2);
}
double doit(int a, int b, int c)
{
	int t = 1;
	pt ce = cnt(circle[a], circle[b], circle[c]);
	if (vm(circle[a], circle[b], circle[c]) == 0)
		t = 0;
	double d = dst(circle[a], ce);
	t = t * (1 - isout(circle[a], circle[b], circle[c], ce));
	forn(i, n)
		if (dst(ce, circle[i]) < d)
			t = 0;
	if (t)
		return d;
	return -1;
}

void brute()
{
	forn(i, n)
		for (int j = i + 1; j < n; j++)
			for (int u = j + 1; u < n; u++)
				ans = max(doit(i, j, u), ans);
}

int main()
{
	read();
	brute();
	cout.precision(7);
	if (ans > 0)
		ans = sqrt(ans);
	cout<<fixed<<ans;
	return 0;
}


#include<iostream>
#include<math.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
#include<string>
#include<stdio.h>
#include<map>

#define forn(i, n)	for(int i = 0; i < n; i++)
#define ll long long

using namespace std;

const int md = 1000000007;
const int maxn = 101010;
const double inf = 2020202020202020202LL;

struct pt
{
	double x;
	double y;
};
int n;
double ans = -1;
vector < pt > circle;

void read()
{
	pt p;
	cin>>n;
	forn(i, n)
		{
			cin>>p.x>>p.y;
			circle.push_back(p);
		}
}

double dst(pt a, pt b)
{
	return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}

double vm(pt a, pt b, pt p)
{
	double x1 = p.x - a.x;
	double y1 = p.y - a.y;
	double x2 = p.x - b.x;
	double y2 = p.y - b.y;
	return x1 * y2 - x2 * y1;
}
double vs(pt a, pt b, pt p)
{
	double x1 = p.x - a.x;
	double y1 = p.y - a.y;
	double x2 = p.x - b.x;
	double y2 = p.y - b.y;
	return x1 * x2 + y1 * y2;
}
int nice(pt a, pt b, pt c, pt d)
{
	double a1 = (c.y - b.y);
	double b1 = b.x - c.x;
	double c1 = b.y * c.x - b.x * c.y;
	double p = a1 * a.x + b1 * a.y + c1;
	double q = a1 * d.x + b1 * d.y + c1;
	if (p == 0)
		return 0;
	if (q == 0)
		return 0;
	if (p < 0)
		p = -1;
	else
		p = 1;
	if (q < 0)
		q = -1;
	else
		q = 1;
	if (p != q)
		return 1;
	return 0;
}
int isout(pt a, pt b, pt c, pt p)
{
	double sa = vm(a, b, p);
	double sb = vm(b, c, p);
	double sc = vm(c, a, p);
	if (vm(a, b, p) == 0){
		forn(i, n)
		if (dst(circle[i], p) == dst(p, a))
		if (nice(c, a, b, circle[i]))
			return 0;
		return 1;
	}
	if (vm(b, c, p) == 0){
		forn(i, n)
		if (dst(circle[i], p) == dst(p, a))
		if (nice(a, b, c, circle[i]))
			return 0;
		return 1;
	}
	if (vm(c, a, p) == 0){
		forn(i, n)
		if (dst(circle[i], p) == dst(p, a))
		if(nice(b, a, c, circle[i]))
			return 0;
		return 1;
	}
	if (abs(sa + sb + sc) == (abs(sa) + abs(sb) + abs(sc)))
		return 0;
	return 1;
}
pt intr(double a1, double b1, double c1, double a2, double b2, double c2)
{
	pt u;
	double e = a1 * b2 - a2 * b1;
	if (e == 0)
		{
			u.x = md;
			u.y = md;
		}
	else
	{
		u.x = (a1 * c2 - a2 * c1) / e;
		u.x = -u.x;
		u.y = (b1 * c2 - b2 * c1) / e;
		swap(u.x, u.y);
	}
	return u;
}
pt cnt(pt a, pt b, pt c)
{
	double a1 = b.x - a.x;
	double a2 = c.x - a.x;
	double b1 = b.y - a.y;
	double b2 = c.y - a.y;
	pt o;
	o.x = 0;
	o.y = 0;
	double c1 = dst(o, a) / 2 - dst(o, b) / 2;
	double c2 = dst(o, a) / 2 - dst(o, c) / 2;
	return intr(a1, b1, c1, a2, b2, c2);
}
double sgn(double d)
{
	if (d < 0)
		return -1;
	return 1;
}
double doit(int a, int b, int c)
{
	int t = 1;
	pt ce = cnt(circle[a], circle[b], circle[c]);
	if (vm(circle[a], circle[b], circle[c]) == 0)
		t = 0;
	double d = dst(circle[a], ce);
	int g = isout(circle[a], circle[b], circle[c], ce);
	if (g)
		t = 0;
	forn(i, n)
		if ((dst(ce, circle[i]) < d))
			t = 0;
	double e = sqrt(d);
	if (t)
		return d;
	return -1;
}

void brute()
{
	forn(i, n)
		for (int j = 0; j < n; j++)
			for (int u = 0; u < n; u++)
				if ((i != j) && (i != u) && (j != u))
				ans = max(doit(i, j, u), ans);
}

int main()
{
	read();
	brute();
	cout.precision(7);
	if (ans > 0)
		ans = sqrt(ans);
	cout<<fixed<<ans;
	return 0;
}


#include<iostream>
#include<math.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
#include<string>
#include<stdio.h>
#include<map>

#define forn(i, n)	for(int i = 0; i < n; i++)
#define ll long long

using namespace std;

const int md = 1000000007;
const int maxn = 101010;
const ll inf = 2020202020202020202LL;

struct pt
{
	double x;
	double y;
};
int n;
double ans = -1;
vector < pt > circle;

void read()
{
	pt p;
	cin>>n;
	forn(i, n)
		{
			cin>>p.x>>p.y;
			circle.push_back(p);
		}
}

double dst(pt a, pt b)
{
	return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}

double vm(pt a, pt b, pt p)
{
	double x1 = p.x - a.x;
	double y1 = p.y - a.y;
	double x2 = p.x - b.x;
	double y2 = p.y - b.y;
	return x1 * y2 - x2 * y1;
}
double vs(pt a, pt b, pt p)
{
	double x1 = p.x - a.x;
	double y1 = p.y - a.y;
	double x2 = p.x - b.x;
	double y2 = p.y - b.y;
	return x1 * x2 + y1 * y2;
}
int nice(pt a, pt b, pt c, pt d)
{
	double a1 = (c.y - b.y);
	double b1 = b.x - c.x;
	double c1 = b.y * c.x - b.x * c.y;
	double p = a1 * a.x + b1 * a.y + c1;
	double q = a1 * d.x + b1 * d.y + c1;
	if (p == 0)
		return 0;
	if (q == 0)
		return 0;
	if (p < 0)
		p = -1;
	else
		p = 1;
	if (q < 0)
		q = -1;
	else
		q = 1;
	if (p != q)
		return 1;
	return 0;
}
int isout(pt a, pt b, pt c, pt p)
{
	double sa = vm(a, b, p);
	double sb = vm(b, c, p);
	double sc = vm(c, a, p);
	if (vs(a, b, c) == 0){
		forn(i, n)
		if (dst(circle[i], p) == dst(p, a))
		if (nice(c, a, b, circle[i]))
			return 0;
		return 1;
	}
	if (vs(b, c, a) == 0){
		forn(i, n)
		if (dst(circle[i], p) == dst(p, a))
		if (nice(a, b, c, circle[i]))
			return 0;
		return 1;
	}
	if (vs(c, a, b) == 0){
		forn(i, n)
		if (dst(circle[i], p) == dst(p, a))
		if(nice(b, a, c, circle[i]))
			return 0;
		return 1;
	}
	if (abs(sa + sb + sc) == (abs(sa) + abs(sb) + abs(sc)))
		return 0;
	return 1;
}
pt intr(double a1, double b1, double c1, double a2, double b2, double c2)
{
	pt u;
	double e = a1 * b2 - a2 * b1;
	if (e == 0)
		{
			u.x = md;
			u.y = md;
		}
	else
	{
		u.x = (a1 * c2 - a2 * c1) / e;
		u.x = -u.x;
		u.y = (b1 * c2 - b2 * c1) / e;
		swap(u.x, u.y);
	}
	return u;
}
pt cnt(pt a, pt b, pt c)
{
	double a1 = b.x - a.x;
	double a2 = c.x - a.x;
	double b1 = b.y - a.y;
	double b2 = c.y - a.y;
	pt o;
	o.x = 0;
	o.y = 0;
	double c1 = dst(o, a) / 2 - dst(o, b) / 2;
	double c2 = dst(o, a) / 2 - dst(o, c) / 2;
	return intr(a1, b1, c1, a2, b2, c2);
}
double sgn(double d)
{
	if (d < 0)
		return -1;
	return 1;
}
double doit(int a, int b, int c)
{
	int t = 1;
	pt ce = cnt(circle[a], circle[b], circle[c]);
	if (vm(circle[a], circle[b], circle[c]) == 0)
		t = 0;
	double d = dst(circle[a], ce);
	int g = isout(circle[a], circle[b], circle[c], ce);
	if (g)
		t = 0;
	forn(i, n)
		if (dst(ce, circle[i]) < d)
			t = 0;
	if (t)
		return d;
	return -1;
}

void brute()
{
	forn(i, n)
		for (int j = i + 1; j < n; j++)
			for (int u = j + 1; u < n; u++)
				ans = max(doit(i, j, u), ans);
}

int main()
{
	read();
	brute();
	cout.precision(7);
	if (ans > 0)
		ans = sqrt(ans);
	cout<<fixed<<ans;
	return 0;
}


#include<iostream>
#include<math.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
#include<string>
#include<stdio.h>
#include<map>

#define forn(i, n)	for(int i = 0; i < n; i++)
#define ll long long

using namespace std;

const int md = 1000000007;
const int maxn = 101010;
const ll inf = 2020202020202020202LL;

struct pt
{
	double x;
	double y;
};
int n;
double ans = -1;
vector < pt > circle;

void read()
{
	pt p;
	cin>>n;
	forn(i, n)
		{
			cin>>p.x>>p.y;
			circle.push_back(p);
		}
}

double dst(pt a, pt b)
{
	return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}

double vm(pt a, pt b, pt p)
{
	double x1 = p.x - a.x;
	double y1 = p.y - a.y;
	double x2 = p.x - b.x;
	double y2 = p.y - b.y;
	return x1 * y2 - x2 * y1;
}
double vs(pt a, pt b, pt p)
{
	double x1 = p.x - a.x;
	double y1 = p.y - a.y;
	double x2 = p.x - b.x;
	double y2 = p.y - b.y;
	return x1 * x2 + y1 * y2;
}
int isout(pt a, pt b, pt c, pt p)
{
	double sa = vm(a, b, p);
	double sb = vm(b, c, p);
	double sc = vm(c, a, p);
	if (vs(a, b, c) == 0)
		return 1;
	if (vs(b, c, a) == 0)
		return 1;
	if (vs(c, a, b) == 0)
		return 1;
	if (abs(sa + sb + sc) == (abs(sa) + abs(sb) + abs(sc)))
		return 0;
	return 1;
}
pt intr(double a1, double b1, double c1, double a2, double b2, double c2)
{
	pt u;
	double e = a1 * b2 - a2 * b1;
	if (e == 0)
		{
			u.x = md;
			u.y = md;
		}
	else
	{
		u.x = (a1 * c2 - a2 * c1) / e;
		u.x = -u.x;
		u.y = (b1 * c2 - b2 * c1) / e;
		swap(u.x, u.y);
	}
	return u;
}
pt cnt(pt a, pt b, pt c)
{
	double a1 = b.x - a.x;
	double a2 = c.x - a.x;
	double b1 = b.y - a.y;
	double b2 = c.y - a.y;
	pt o;
	o.x = 0;
	o.y = 0;
	double c1 = dst(o, a) / 2 - dst(o, b) / 2;
	double c2 = dst(o, a) / 2 - dst(o, c) / 2;
	return intr(a1, b1, c1, a2, b2, c2);
}
double doit(int a, int b, int c)
{
	int t = 1;
	pt ce = cnt(circle[a], circle[b], circle[c]);
	if (vm(circle[a], circle[b], circle[c]) == 0)
		t = 0;
	double d = dst(circle[a], ce);
	t = t * (1 - isout(circle[a], circle[b], circle[c], ce));
	forn(i, n)
		if (dst(ce, circle[i]) < d)
			t = 0;
	if (t)
		return d;
	return -1;
}

void brute()
{
	forn(i, n)
		for (int j = i + 1; j < n; j++)
			for (int u = j + 1; u < n; u++)
				ans = max(doit(i, j, u), ans);
}

int main()
{
	read();
	brute();
	cout.precision(7);
	if (ans > 0)
		ans = sqrt(ans);
	cout<<fixed<<ans;
	return 0;
}


process.stdin.resume()
process.stdin.setEncoding('utf-8')

var arr = ''
process.stdin.on('data', (i) => {
  arr += i
})

process.stdin.on('end', () => {
  arr = arr.split('\n').map(a => a.replace(/(\r\n|\n|\r)/gm, ''))
  main(arr)
})

function wr(...x) {
  console.log(...x)
}

function sort(a, inc = true) {
  if(inc) a.sort((a, b) => a - b)
  else a.sort((a, b) => b - a)
}

function readInt(a, i) {
  if(i === undefined) return parseInt(a.shift())
  else return parseInt(a[i])
}

function readInts(a, i) {
  if(i === undefined) return arr.shift().split(' ').map(a => parseInt(a))
  else return arr[i].split(' ').map(a => parseInt(a))
}

//====================
var fs = require('fs');

fs.readFile('input.txt', 'utf8', function(err, arr) {
    main(arr.split('\n').map(a => a.replace(/(\r\n|\n|\r)/gm, '')))
})
//====================*/

function main(input) {
    G=new Object()
    n=+input[0]
    X=[]
    Y=[]
    for (i=1;i<=n;i++){
        a=input[i].split(' ')
        x=+a[0]
        y=+a[1]
        if (G[x]===undefined)
            G[x]=new Object
        G[x][y]=i-1
        X.push(x)
        Y.push(y)
    }

    ans=-1

    function C(a,b,c){
        ya=Y[a]
        xa=X[a]
        yb=Y[b]
        xb=X[b]
        yc=Y[c]
        xc=X[c]
        x0=-0.5*(ya*(xb*xb+yb*yb-xc*xc-yc*yc)+yb*(xc*xc+yc*yc-xa*xa-ya*ya)+yc*(xa*xa+ya*ya-xb*xb-yb*yb))/(xa*(yb-yc)+xb*(yc-ya)+xc*(ya-yb))
        y0=+0.5*(xa*(xb*xb+yb*yb-xc*xc-yc*yc)+xb*(xc*xc+yc*yc-xa*xa-ya*ya)+xc*(xa*xa+ya*ya-xb*xb-yb*yb))/(xa*(yb-yc)+xb*(yc-ya)+xc*(ya-yb))
        return {x:x0,y:y0}
    }

    function O(a,b,c){
        x1=X[b]-X[a]
        y1=Y[b]-Y[a]
        x2=X[c]-X[a]
        y2=Y[c]-Y[a]
        return x1*x2+y1*y2>0
    }

    function R(a,b,c){
        x1=X[b]-X[a]
        y1=Y[b]-Y[a]
        x2=X[c]-X[a]
        y2=Y[c]-Y[a]
        return x1*x2+y1*y2==0
    }

    function hypot(a,b){
        return Math.sqrt(a*a+b*b)
    }
    function hypot2(a,b){
        return (a*a+b*b)
    }

    function doR(a,b,c){
        dx=X[b]-X[a]
        dy=Y[b]-Y[a]
        x2=X[c]+dx
        y2=Y[c]+dy
        if (G[x2]!=undefined)
            if (G[x2][y2]!=undefined){
                x0=(X[a]+x2)/2.0
                y0=(Y[a]+y2)/2.0
                d=hypot(X[b]-X[c],Y[b]-Y[c])/2
                for (z=0;z<n;z++)
                {
                    if (z!=a&&z!=b&&z!=c&&z!=G[x2][y2])
                    {
                        wr(i,j,k,G[x2][y2],z)
                        if (hypot(x0-X[z],y0-Y[z])<d){
                            d=-2
                        }
                    }
                }
                if (d>ans)
                   ans=d
            }
    }

    for (i=0;i<n;i++){
        for (j=i+1;j<n;j++){
            for (k=j+1;k<n;k++){

                if (O(i,j,k)&&O(j,i,k)&&O(k,i,j))
                {
                    pt=C(i,j,k)
                    d=hypot(pt.x-X[i],pt.y-Y[i])
                    for (z=0;z<n;z++)
                    {
                        if (z!=i&&z!=j&&z!=k)
                        {
                            if (hypot(pt.x-X[z],pt.y-Y[z])<d){
                                d=-2
                            }
                        }
                    }
                    if (d>ans)
                        ans=d
                }
                if (R(i,j,k)&&hypot(X[j]-X[i],Y[j]-Y[i])==hypot(X[k]-X[i],Y[k]-Y[i])){
                    doR(i,j,k)
                }
                if (R(j,i,k)&&hypot(X[i]-X[j],Y[i]-Y[j])==hypot(X[k]-X[j],Y[k]-Y[j])){
                    doR(j,i,k)
                }
                if (R(k,i,j)&&hypot(X[j]-X[k],Y[j]-Y[k])==hypot(X[i]-X[k],Y[i]-Y[k])){
                    doR(k,i,j)
                }
            }
        }
    }
    wr(ans)

}


process.stdin.resume()
process.stdin.setEncoding('utf-8')

var arr = ''
process.stdin.on('data', (i) => {
  arr += i
})

process.stdin.on('end', () => {
  arr = arr.split('\n').map(a => a.replace(/(\r\n|\n|\r)/gm, ''))
  main(arr)
})

function wr(...x) {
  console.log(...x)
}

function sort(a, inc = true) {
  if(inc) a.sort((a, b) => a - b)
  else a.sort((a, b) => b - a)
}

function readInt(a, i) {
  if(i === undefined) return parseInt(a.shift())
  else return parseInt(a[i])
}

function readInts(a, i) {
  if(i === undefined) return arr.shift().split(' ').map(a => parseInt(a))
  else return arr[i].split(' ').map(a => parseInt(a))
}

/*/====================
var fs = require('fs');

fs.readFile('input.txt', 'utf8', function(err, arr) {
    main(arr.split('\n').map(a => a.replace(/(\r\n|\n|\r)/gm, '')))
})
//====================*/

function main(input) {
    G=new Object()
    n=+input[0]
    X=[]
    Y=[]
    for (i=1;i<=n;i++){
        a=input[i].split(' ')
        x=+a[0]
        y=+a[1]
        if (G[x]===undefined)
            G[x]=new Object
        G[x][y]=i-1
        X.push(x)
        Y.push(y)
    }

    ans=-1

    function C(a,b,c){
        ya=Y[a]
        xa=X[a]
        yb=Y[b]
        xb=X[b]
        yc=Y[c]
        xc=X[c]
        x0=-0.5*(ya*(xb*xb+yb*yb-xc*xc-yc*yc)+yb*(xc*xc+yc*yc-xa*xa-ya*ya)+yc*(xa*xa+ya*ya-xb*xb-yb*yb))/(xa*(yb-yc)+xb*(yc-ya)+xc*(ya-yb))
        y0=+0.5*(xa*(xb*xb+yb*yb-xc*xc-yc*yc)+xb*(xc*xc+yc*yc-xa*xa-ya*ya)+xc*(xa*xa+ya*ya-xb*xb-yb*yb))/(xa*(yb-yc)+xb*(yc-ya)+xc*(ya-yb))
        return {x:x0,y:y0}
    }

    function O(a,b,c){
        x1=X[b]-X[a]
        y1=Y[b]-Y[a]
        x2=X[c]-X[a]
        y2=Y[c]-Y[a]
        return x1*x2+y1*y2>0
    }

    function R(a,b,c){
        x1=X[b]-X[a]
        y1=Y[b]-Y[a]
        x2=X[c]-X[a]
        y2=Y[c]-Y[a]
        return x1*x2+y1*y2==0
    }

    function hypot(a,b){
        return Math.sqrt(a*a+b*b)
    }
    function hypot2(a,b){
        return (a*a+b*b)
    }

    function doR(a,b,c){
        dx=X[b]-X[a]
        dy=Y[b]-Y[a]
        x2=X[c]+dx
        y2=Y[c]+dy
        if (G[x2]!=undefined)
            if (G[x2][y2]!=undefined){
                x0=(X[a]+x2)/2.0
                y0=(Y[a]+y2)/2.0
                d=hypot(X[b]-X[c],Y[b]-Y[c])/2
                for (z=0;z<n;z++)
                {
                    if (z!=a&&z!=b&&z!=c&&z!=G[x2][y2])
                    {
                        wr(i,j,k,G[x2][y2],z)
                        if (hypot(x0-X[z],y0-Y[z])<d){
                            d=-2
                        }
                    }
                }
                if (d>ans)
                   ans=d
            }
    }

    for (i=0;i<n;i++){
        for (j=i+1;j<n;j++){
            for (k=j+1;k<n;k++){

                if (O(i,j,k)&&O(j,i,k)&&O(k,i,j))
                {
                    pt=C(i,j,k)
                    d=hypot(pt.x-X[i],pt.y-Y[i])
                    for (z=0;z<n;z++)
                    {
                        if (z!=i&&z!=j&&z!=k)
                        {
                            if (hypot(pt.x-X[z],pt.y-Y[z])<d){
                                d=-2
                            }
                        }
                    }
                    if (d>ans)
                        ans=d
                }
                if (R(i,j,k)&&hypot(X[j]-X[i],Y[j]-Y[i])==hypot(X[k]-X[i],Y[k]-Y[i])){
                    doR(i,j,k)
                }
                if (R(j,i,k)&&hypot(X[i]-X[j],Y[i]-Y[j])==hypot(X[k]-X[j],Y[k]-Y[j])){
                    doR(j,i,k)
                }
                if (R(k,i,j)&&hypot(X[j]-X[k],Y[j]-Y[k])==hypot(X[i]-X[k],Y[i]-Y[k])){
                    doR(k,i,j)
                }
            }
        }
    }
    wr(ans)

}


process.stdin.resume()
process.stdin.setEncoding('utf-8')

var arr = ''
process.stdin.on('data', (i) => {
  arr += i
})

process.stdin.on('end', () => {
  arr = arr.split('\n').map(a => a.replace(/(\r\n|\n|\r)/gm, ''))
  main(arr)
})

function wr(...x) {
  console.log(...x)
}

function sort(a, inc = true) {
  if(inc) a.sort((a, b) => a - b)
  else a.sort((a, b) => b - a)
}

function readInt(a, i) {
  if(i === undefined) return parseInt(a.shift())
  else return parseInt(a[i])
}

function readInts(a, i) {
  if(i === undefined) return arr.shift().split(' ').map(a => parseInt(a))
  else return arr[i].split(' ').map(a => parseInt(a))
}

/*/====================
var fs = require('fs');

fs.readFile('input.txt', 'utf8', function(err, arr) {
    main(arr.split('\n').map(a => a.replace(/(\r\n|\n|\r)/gm, '')))
})
//====================*/

function main(input) {
    G=new Object()
    n=+input[0]
    X=[]
    Y=[]
    for (i=1;i<=n;i++){
        a=input[i].split(' ')
        x=+a[0]
        y=+a[1]
        if (G[x]===undefined)
            G[x]=new Object
        G[x][y]=i-1
        X.push(x)
        Y.push(y)
    }

    ans=-1

    function C(a,b,c){
        ya=Y[a]
        xa=X[a]
        yb=Y[b]
        xb=X[b]
        yc=Y[c]
        xc=X[c]
        x0=-0.5*(ya*(xb*xb+yb*yb-xc*xc-yc*yc)+yb*(xc*xc+yc*yc-xa*xa-ya*ya)+yc*(xa*xa+ya*ya-xb*xb-yb*yb))/(xa*(yb-yc)+xb*(yc-ya)+xc*(ya-yb))
        y0=+0.5*(xa*(xb*xb+yb*yb-xc*xc-yc*yc)+xb*(xc*xc+yc*yc-xa*xa-ya*ya)+xc*(xa*xa+ya*ya-xb*xb-yb*yb))/(xa*(yb-yc)+xb*(yc-ya)+xc*(ya-yb))
        return {x:x0,y:y0}
    }

    function O(a,b,c){
        x1=X[b]-X[a]
        y1=Y[b]-Y[a]
        x2=X[c]-X[a]
        y2=Y[c]-Y[a]
        return x1*x2+y1*y2>0
    }

    function R(a,b,c){
        x1=X[b]-X[a]
        y1=Y[b]-Y[a]
        x2=X[c]-X[a]
        y2=Y[c]-Y[a]
        return x1*x2+y1*y2==0
    }

    function hypot(a,b){
        return Math.sqrt(a*a+b*b)
    }
    function hypot2(a,b){
        return (a*a+b*b)
    }

    function doR(a,b,c){
        dx=X[b]-X[a]
        dy=Y[b]-Y[a]
        x2=X[c]+dx
        y2=Y[c]+dy
        if (G[x2]!=undefined)
            if (G[x2][y2]!=undefined){
                x0=(X[a]+x2)/2.0
                y0=(Y[a]+y2)/2.0
                d=hypot(X[b]-X[c],Y[b]-Y[c])/2
                for (z=0;z<n;z++)
                {
                    if (z!=a&&z!=b&&z!=c&&z!=G[x2][y2])
                    {
                        if (hypot(x0-X[z],y0-Y[z])<d){
                            d=-2
                        }
                    }
                }
                if (d>ans)
                   ans=d
            }
    }

    for (i=0;i<n;i++){
        for (j=i+1;j<n;j++){
            for (k=j+1;k<n;k++){

                if (O(i,j,k)&&O(j,i,k)&&O(k,i,j))
                {
                    pt=C(i,j,k)
                    d=hypot(pt.x-X[i],pt.y-Y[i])
                    for (z=0;z<n;z++)
                    {
                        if (z!=i&&z!=j&&z!=k)
                        {
                            if (hypot(pt.x-X[z],pt.y-Y[z])<d){
                                d=-2
                            }
                        }
                    }
                    if (d>ans)
                        ans=d
                }
                if (R(i,j,k)&&hypot(X[j]-X[i],Y[j]-Y[i])==hypot(X[k]-X[i],Y[k]-Y[i])){
                    doR(i,j,k)
                }
                if (R(j,i,k)&&hypot(X[i]-X[j],Y[i]-Y[j])==hypot(X[k]-X[j],Y[k]-Y[j])){
                    doR(j,i,k)
                }
                if (R(k,i,j)&&hypot(X[j]-X[k],Y[j]-Y[k])==hypot(X[i]-X[k],Y[i]-Y[k])){
                    doR(k,i,j)
                }
            }
        }
    }
    wr(ans)

}


#include <bits/stdc++.h>

using namespace std;

typedef complex<double> point;

const double eps = 1e-9;
#define vec(a, b) ((b) - (a))
#define dot(a, b) ((conj(a) * (b)).real())
#define cross(a, b) ((conj(a) * (b)).imag())
#define length(a) (hypot((a).real(), (a).imag()))
#define midpoint(a, b) (((a) + (b)) / 2.0)
#define perp(a) (point(-(a).imag(), (a).real()))

struct _hash {
  int operator()(const point &p) const {
    return p.real() * 20001 + p.imag();
  }
};

int n;
point p[100];
unordered_set<point, _hash> pnts;
double ans = -1;

inline int compare(const double &a, const double &b) {
  if(fabs(a - b) < eps) return 0;
  return a < b ? -1 : 1;
}

bool intersect(const point &a, const point &b, const point &p, const point &q, point &ret) {
  double d1 = cross(p - a, b - a);
  double d2 = cross(q - a, b - a);
  ret = (d1 * q - d2 * p) / (d1 - d2);
  return (fabs(d1 - d2) > eps);
}

point findCenter(const point &a, const point &b, const point &c) {
  point m1 = midpoint(a, b);
  point m2 = midpoint(b, c);
  point p1 = perp(vec(a, b));
  point p2 = perp(vec(b, c));
  point r;
  assert(intersect(m1, m1 + p1, m2, m2 + p2, r));
  return r;
}

void check(const point &center, const double &r) {
  double minDist = 1e9;
  for(int i = 0; i < n; ++i)
    minDist = min(minDist, length(vec(center, p[i])));
  if(compare(minDist, r) < 0) return;
  assert(compare(r, minDist) == 0); // :P
  ans = max(ans, r);
}

int main() {
  scanf("%d", &n);
  for(int i = 0; i < n; ++i) {
    int x, y; scanf("%d %d", &x, &y);
    pnts.insert(p[i] = point(x, y));
  }
  for(int i = 0; i < n; ++i)
    for(int j = i + 1; j < n; ++j)
      for(int k = j + 1; k < n; ++k) {
        point triangle[3] = {p[i], p[j], p[k]};
        for(int a = 0; a < 3; ++a) {
          int b = (a + 1) % 3;
          int c = (b + 1) % 3;
          double d = dot(vec(triangle[a], triangle[b]), vec(triangle[a], triangle[c]));
          if(d < 0) goto next;
          if(d == 0) {
            if(!compare(length(vec(triangle[a], triangle[b])), length(vec(triangle[a], triangle[c])))) {
              {
                map<double, int> Xs, Ys;
                for(int q = 0; q < 3; ++q) {
                  if(++Xs[triangle[q].real()] == 2) Xs.erase(triangle[q].real());
                  if(++Ys[triangle[q].imag()] == 2) Ys.erase(triangle[q].imag());
                }
                assert(Xs.size() == 1);
                assert(Ys.size() == 1);
                point _4th(Xs.begin()->first, Ys.begin()->first);
                if(pnts.find(_4th) == pnts.end()) goto next;
                {
                  point center = midpoint(triangle[b], triangle[c]);
                  check(center, length(vec(center, triangle[0])));
                }
              }
            }
            goto next;
          }
        }
        {
          point center = findCenter(triangle[0], triangle[1], triangle[2]);
          check(center, length(vec(center, triangle[0])));
        }
        next:;
      }
  printf("%.17lf\n", ans);
  return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef complex<double> point;

const double eps = 1e-9;
#define vec(a, b) ((b) - (a))
#define dot(a, b) ((conj(a) * (b)).real())
#define cross(a, b) ((conj(a) * (b)).imag())
#define length(a) (hypot((a).real(), (a).imag()))
#define midpoint(a, b) (((a) + (b)) / 2.0)
#define perp(a) (point(-(a).imag(), (a).real()))

struct _hash {
  int operator()(const point &p) const {
    return p.real() * 20001 + p.imag();
  }
};

int n;
point p[100];
unordered_set<point, _hash> pnts;
double ans = -1;

inline int compare(const double &a, const double &b) {
  if(fabs(a - b) < eps) return 0;
  return a < b ? -1 : 1;
}

bool intersect(const point &a, const point &b, const point &p, const point &q, point &ret) {
  double d1 = cross(p - a, b - a);
  double d2 = cross(q - a, b - a);
  ret = (d1 * q - d2 * p) / (d1 - d2);
  return (fabs(d1 - d2) > eps);
}

point findCenter(const point &a, const point &b, const point &c) {
  point m1 = midpoint(a, b);
  point m2 = midpoint(b, c);
  point p1 = perp(vec(a, b));
  point p2 = perp(vec(b, c));
  point r;
  assert(intersect(m1, m1 + p1, m2, m2 + p2, r));
  return r;
}

void check(const point &center, const double &r) {
  double minDist = 1e9;
  for(int i = 0; i < n; ++i)
    minDist = min(minDist, length(vec(center, p[i])));
  if(compare(minDist, r) < 0) return;
  assert(compare(r, minDist) == 0);
  ans = max(ans, r);
}

int main() {
  scanf("%d", &n);
  for(int i = 0; i < n; ++i) {
    int x, y; scanf("%d %d", &x, &y);
    pnts.insert(p[i] = point(x, y));
  }
  for(int i = 0; i < n; ++i)
    for(int j = i + 1; j < n; ++j)
      for(int k = j + 1; k < n; ++k) {
        point triangle[3] = {p[i], p[j], p[k]};
        for(int a = 0; a < 3; ++a) {
          int b = (a + 1) % 3;
          int c = (b + 1) % 3;
          double d = dot(vec(triangle[a], triangle[b]), vec(triangle[a], triangle[c]));
          if(d < 0) goto next;
          if(d == 0) {
            if(!compare(length(vec(triangle[a], triangle[b])), length(vec(triangle[a], triangle[c])))) {
              {
                point p = vec(triangle[b], triangle[a]);
                point m = vec(triangle[b], triangle[c]);
                point _4th = conj(p / m) * m;
//                _4th = point(round(_4th.real()), round(_4th.imag()));
                if(pnts.find(_4th) == pnts.end()) goto next;
                {
                  point center = midpoint(triangle[b], triangle[c]);
                  check(center, length(vec(center, triangle[0])));
                }
              }
            }
            goto next;
          }
        }
        {
          point center = findCenter(triangle[0], triangle[1], triangle[2]);
          check(center, length(vec(center, triangle[0])));
        }
        next:;
      }
  printf("%.17lf\n", ans);
  return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef complex<double> point;

const double eps = 1e-9;
#define vec(a, b) ((b) - (a))
#define dot(a, b) ((conj(a) * (b)).real())
#define cross(a, b) ((conj(a) * (b)).imag())
#define length(a) (hypot((a).real(), (a).imag()))
#define midpoint(a, b) (((a) + (b)) / 2.0)
#define perp(a) (point(-(a).imag(), (a).real()))

struct _hash {
  int operator()(const point &p) const {
    return p.real() * 20001 + p.imag();
  }
};

int n;
point p[100];
unordered_set<point, _hash> pnts;
double ans = -1;

inline int compare(const double &a, const double &b) {
  if(fabs(a - b) < eps) return 0;
  return a < b ? -1 : 1;
}

bool intersect(const point &a, const point &b, const point &p, const point &q, point &ret) {
  double d1 = cross(p - a, b - a);
  double d2 = cross(q - a, b - a);
  ret = (d1 * q - d2 * p) / (d1 - d2);
  return (fabs(d1 - d2) > eps);
}

point findCenter(const point &a, const point &b, const point &c) {
  point m1 = midpoint(a, b);
  point m2 = midpoint(b, c);
  point p1 = perp(vec(a, b));
  point p2 = perp(vec(b, c));
  point r;
  assert(intersect(m1, m1 + p1, m2, m2 + p2, r));
  return r;
}

void check(const point &center, const double &r) {
  double minDist = 1e9;
  for(int i = 0; i < n; ++i)
    minDist = min(minDist, length(vec(center, p[i])));
  if(compare(minDist, r) < 0) return;
  assert(compare(r, minDist) == 0);
  ans = max(ans, r);
}

int main() {
  scanf("%d", &n);
  for(int i = 0; i < n; ++i) {
    int x, y; scanf("%d %d", &x, &y);
    pnts.insert(p[i] = point(x, y));
  }
  for(int i = 0; i < n; ++i)
    for(int j = i + 1; j < n; ++j)
      for(int k = j + 1; k < n; ++k) {
        point triangle[3] = {p[i], p[j], p[k]};
        for(int a = 0; a < 3; ++a) {
          int b = (a + 1) % 3;
          int c = (b + 1) % 3;
          double d = dot(vec(triangle[a], triangle[b]), vec(triangle[a], triangle[c]));
          if(d < 0) goto next;
          if(d == 0) {
            if(!compare(length(vec(triangle[a], triangle[b])), length(vec(triangle[a], triangle[c])))) {
              {
                point p = vec(triangle[b], triangle[a]);
                point m = vec(triangle[b], triangle[c]);
                point _4th = conj(p / m) * m;
                _4th = point(round(_4th.real()), round(_4th.imag()));
                if(pnts.find(_4th) == pnts.end()) goto next;
                {
                  point center = midpoint(triangle[b], triangle[c]);
                  check(center, length(vec(center, triangle[0])));
                }
              }
            }
            goto next;
          }
        }
        {
          point center = findCenter(triangle[0], triangle[1], triangle[2]);
          check(center, length(vec(center, triangle[0])));
        }
        next:;
      }
  printf("%.17lf\n", ans);
  return 0;
}


#include <functional>/*{{{*/
#include <algorithm>
#include <iostream>
#include <sstream>
#include <numeric>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <string>
#include <cstdio>
#include <vector>
#include <array>
#include <cmath>
#include <queue>
#include <deque>
#include <cmath>
#include <stack>
#include <list>
#include <map>
#include <set>
using namespace std;typedef long long ll;typedef long double real;void run();int main(){ios::sync_with_stdio(0);run();}/*}}}*/

struct vec2{
  real x,y;
  vec2(real x=0,real y=0):x(x),y(y){}
  vec2 operator-(vec2 const a)const{return vec2{x-a.x,y-a.y};}
  vec2 operator+(vec2 const a)const{return vec2{x+a.x,y+a.y};}
  vec2 operator*(real const a)const{return vec2{x*a,y*a};}
  vec2 operator/(real const a)const{return vec2{x/a,y/a};}

  vec2 transverse()const{return vec2{-y,x};}
  real dot(vec2 const a)const{return x*a.x+y*a.y;}
  real cross(vec2 const a)const{return y*a.x-x*a.y;}
  real len()const{return sqrtl(x*x+y*y);}

  bool operator<(vec2 const a)const{return x<a.x or x==a.x and y<a.y;}
};

real frand(int n=40){
  if (not n) return 0;
  return frand(n-1)*0.5L+(rand()%2)-0.5L;
}

vec2 circumcentre(vec2 a,vec2 b,vec2 c){
  vec2 mid=(a+b)/2, add=(c-b);
  vec2 ab=(b-a).transverse(), ac=(c-a).transverse();
  real t=((c/2-b/2).cross(ac))/((ab).cross(ac));
  return (a+b)/2+ab*t;
}

list<array<int,3>> tri;
void push(int a,int b,int c){tri.push_back(array<int,3>{a,b,c});}
vec2 v[103];

void run(){
  int n; cin>>n; for (int i=n; i--;) cin>>v[i].x>>v[i].y;
  cout.precision(12);
  random_shuffle(v,v+n);

  v[n+0]={-1e9L,+1e8L};
  v[n+1]={+1e8L,+1e8L};
  v[n+2]={+1e8L,-1e9L};

  push(n,n+1,n+2);
  for (int i=n; i--;){
    map<pair<int,int>,int> del;
    for (auto it=tri.begin(); it!=tri.end();){
      vec2 centre=circumcentre(v[(*it)[0]],v[(*it)[1]],v[(*it)[2]]);
      if ((centre-v[i]).len()<=(centre-v[(*it)[0]]).len()){
        del[{(*it)[0],(*it)[1]}]^=1;
        del[{(*it)[0],(*it)[2]}]^=1;
        del[{(*it)[1],(*it)[2]}]^=1;
        tri.erase(it++);
      }else{
        ++it;
      }
    }
    for (auto j: del){
      if (j.second and fabsl((v[i]-v[j.first.first]).transverse().dot(v[i]-v[j.first.second]))>1e-6L){
        push(i,j.first.first,j.first.second);
      }
    }
  }

  bool valid=true;
  for (auto i: tri){
    vec2 centre=circumcentre(v[i[0]],v[i[1]],v[i[2]]);
    for (int j=n+3; j--;){
      if ((centre-v[j]).len()<(centre-v[i[0]]).len()-1e-6L){
        valid=false;
      }
    }
  }

  if (not valid){
    cout<<"invalid tessellation"<<endl;
    return;
  }

  real res=-1;
  for (auto i: tri){
    if (i[0]>=n or i[1]>=n or i[2]>=n) continue;
    vec2 centre=circumcentre(v[i[0]],v[i[1]],v[i[2]]);
    vector<int> meet;
    bool ok=true;
    for (int j=n; j--;){
      if ((centre-v[j]).len()<=(centre-v[i[0]]).len()+1e-6L){
        meet.push_back(j);
      }
      if ((centre-v[j]).len()<=(centre-v[i[0]]).len()-1e-6L){
        ok=false;
      }
    }
    ok&=(meet.size()>=3);
    for (int a=3; a--;){
      for (int b=a; b--;){
        if (fabsl((centre-v[i[a]]).transverse().dot(v[i[b]]-v[i[a]]))<=1e-6L){
          bool s=false,t=false;
          for (int c: meet){
            real prod=(centre-v[i[a]]).cross(v[c]-v[i[a]]);
            if (fabsl(prod)<=1e-5L) continue;
            (prod<0?s:t)=true;
          }
          ok&=(s and t);
        }
      }
    }
    real dn[3]={};
    for (int q=0,w=2; q<3; w=q++) dn[q]=(centre-v[i[w]]).cross(v[i[q]]-v[i[w]]); sort(dn,dn+3);
    ok&=(dn[0]*dn[2]>=0);
    if (ok){
      res=max(res,(centre-v[i[0]]).len());
    }
  }

  cout<<res<<endl;
}


/*
    Author: Zhouxing Shi
    Created on Oct29, 2014
*/
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define drep(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i, a, b) for (int i = (a); i < (b); ++i)
#define pb(x) push_back(x)
#define mp(x, y) (make_pair(x, y))
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
const int inf = ~0U >> 1;
const ll INF = ~0ULL >> 1;
template <class T> inline void read(T &n)
{
    char c;
    for (c = getchar(); !(c >= '0' && c <= '9'); c = getchar()); n = c - '0';
    for (c = getchar(); c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0';
}
int Pow(int base, int n, int mo)
{
    if (n == 0) return 1;
    if (n == 1) return base % mo;
    int tmp = Pow(base, n >> 1, mo);
    tmp = (ll)tmp * tmp % mo;
    if (n & 1) tmp = (ll)tmp * base % mo;
    return tmp;
}
//***************************

template<class T> inline T sqr(const T &x) { return x * x; }

int n, m;

struct point
{
	double x, y;
	point(){}
	point(double _x, double _y) : x(_x), y(_y) {}
} a[200], center[105 * 105 * 105 * 2];

double dis(point a, point b)
{
    return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
}

point gen(point a, point b, point c)
{
    point ans;
    double A = sqr(dis(b, c)), B = sqr(dis(a, c)), C = sqr(dis(a, b));
    double AA = dis(b, c), BB = dis(a, c), CC = dis(a, b);

    double S = sqr((a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x)) / 4;
    double aa = B / S / 16 * (C + A - B);
    double bb = C / S / 16 * (A + B - C);
    ans.x = a.x + aa * (b.x - a.x) + bb * (c.x - a.x);
    ans.y = a.y + aa * (b.y - a.y) + bb * (c.y - a.y);
    return ans;
}

inline double cross(const point &a, const point &b, const point &c)
{
	return (c.x - a.x) * (c.y - b.y) - (c.y - a.y) * (c.x - b.x);
}

inline int acute_triangle(const point &a, const point &b, const point &c)
{
	double A = dis(a, b);
	double B = dis(a, c);
	double C = dis(b, c);
	if (A > B) swap(A, B);
	if (A > C) swap(A, C);
	if (B > C) swap(B, C);
	return A * A + B * B - C * C;
}

struct int_point
{
	int x, y;
} b[2000];
map<pair<int, int>, int> Hash;

int main()
{
	scanf("%d", &n);
	rep(i, 1, n)
	{
		scanf("%d%d", &b[i].x, &b[i].y);
		a[i].x = b[i].x; a[i].y = b[i].y;
		Hash[mp(b[i].x, b[i].y)] = 1;
	}
	rep(i, 1, n) rep(j, i + 1, n) rep(k, j + 1, n)
		if (fabs(cross(a[i], a[j], a[k])) > 1e-9 && acute_triangle(a[i], a[j], a[k]) > 1e-9)
			center[++m] = gen(a[i], a[j], a[k]);

	rep(i, 1, n) rep(j, 1, n) rep(k, 1, n)
		if (i != j && i != k && j != k)
			if ((b[j].x - b[i].x) * (b[k].x - b[i].x) + (b[j].y - b[i].y) * (b[k].y - b[i].y))
			{
				int x = b[j].x + b[k].x - a[i].x;
				int y = a[j].y + a[k].y - a[i].y;
				if (Hash[mp(x, y)])
					center[++m] = point((a[j].x + a[k].x) / 2, (a[j].y + a[k].y) / 2);
			}
	int no_holes = 1;
	rep(i, 3, n) if (fabs(cross(a[1], a[2], a[i])) > 1e-9) no_holes = 0;

	if (n <= 2 || no_holes)
	{
		puts("-1");
		return 0;
	}
	if (n == 3 && fabs(acute_triangle(a[1], a[2], a[3])) < 1e-9)
	{
		puts("-1");
		return 0;
	}

	double last = 0;
	rep(i, 1, m)
	{
		double tmp = 1e30;
		rep(j, 1, n) tmp = min(tmp, dis(center[i], a[j]));
		last = max(last, tmp);
	}
	if (fabs(last) < 1e-9) puts("-1");
	else printf("%.10lf\n", last);
    return 0;
}


/*
    Author: Zhouxing Shi
    Created on Oct29, 2014
*/
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define drep(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i, a, b) for (int i = (a); i < (b); ++i)
#define pb(x) push_back(x)
#define mp(x, y) (make_pair(x, y))
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
const int inf = ~0U >> 1;
const ll INF = ~0ULL >> 1;
template <class T> inline void read(T &n)
{
    char c;
    for (c = getchar(); !(c >= '0' && c <= '9'); c = getchar()); n = c - '0';
    for (c = getchar(); c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0';
}
int Pow(int base, int n, int mo)
{
    if (n == 0) return 1;
    if (n == 1) return base % mo;
    int tmp = Pow(base, n >> 1, mo);
    tmp = (ll)tmp * tmp % mo;
    if (n & 1) tmp = (ll)tmp * base % mo;
    return tmp;
}
//***************************

template<class T> inline T sqr(const T &x) { return x * x; }

int n, m;

struct point
{
	double x, y;
	point(){}
	point(double _x, double _y) : x(_x), y(_y) {}
} a[200], center[105 * 105 * 105 * 2], p[105 * 105 * 105 * 2];

double dis(point a, point b)
{
    return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
}

point gen(point a, point b, point c)
{
    point ans;
    double A = sqr(dis(b, c)), B = sqr(dis(a, c)), C = sqr(dis(a, b));
    double AA = dis(b, c), BB = dis(a, c), CC = dis(a, b);

    double S = sqr((a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x)) / 4;
    double aa = B / S / 16 * (C + A - B);
    double bb = C / S / 16 * (A + B - C);
    ans.x = a.x + aa * (b.x - a.x) + bb * (c.x - a.x);
    ans.y = a.y + aa * (b.y - a.y) + bb * (c.y - a.y);
    return ans;
}

inline double cross(const point &a, const point &b, const point &c)
{
	return (c.x - a.x) * (c.y - b.y) - (c.y - a.y) * (c.x - b.x);
}

inline int acute_triangle(const point &a, const point &b, const point &c)
{
	double A = dis(a, b);
	double B = dis(a, c);
	double C = dis(b, c);
	if (A > B) swap(A, B);
	if (A > C) swap(A, C);
	if (B > C) swap(B, C);
	return A * A + B * B - C * C;
}

struct int_point
{
	int x, y;
} b[2000];
map<pair<int, int>, int> Hash;

int main()
{
	scanf("%d", &n);
	rep(i, 1, n)
	{
		scanf("%d%d", &b[i].x, &b[i].y);
		a[i].x = b[i].x; a[i].y = b[i].y;
		Hash[mp(b[i].x, b[i].y)] = 1;
	}
	rep(i, 1, n) rep(j, i + 1, n) rep(k, j + 1, n)
		if (fabs(cross(a[i], a[j], a[k])) > 1e-9 && acute_triangle(a[i], a[j], a[k]) > 1e-9)
			center[++m] = gen(a[i], a[j], a[k]), p[m] = a[i];

	rep(i, 1, n) rep(j, 1, n) rep(k, 1, n)
		if (i != j && i != k && j != k)
			if ((b[j].x - b[i].x) * (b[k].x - b[i].x) + (b[j].y - b[i].y) * (b[k].y - b[i].y) == 0)
			{
				int x = b[j].x + b[k].x - a[i].x;
				int y = a[j].y + a[k].y - a[i].y;
				if (Hash[mp(x, y)])
					center[++m] = point((a[j].x + a[k].x) / 2, (a[j].y + a[k].y) / 2),
					p[m] = a[i];
			}
	int no_holes = 1;
	rep(i, 3, n) if (fabs(cross(a[1], a[2], a[i])) > 1e-9) no_holes = 0;

	if (n <= 2 || no_holes)
	{
		puts("-1");
		return 0;
	}
	if (n == 3 && fabs(acute_triangle(a[1], a[2], a[3])) < 1e-9)
	{
		puts("-1");
		return 0;
	}

	double last = 0;
	rep(i, 1, m)
	{
		double tmp = 1e30;
		rep(j, 1, n) tmp = min(tmp, dis(center[i], a[j]));
		if (tmp >= dis(center[i], p[i]) - 1e-9) last = max(last, tmp);
	}
	if (fabs(last) < 1e-9) puts("-1");
	else printf("%.10lf\n", last);
    return 0;
}


/*
    Author: Zhouxing Shi
    Created on Oct29, 2014
*/
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define drep(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i, a, b) for (int i = (a); i < (b); ++i)
#define pb(x) push_back(x)
#define mp(x, y) (make_pair(x, y))
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
const int inf = ~0U >> 1;
const ll INF = ~0ULL >> 1;
template <class T> inline void read(T &n)
{
    char c;
    for (c = getchar(); !(c >= '0' && c <= '9'); c = getchar()); n = c - '0';
    for (c = getchar(); c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0';
}
int Pow(int base, int n, int mo)
{
    if (n == 0) return 1;
    if (n == 1) return base % mo;
    int tmp = Pow(base, n >> 1, mo);
    tmp = (ll)tmp * tmp % mo;
    if (n & 1) tmp = (ll)tmp * base % mo;
    return tmp;
}
//***************************

template<class T> inline T sqr(const T &x) { return x * x; }

int n, m;

struct point
{
	double x, y;
	point(){}
	point(double _x, double _y) : x(_x), y(_y) {}
} a[200], center[105 * 105 * 105 * 2];

double dis(point a, point b)
{
    return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
}

point gen(point a, point b, point c)
{
    point ans;
    double A = sqr(dis(b, c)), B = sqr(dis(a, c)), C = sqr(dis(a, b));
    double AA = dis(b, c), BB = dis(a, c), CC = dis(a, b);

    double S = sqr((a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x)) / 4;
    double aa = B / S / 16 * (C + A - B);
    double bb = C / S / 16 * (A + B - C);
    ans.x = a.x + aa * (b.x - a.x) + bb * (c.x - a.x);
    ans.y = a.y + aa * (b.y - a.y) + bb * (c.y - a.y);
    return ans;
}

inline double cross(const point &a, const point &b, const point &c)
{
	return (c.x - a.x) * (c.y - b.y) - (c.y - a.y) * (c.x - b.x);
}

inline int acute_triangle(const point &a, const point &b, const point &c)
{
	double A = dis(a, b);
	double B = dis(a, c);
	double C = dis(b, c);
	if (A > B) swap(A, B);
	if (A > C) swap(A, C);
	if (B > C) swap(B, C);
	return A * A + B * B - C * C;
}

struct int_point
{
	int x, y;
} b[2000];
map<pair<int, int>, int> Hash;

int main()
{
	scanf("%d", &n);
	rep(i, 1, n)
	{
		scanf("%d%d", &b[i].x, &b[i].y);
		a[i].x = b[i].x; a[i].y = b[i].y;
		Hash[mp(b[i].x, b[i].y)] = 1;
	}
	rep(i, 1, n) rep(j, i + 1, n) rep(k, j + 1, n)
		if (fabs(cross(a[i], a[j], a[k])) > 1e-9 && acute_triangle(a[i], a[j], a[k]) > 1e-9)
			center[++m] = gen(a[i], a[j], a[k]);

	rep(i, 1, n) rep(j, 1, n) rep(k, 1, n)
		if (i != j && i != k && j != k)
			if ((b[j].x - b[i].x) * (b[k].x - b[i].x) + (b[j].y - b[i].y) * (b[k].y - b[i].y) == 0)
			{
				int x = b[j].x + b[k].x - a[i].x;
				int y = a[j].y + a[k].y - a[i].y;
				if (Hash[mp(x, y)])
					center[++m] = point((a[j].x + a[k].x) / 2, (a[j].y + a[k].y) / 2);
			}
	int no_holes = 1;
	rep(i, 3, n) if (fabs(cross(a[1], a[2], a[i])) > 1e-9) no_holes = 0;

	if (n <= 2 || no_holes)
	{
		puts("-1");
		return 0;
	}
	if (n == 3 && fabs(acute_triangle(a[1], a[2], a[3])) < 1e-9)
	{
		puts("-1");
		return 0;
	}

	double last = 0;
	rep(i, 1, m)
	{
		double tmp = 1e30;
		rep(j, 1, n) tmp = min(tmp, dis(center[i], a[j]));
		last = max(last, tmp);
	}
	if (fabs(last) < 1e-9) puts("-1");
	else printf("%.10lf\n", last);
    return 0;
}


/*
    Author: Zhouxing Shi
    Created on Oct29, 2014
*/
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define drep(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i, a, b) for (int i = (a); i < (b); ++i)
#define pb(x) push_back(x)
#define mp(x, y) (make_pair(x, y))
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
const int inf = ~0U >> 1;
const ll INF = ~0ULL >> 1;
template <class T> inline void read(T &n)
{
    char c;
    for (c = getchar(); !(c >= '0' && c <= '9'); c = getchar()); n = c - '0';
    for (c = getchar(); c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0';
}
int Pow(int base, int n, int mo)
{
    if (n == 0) return 1;
    if (n == 1) return base % mo;
    int tmp = Pow(base, n >> 1, mo);
    tmp = (ll)tmp * tmp % mo;
    if (n & 1) tmp = (ll)tmp * base % mo;
    return tmp;
}
//***************************

template<class T> inline T sqr(const T &x) { return x * x; }

int n, m;

struct point
{
	double x, y;
	point(){}
	point(double _x, double _y) : x(_x), y(_y) {}
} a[200], center[105 * 105 * 105];

double dis(point a, point b)
{
    return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
}

point gen(point a, point b, point c)
{
    point ans;
    double A = sqr(dis(b, c)), B = sqr(dis(a, c)), C = sqr(dis(a, b));
    double AA = dis(b, c), BB = dis(a, c), CC = dis(a, b);

    double S = sqr((a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x)) / 4;
    double aa = B / S / 16 * (C + A - B);
    double bb = C / S / 16 * (A + B - C);
    ans.x = a.x + aa * (b.x - a.x) + bb * (c.x - a.x);
    ans.y = a.y + aa * (b.y - a.y) + bb * (c.y - a.y);
    return ans;
}

double cross(point a, point b, point c)
{
	return (c.x - a.x) * (c.y - b.y) - (c.y - a.y) * (c.x - b.x);
}

int acute_triangle(point a, point b, point c)
{
	double A = dis(a, b);
	double B = dis(a, c);
	double C = dis(b, c);
	if (A > B) swap(A, B);
	if (A > C) swap(A, C);
	if (B > C) swap(B, C);
	return A * A + B * B - C * C > -1e-9;
}

int main()
{
	scanf("%d", &n);
	rep(i, 1, n) scanf("%lf%lf", &a[i].x, &a[i].y);
	rep(i, 1, n) rep(j, i + 1, n) rep(k, j + 1, n)
		if (fabs(cross(a[i], a[j], a[k])) > 1e-9 && acute_triangle(a[i], a[j], a[k]))
			center[++m] = gen(a[i], a[j], a[k]);
	int no_holes = 1;
	rep(i, 3, n) if (fabs(cross(a[1], a[2], a[i])) > 1e-9) no_holes = 0;

	if (n <= 2 || no_holes)
	{
		puts("-1");
		return 0;
	}

	double last = 0;
	rep(i, 1, m)
	{
		double tmp = 1e30;
		rep(j, 1, n) tmp = min(tmp, dis(center[i], a[j]));
		last = max(last, tmp);
	}
	printf("%.10lf\n", last);
    return 0;
}


/*
    Author: Zhouxing Shi
    Created on Oct29, 2014
*/
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define drep(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i, a, b) for (int i = (a); i < (b); ++i)
#define pb(x) push_back(x)
#define mp(x, y) (make_pair(x, y))
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
const int inf = ~0U >> 1;
const ll INF = ~0ULL >> 1;
template <class T> inline void read(T &n)
{
    char c;
    for (c = getchar(); !(c >= '0' && c <= '9'); c = getchar()); n = c - '0';
    for (c = getchar(); c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0';
}
int Pow(int base, int n, int mo)
{
    if (n == 0) return 1;
    if (n == 1) return base % mo;
    int tmp = Pow(base, n >> 1, mo);
    tmp = (ll)tmp * tmp % mo;
    if (n & 1) tmp = (ll)tmp * base % mo;
    return tmp;
}
//***************************

template<class T> inline T sqr(const T &x) { return x * x; }

int n, m;

struct point
{
	double x, y;
	point(){}
	point(double _x, double _y) : x(_x), y(_y) {}
} a[200], center[105 * 105 * 105];

double dis(point a, point b)
{
    return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
}

point gen(point a, point b, point c)
{
    point ans;
    double A = sqr(dis(b, c)), B = sqr(dis(a, c)), C = sqr(dis(a, b));
    double AA = dis(b, c), BB = dis(a, c), CC = dis(a, b);

    double S = sqr((a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x)) / 4;
    double aa = B / S / 16 * (C + A - B);
    double bb = C / S / 16 * (A + B - C);
    ans.x = a.x + aa * (b.x - a.x) + bb * (c.x - a.x);
    ans.y = a.y + aa * (b.y - a.y) + bb * (c.y - a.y);
    return ans;
}

double cross(point a, point b, point c)
{
	return (c.x - a.x) * (c.y - b.y) - (c.y - a.y) * (c.x - b.x);
}

int acute_triangle(point a, point b, point c)
{
	double A = dis(a, b);
	double B = dis(a, c);
	double C = dis(b, c);
	if (A > B) swap(A, B);
	if (A > C) swap(A, C);
	if (B > C) swap(B, C);
	return A * A + B * B - C * C;
}

int main()
{
	scanf("%d", &n);
	rep(i, 1, n) scanf("%lf%lf", &a[i].x, &a[i].y);
	rep(i, 1, n) rep(j, i + 1, n) rep(k, j + 1, n)
		if (fabs(cross(a[i], a[j], a[k])) > 1e-9 && acute_triangle(a[i], a[j], a[k]) > 1e-9)
			center[++m] = gen(a[i], a[j], a[k]);
	rep(i, 1, n) rep(j, 1, n) rep(k, 1, n) rep(l, 1, n)
		if (i != j && i != k && i != l && j != k && j != l && k != l)
		{
			if (fabs(acute_triangle(a[i], a[j], a[k])) > 1e-9) continue;
			if (fabs(acute_triangle(a[i], a[j], a[l])) > 1e-9) continue;
			if (fabs(acute_triangle(a[i], a[k], a[l])) > 1e-9) continue;
			if (fabs(acute_triangle(a[j], a[k], a[l])) > 1e-9) continue;
			center[++m] = point((a[i].x + a[k].x) / 2, (a[i].y + a[k].y) / 2);
		}
	int no_holes = 1;
	rep(i, 3, n) if (fabs(cross(a[1], a[2], a[i])) > 1e-9) no_holes = 0;

	if (n <= 2 || no_holes)
	{
		puts("-1");
		return 0;
	}
	if (n == 3 && fabs(acute_triangle(a[1], a[2], a[3])) < 1e-9)
	{
		puts("-1");
		return 0;
	}

	double last = 0;
	rep(i, 1, m)
	{
		double tmp = 1e30;
		rep(j, 1, n) tmp = min(tmp, dis(center[i], a[j]));
		last = max(last, tmp);
	}
	printf("%.10lf\n", last);
    return 0;
}


/*
    Author: Zhouxing Shi
    Created on Oct29, 2014
*/
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define drep(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i, a, b) for (int i = (a); i < (b); ++i)
#define pb(x) push_back(x)
#define mp(x, y) (make_pair(x, y))
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
const int inf = ~0U >> 1;
const ll INF = ~0ULL >> 1;
template <class T> inline void read(T &n)
{
    char c;
    for (c = getchar(); !(c >= '0' && c <= '9'); c = getchar()); n = c - '0';
    for (c = getchar(); c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0';
}
int Pow(int base, int n, int mo)
{
    if (n == 0) return 1;
    if (n == 1) return base % mo;
    int tmp = Pow(base, n >> 1, mo);
    tmp = (ll)tmp * tmp % mo;
    if (n & 1) tmp = (ll)tmp * base % mo;
    return tmp;
}
//***************************

template<class T> inline T sqr(const T &x) { return x * x; }

int n, m;

struct point
{
	double x, y;
	point(){}
	point(double _x, double _y) : x(_x), y(_y) {}
} a[200], center[105 * 105 * 105];

double dis(point a, point b)
{
    return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
}

point gen(point a, point b, point c)
{
    point ans;
    double A = sqr(dis(b, c)), B = sqr(dis(a, c)), C = sqr(dis(a, b));
    double AA = dis(b, c), BB = dis(a, c), CC = dis(a, b);

    double S = sqr((a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x)) / 4;
    double aa = B / S / 16 * (C + A - B);
    double bb = C / S / 16 * (A + B - C);
    ans.x = a.x + aa * (b.x - a.x) + bb * (c.x - a.x);
    ans.y = a.y + aa * (b.y - a.y) + bb * (c.y - a.y);
    return ans;
}

double cross(point a, point b, point c)
{
	return (c.x - a.x) * (c.y - b.y) - (c.y - a.y) * (c.x - b.x);
}

int acute_triangle(point a, point b, point c)
{
	double A = dis(a, b);
	double B = dis(a, c);
	double C = dis(b, c);
	if (A > B) swap(A, B);
	if (A > C) swap(A, C);
	if (B > C) swap(B, C);
	return A * A + B * B - C * C;
}

int main()
{
	scanf("%d", &n);
	rep(i, 1, n) scanf("%lf%lf", &a[i].x, &a[i].y);
	rep(i, 1, n) rep(j, i + 1, n) rep(k, j + 1, n)
		if (fabs(cross(a[i], a[j], a[k])) > 1e-9 && acute_triangle(a[i], a[j], a[k]) > 1e-9)
			center[++m] = gen(a[i], a[j], a[k]);
	rep(i, 1, n) rep(j, 1, n) rep(k, 1, n) rep(l, 1, n)
		if (i != j && i != k && i != l && j != k && j != l && k != l)
		{
			if (fabs(acute_triangle(a[i], a[j], a[k])) > 1e-9) continue;
			if (fabs(acute_triangle(a[i], a[j], a[l])) > 1e-9) continue;
			if (fabs(acute_triangle(a[i], a[k], a[l])) > 1e-9) continue;
			if (fabs(acute_triangle(a[j], a[k], a[l])) > 1e-9) continue;
			center[++m] = point((a[i].x + a[k].x) / 2, (a[i].y + a[k].y) / 2);
		}
	int no_holes = 1;
	rep(i, 3, n) if (fabs(cross(a[1], a[2], a[i])) > 1e-9) no_holes = 0;

	if (n <= 2 || no_holes)
	{
		puts("-1");
		return 0;
	}
	if (n == 3 && fabs(acute_triangle(a[1], a[2], a[3])) < 1e-9)
	{
		puts("-1");
		return 0;
	}

	double last = 0;
	rep(i, 1, m)
	{
		double tmp = 1e30;
		rep(j, 1, n) tmp = min(tmp, dis(center[i], a[j]));
		last = max(last, tmp);
	}
	if (fabs(last) < 1e-9) puts("-1");
	else printf("%.10lf\n", last);
    return 0;
}


/*
    Author: Zhouxing Shi
    Created on Oct29, 2014
*/
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define drep(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i, a, b) for (int i = (a); i < (b); ++i)
#define pb(x) push_back(x)
#define mp(x, y) (make_pair(x, y))
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
const int inf = ~0U >> 1;
const ll INF = ~0ULL >> 1;
template <class T> inline void read(T &n)
{
    char c;
    for (c = getchar(); !(c >= '0' && c <= '9'); c = getchar()); n = c - '0';
    for (c = getchar(); c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0';
}
int Pow(int base, int n, int mo)
{
    if (n == 0) return 1;
    if (n == 1) return base % mo;
    int tmp = Pow(base, n >> 1, mo);
    tmp = (ll)tmp * tmp % mo;
    if (n & 1) tmp = (ll)tmp * base % mo;
    return tmp;
}
//***************************

template<class T> inline T sqr(const T &x) { return x * x; }

int n, m;

struct point
{
	double x, y;
	point(){}
	point(double _x, double _y) : x(_x), y(_y) {}
} a[200], center[105 * 105 * 105 * 2], p[105 * 105 * 105 * 2];

double dis(point a, point b)
{
    return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
}

point gen(point a, point b, point c)
{
    point ans;
    double A = sqr(dis(b, c)), B = sqr(dis(a, c)), C = sqr(dis(a, b));
    double AA = dis(b, c), BB = dis(a, c), CC = dis(a, b);

    double S = sqr((a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x)) / 4;
    double aa = B / S / 16 * (C + A - B);
    double bb = C / S / 16 * (A + B - C);
    ans.x = a.x + aa * (b.x - a.x) + bb * (c.x - a.x);
    ans.y = a.y + aa * (b.y - a.y) + bb * (c.y - a.y);
    return ans;
}

inline double cross(const point &a, const point &b, const point &c)
{
	return (c.x - a.x) * (c.y - b.y) - (c.y - a.y) * (c.x - b.x);
}

inline int acute_triangle(const point &a, const point &b, const point &c)
{
	double A = dis(a, b);
	double B = dis(a, c);
	double C = dis(b, c);
	if (A > B) swap(A, B);
	if (A > C) swap(A, C);
	if (B > C) swap(B, C);
	return A * A + B * B - C * C;
}

struct int_point
{
	int x, y;
} b[2000];
map<pair<int, int>, int> Hash;

int main()
{
	scanf("%d", &n);
	rep(i, 1, n)
	{
		scanf("%d%d", &b[i].x, &b[i].y);
		a[i].x = b[i].x; a[i].y = b[i].y;
		Hash[mp(b[i].x, b[i].y)] = 1;
	}
	rep(i, 1, n) rep(j, i + 1, n) rep(k, j + 1, n)
		if (fabs(cross(a[i], a[j], a[k])) > 1e-9 && acute_triangle(a[i], a[j], a[k]) > 1e-9)
			center[++m] = gen(a[i], a[j], a[k]), p[m] = a[i];

	rep(i, 1, n) rep(j, 1, n) rep(k, 1, n)
		if (i != j && i != k && j != k)
			if ((b[j].x - b[i].x) * (b[k].x - b[i].x) + (b[j].y - b[i].y) * (b[k].y - b[i].y) == 0)
			{
				int x = b[j].x + b[k].x - a[i].x;
				int y = a[j].y + a[k].y - a[i].y;
				if (Hash[mp(x, y)])
					center[++m] = point((a[j].x + a[k].x) / 2, (a[j].y + a[k].y) / 2),
					p[m] = a[i];
			}
	int no_holes = 1;
	rep(i, 3, n) if (fabs(cross(a[1], a[2], a[i])) > 1e-9) no_holes = 0;

	if (n <= 2 || no_holes)
	{
		puts("-1");
		return 0;
	}
	if (n == 3 && fabs(acute_triangle(a[1], a[2], a[3])) < 1e-9)
	{
		puts("-1");
		return 0;
	}

	double last = 0;
	rep(i, 1, m)
	{
		double tmp = 1e30;
		rep(j, 1, n) tmp = min(tmp, dis(center[i], a[j]));
		if (tmp >= dis(center[i], p[i])) last = max(last, tmp);
	}
	if (fabs(last) < 1e-9) puts("-1");
	else printf("%.10lf\n", last);
    return 0;
}


/*
    Author: Zhouxing Shi
    Created on Oct29, 2014
*/
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define drep(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i, a, b) for (int i = (a); i < (b); ++i)
#define pb(x) push_back(x)
#define mp(x, y) (make_pair(x, y))
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
const int inf = ~0U >> 1;
const ll INF = ~0ULL >> 1;
template <class T> inline void read(T &n)
{
    char c;
    for (c = getchar(); !(c >= '0' && c <= '9'); c = getchar()); n = c - '0';
    for (c = getchar(); c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0';
}
int Pow(int base, int n, int mo)
{
    if (n == 0) return 1;
    if (n == 1) return base % mo;
    int tmp = Pow(base, n >> 1, mo);
    tmp = (ll)tmp * tmp % mo;
    if (n & 1) tmp = (ll)tmp * base % mo;
    return tmp;
}
//***************************

template<class T> inline T sqr(const T &x) { return x * x; }

int n, m;

struct point
{
	double x, y;
	point(){}
	point(double _x, double _y) : x(_x), y(_y) {}
} a[200], center[105 * 105 * 105];

double dis(point a, point b)
{
    return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
}

point gen(point a, point b, point c)
{
    point ans;
    double A = sqr(dis(b, c)), B = sqr(dis(a, c)), C = sqr(dis(a, b));
    double AA = dis(b, c), BB = dis(a, c), CC = dis(a, b);

    double S = sqr((a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x)) / 4;
    double aa = B / S / 16 * (C + A - B);
    double bb = C / S / 16 * (A + B - C);
    ans.x = a.x + aa * (b.x - a.x) + bb * (c.x - a.x);
    ans.y = a.y + aa * (b.y - a.y) + bb * (c.y - a.y);
    return ans;
}

inline double cross(const point &a, const point &b, const point &c)
{
	return (c.x - a.x) * (c.y - b.y) - (c.y - a.y) * (c.x - b.x);
}

inline int acute_triangle(const point &a, const point &b, const point &c)
{
	double A = dis(a, b);
	double B = dis(a, c);
	double C = dis(b, c);
	if (A > B) swap(A, B);
	if (A > C) swap(A, C);
	if (B > C) swap(B, C);
	return A * A + B * B - C * C;
}

int main()
{
	scanf("%d", &n);
	rep(i, 1, n) scanf("%lf%lf", &a[i].x, &a[i].y);
	rep(i, 1, n) rep(j, i + 1, n) rep(k, j + 1, n)
		if (fabs(cross(a[i], a[j], a[k])) > 1e-9 && acute_triangle(a[i], a[j], a[k]) > 1e-9)
			center[++m] = gen(a[i], a[j], a[k]);
	rep(i, 1, n) rep(j, 1, n) rep(k, 1, n) rep(l, 1, n)
		if (i != j && i != k && i != l && j != k && j != l && k != l)
		{
			if (fabs(acute_triangle(a[i], a[j], a[k])) > 1e-9) continue;
			if (fabs(acute_triangle(a[i], a[j], a[l])) > 1e-9) continue;
			if (fabs(acute_triangle(a[i], a[k], a[l])) > 1e-9) continue;
			if (fabs(acute_triangle(a[j], a[k], a[l])) > 1e-9) continue;
			center[++m] = point((a[i].x + a[k].x) / 2, (a[i].y + a[k].y) / 2);
		}
	int no_holes = 1;
	rep(i, 3, n) if (fabs(cross(a[1], a[2], a[i])) > 1e-9) no_holes = 0;

	if (n <= 2 || no_holes)
	{
		puts("-1");
		return 0;
	}
	if (n == 3 && fabs(acute_triangle(a[1], a[2], a[3])) < 1e-9)
	{
		puts("-1");
		return 0;
	}

	double last = 0;
	rep(i, 1, m)
	{
		double tmp = 1e30;
		rep(j, 1, n) tmp = min(tmp, dis(center[i], a[j]));
		last = max(last, tmp);
	}
	if (fabs(last) < 1e-9) puts("-1");
	else printf("%.10lf\n", last);
    return 0;
}


/*
    Author: Zhouxing Shi
    Created on Oct29, 2014
*/
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define drep(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i, a, b) for (int i = (a); i < (b); ++i)
#define pb(x) push_back(x)
#define mp(x, y) (make_pair(x, y))
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
const int inf = ~0U >> 1;
const ll INF = ~0ULL >> 1;
template <class T> inline void read(T &n)
{
    char c;
    for (c = getchar(); !(c >= '0' && c <= '9'); c = getchar()); n = c - '0';
    for (c = getchar(); c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0';
}
int Pow(int base, int n, int mo)
{
    if (n == 0) return 1;
    if (n == 1) return base % mo;
    int tmp = Pow(base, n >> 1, mo);
    tmp = (ll)tmp * tmp % mo;
    if (n & 1) tmp = (ll)tmp * base % mo;
    return tmp;
}
//***************************

template<class T> inline T sqr(const T &x) { return x * x; }

int n, m;

struct point
{
	double x, y;
	point(){}
	point(double _x, double _y) : x(_x), y(_y) {}
} a[200], center[105 * 105 * 105];

double dis(point a, point b)
{
    return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
}

point gen(point a, point b, point c)
{
    point ans;
    double A = sqr(dis(b, c)), B = sqr(dis(a, c)), C = sqr(dis(a, b));
    double AA = dis(b, c), BB = dis(a, c), CC = dis(a, b);

    double S = sqr((a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x)) / 4;
    double aa = B / S / 16 * (C + A - B);
    double bb = C / S / 16 * (A + B - C);
    ans.x = a.x + aa * (b.x - a.x) + bb * (c.x - a.x);
    ans.y = a.y + aa * (b.y - a.y) + bb * (c.y - a.y);
    return ans;
}

double cross(point a, point b, point c)
{
	return (c.x - a.x) * (c.y - b.y) - (c.y - a.y) * (c.x - b.x);
}

int acute_triangle(point a, point b, point c)
{
	double A = dis(a, b);
	double B = dis(a, c);
	double C = dis(b, c);
	if (A > B) swap(A, B);
	if (A > C) swap(A, C);
	if (B > C) swap(B, C);
	return A * A + B * B - C * C > 1e-9;
}

int main()
{
	scanf("%d", &n);
	rep(i, 1, n) scanf("%lf%lf", &a[i].x, &a[i].y);
	rep(i, 1, n) rep(j, i + 1, n) rep(k, j + 1, n)
		if (fabs(cross(a[i], a[j], a[k])) > 1e-9 && acute_triangle(a[i], a[j], a[k]))
			center[++m] = gen(a[i], a[j], a[k]);
	int no_holes = 1;
	rep(i, 3, n) if (fabs(cross(a[1], a[2], a[i])) > 1e-9) no_holes = 0;

	if (n <= 2 || no_holes)
	{
		puts("-1");
		return 0;
	}

	double last = 0;
	rep(i, 1, m)
	{
		double tmp = 1e30;
		rep(j, 1, n) tmp = min(tmp, dis(center[i], a[j]));
		last = max(last, tmp);
	}
	printf("%.10lf\n", last);
    return 0;
}


#include <cassert>
#include <cstring>

#include <algorithm>
#include <iostream>

using namespace std;

#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define TRACE(x) cout << #x << " = " << x << endl
#define _ << " _ " <<

#ifdef ONLINE_JUDGE
# define LLD "%I64d"
#else
# define LLD "%ll" "d"
#endif

typedef long long llint;

const double eps = 1e-9;
inline double eq(double a, double b) { return fabs(a-b) < eps; }
inline double sq(double a) { return a*a; }

struct Pt { // 2D (z homog.) or 3D
  double x, y, z;
  Pt(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}
  friend Pt operator + (Pt a, Pt b) { return {a.x+b.x, a.y+b.y, a.z+b.z}; }
  friend Pt operator - (Pt a, Pt b) { return {a.x-b.x, a.y-b.y, a.z-b.z}; }
  friend Pt operator * (double k, Pt a) { return {k*a.x, k*a.y, k*a.z}; }
  friend Pt operator / (Pt a, double k) { return {a.x/k, a.y/k, a.z/k}; }
};

double get_sq_len(Pt a) { return a.x*a.x + a.y*a.y + a.z*a.z; } // check: has all 3 terms (x,y,z)
double get_len(Pt a) { return sqrt(get_sq_len(a)); }
double dot(Pt a, Pt b) { return a.x*b.x + a.y*b.y + a.z*b.z; } // check: <up>
Pt cross(Pt a, Pt b) { // 3d or homogen. cross product
  Pt ans;
  ans.x = a.y*b.z - a.z*b.y;
  ans.y = a.z*b.x - a.x*b.z;
  ans.z = a.x*b.y - a.y*b.x;
  return ans;
}

struct Line { // 2D or 3D
  Pt a, b;
};
Pt get_line_abc(Line L) { // A*x + B*y + C = 0... 2D only!
  Pt ans = cross((Pt){L.a.x, L.a.y, 1}, {L.b.x, L.b.y, 1});
  assert(dot({L.a.x, L.a.y, 1}, ans) == 0);
  assert(dot({L.b.x, L.b.y, 1}, ans) == 0);
  return ans;
}

Pt bisector_abc(Pt a, Pt b) {
  Pt mid = (a + b) / 2;
  Line L = {a, b};
  Pt abc = get_line_abc(L);
  abc = {abc.y, -abc.x, 0}; abc.z = -(abc.x*mid.x + abc.y*mid.y);
  return abc;
}

int main(void)
{
  int n; scanf("%d", &n);
  vector<Pt> pts;
  REP(i, n) {
    int x, y; scanf("%d %d", &x, &y);
    pts.push_back(Pt(x, y));
  }

  double ans = -1;
  REP(i, n) REP(j, i) REP(k, j) {
    double asq = get_sq_len(pts[i] - pts[j]);
    double bsq = get_sq_len(pts[j] - pts[k]);
    double csq = get_sq_len(pts[k] - pts[i]);
    if (asq > bsq) swap(asq, bsq);
    if (asq > csq) swap(asq, csq);
    if (bsq > csq) swap(bsq, csq);
    if (asq + bsq > csq) {
      Pt ab = bisector_abc(pts[i], pts[j]);
      Pt bc = bisector_abc(pts[i], pts[k]);
      Pt sred = cross(ab, bc);
      assert(sred.z != 0);
      sred.x /= sred.z; sred.y /= sred.z; sred.z = 0;

      double sol_R = get_len(sred - pts[i]);
      double closest = 1e100;
      REP(iter, n) {
        closest = min(closest, get_len(sred - pts[iter]));
      }
      if (eq(sol_R, closest)) ans = max(ans, closest);
    }
  }

  auto pravi = [](Pt a, Pt b, Pt c) -> bool {
    return eq(get_sq_len(a - b) + get_sq_len(b - c), get_sq_len(a-c));
  };

  REP(i, n) REP(j, n) {
    REP(k, n) {
      if (!pravi(pts[i], pts[j], pts[k])) continue;
      REP(l, n) {
        if (i == j || i == k || i == l || j == k || j == l || k == l) continue;
        if (pravi(pts[j], pts[k], pts[l]) && pravi(pts[k], pts[l], pts[i]) && pravi(pts[l], pts[i], pts[j])) {
          Pt sred = (pts[i] + pts[k]) / 2;
          double closest = 1e100;
          REP(iter, n) {
            closest = min(closest, get_len(sred - pts[iter]));
          }
          if (eq(closest, get_len(pts[i] - pts[j])/sqrt(2))) ans = max(ans, closest);
        }
      }
    }
  }

  if (ans == -1) printf("-1\n");
  else printf("%.8lf\n", ans);

  return 0;
}


#include <cassert>
#include <cstring>

#include <algorithm>
#include <iostream>

using namespace std;

#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define TRACE(x) cout << #x << " = " << x << endl
#define _ << " _ " <<

#ifdef ONLINE_JUDGE
# define LLD "%I64d"
#else
# define LLD "%ll" "d"
#endif

typedef long long llint;

/**** Dio geometrijskog libraryja --- nedovrsen jos! - tested (WF2007 Collecting Luggage)***/
// greske: imam li svugdje z? (3 dijela formule?)
// greske: (val > eps) - (val < eps) umjesto (val < -eps)
// greske: poredak parametara!

const double eps = 1e-9;
inline double eq(double a, double b) { return fabs(a-b) < eps; }

struct Pt { // 2D (z homog.) or 3D
  double x, y, z;
  Pt(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}
  friend Pt operator + (Pt a, Pt b) { return {a.x+b.x, a.y+b.y, a.z+b.z}; }
  friend Pt operator - (Pt a, Pt b) { return {a.x-b.x, a.y-b.y, a.z-b.z}; }
  friend Pt operator * (double k, Pt a) { return {k*a.x, k*a.y, k*a.z}; }
  friend Pt operator / (Pt a, double k) { return {a.x/k, a.y/k, a.z/k}; }
};
double get_sq_len(Pt a) { return a.x*a.x + a.y*a.y + a.z*a.z; } // check: has all 3 terms (x,y,z)
double get_len(Pt a) { return sqrt(get_sq_len(a)); }
double dot(Pt a, Pt b) { return a.x*b.x + a.y*b.y + a.z*b.z; } // check: <up>
Pt cross(Pt a, Pt b) { // 3d or homogen. cross product
  Pt ans;
  ans.x = a.y*b.z - a.z*b.y;
  ans.y = a.z*b.x - a.x*b.z;
  ans.z = a.x*b.y - a.y*b.x;
  return ans;
}

typedef Pt ABC; // LINE! 2D line in Ax + By + C = 0 format

struct Line { // 2D or 3D
  Pt a, b;
};

ABC line_to_abc(Line L) { // A*x + B*y + C = 0... 2D only!
  ABC ans = cross((Pt){L.a.x, L.a.y, 1}, {L.b.x, L.b.y, 1});
  assert(dot({L.a.x, L.a.y, 1}, ans) == 0);
  assert(dot({L.b.x, L.b.y, 1}, ans) == 0);
  return ans;
}

Pt intersect_lines(ABC a, ABC b) { // 2D only!
  Pt ans = cross(a, b);
  assert(ans.z != 0);
  return {ans.x/ans.z, ans.y/ans.z, 0};
}

ABC abc_through_pt(ABC abc, Pt p) {
  return {abc.x, abc.y, -(abc.x*p.x + abc.y*p.y)};
}

ABC bisector(Pt a, Pt b) { // 2d only
  ABC abc = line_to_abc({a, b});
  return abc_through_pt({abc.y, -abc.x, 0}, (a + b) / 2);
}

int ccw(Pt a, Pt b, Pt c) { // 2D only!
  double sum = 0;
  sum += a.x * (b.y - c.y);
  sum += b.x * (c.y - a.y);
  sum += c.x * (a.y - b.y);
  return (sum > eps) - (sum < -eps);
}

//////////////////////// 3D //////////////////////////

struct Plane { // 3D only
  Pt norm; double d; // norm*x + d == 0
};

int get_pt_plane_side(Pt x, Plane plane) { // 3D.. 1 -> above, -1 -> below, 0 -> on plane
  double val = dot(plane.norm, x) + plane.d;
  return (val > eps) - (val < -eps); // check eps, -eps
}

Pt intersect_line_plane(Line L, Plane plane) { // 3D
  Pt delta = L.b - L.a;
  double t = ( -plane.d - dot(L.a, plane.norm) ) / dot(delta, plane.norm);
  Pt ans = L.a + t*delta;
  return ans;
}

Pt project_to_plane(Pt x, Plane plane) { // project point to plane
  Line L = {x, x+plane.norm};
  Pt ans = intersect_line_plane(L, plane);
  return ans;
}

Plane get_plane_from_pts(Pt a, Pt b, Pt c) { // plane equation from 3 points
  Plane ans;
  ans.norm = cross(c-a, b-a);
  ans.d = -dot(ans.norm, a);
  // assert(get_len(ans.norm) > eps); // they should not be collinear?
  return ans;
}

double dist_pt_plane(Pt a, Plane plane) { // 3D... point-plane distance
  double ans = fabs((dot(a, plane.norm) + plane.d) / get_len(plane.norm));
  return ans;
}

int ccw_3d(Plane plane, Pt a, Pt b, Pt c) { // 3D... a, b, c should be on the plane
  double val = dot(plane.norm, cross(b-a, c-a)); // NEMA +plane.d !
  return (val > eps) - (val < -eps); // eps, -eps
}

double triangle_area_3d(Pt a, Pt b, Pt c) {
  return get_len(cross(c-a, b-a)) / 2; // positive! check: /2
}
// tetrahedron volume
double tetra_vol(Pt a, Pt b, Pt c, Pt d) { return dot(cross(b-a, c-a), d-a) / 6; }
// tetrahedron center of mass
Pt tetra_cm(Pt a, Pt b, Pt c, Pt d) { return (a+b+c+d) / 4; }

double dist_pt_segment(Pt p, Pt a, Pt b) { // point, segment dist
  // check: order of args
  if (get_sq_len(p-b) > get_sq_len(p-a) + get_sq_len(a-b)) return get_len(p-a);
  if (get_sq_len(p-a) > get_sq_len(p-b) + get_sq_len(a-b)) return get_len(p-b);
  return 2 * triangle_area_3d(a, b, p) / get_len(a-b);
}

double dist_pt_hull_3d(Plane plane, vector<Pt> pts, Pt p) { // 3D
  // poly = polygon defined by hull of pts
  // if the p is inside poly, get pt-poly dist
  // if it's outside return -1

  int npts = pts.size();
  double ans = 1e100;
  FOR(i, 0, npts) FOR(j, i+1, npts) {
    bool plus = false, minus = false;
    REP(k, npts) {
      int val = ccw_3d(plane, pts[i], pts[j], pts[k]);
      if (val > 0) plus = true;
      if (val < 0) minus = true;
    }

    if (plus && minus) continue; // pts[i]..pts[j] isn't on the hull
    if (ccw_3d(plane, pts[i], pts[j], p) * (plus - minus) == -1) {
      // p is outside of the polygon
      return -1;
    }
    double val = dist_pt_segment(p, pts[i], pts[j]);
    if (val < ans) ans = val;
  }
  return ans;
}

////////////////////////// other geom algos ///////////////////////////////

// point STRICTLY inside a line segment (not on it's endpoints)
bool point_in_segment(Pt p, Pt a, Pt b) { // 2D !!!
  if (ccw(a, b, p) != 0) return false;

  if (min(a.x, b.x) <= p.x && p.x <= max(a.x, b.x))
    if (min(a.y, b.y) < p.y && p.y < max(a.y, b.y))
      return true;
  if (min(a.x, b.x) < p.x && p.x < max(a.x, b.x))
    if (min(a.y, b.y) <= p.y && p.y <= max(a.y, b.y))
      return true;

  return false;
}

// point STRICTLY in polygon
bool point_in_poly(const vector<Pt>& P, Pt p) {
  int np = P.size();
  int wind = 0;

  REP(i, np) {
    Pt a = P[i];
    Pt b = P[(i+1)%np];
    if (point_in_segment(p, a, b)) return false;

    if (b.y > a.y) { // rising segments
      if (a.y <= p.y && p.y < b.y)
        if (ccw(a, b, p) > 0)
          ++wind;
    } else if (b.y < a.y) { // falling segments
      if (a.y > p.y && p.y >= b.y)
        if (ccw(a, b, p) <= 0)
          --wind;
    } if (a.y == b.y && a.y == p.y) { // horizontal segments
      if (a.x < b.x) { // to the right
        if (a.x < p.x && p.x <= b.x) --wind;
      }
    }
  }

  return (wind > 0);
}

// does the segment (a, b) only touch the polygon P?
// no point on P can lie strictly within, but touching at endpoints is allowed
bool intersects_inside(const vector<Pt>& P, Pt a, Pt b) {
  int np = P.size();
  REP(i, np) if (point_in_segment(P[i], a, b)) return true;

  REP(i, np) {
    int j = (i+1) % np;
    int abi = ccw(a, b, P[i]);
    int abj = ccw(a, b, P[j]);
    int ija = ccw(P[i], P[j], a);
    int ijb = ccw(P[i], P[j], b);

    if (abi*abj == -1 && ija*ijb == -1) return true;
  }

  Pt mid = {a.x+b.x, a.y+b.y}; mid.x /= 2; mid.y /= 2; // DOUBLE!!?!
  return point_in_poly(P, mid); // point in poly -> return yes
}

int main(void)
{
  int n; scanf("%d", &n);
  vector<Pt> pts;
  REP(i, n) {
    int x, y; scanf("%d %d", &x, &y);
    pts.push_back(Pt(x, y));
  }

  double ans = -1;
  REP(i, n) REP(j, i) REP(k, j) {
    double asq = get_sq_len(pts[i] - pts[j]);
    double bsq = get_sq_len(pts[j] - pts[k]);
    double csq = get_sq_len(pts[k] - pts[i]);
    if (asq > bsq) swap(asq, bsq);
    if (asq > csq) swap(asq, csq);
    if (bsq > csq) swap(bsq, csq);
    if (asq + bsq > csq) {
      Pt ab = bisector(pts[i], pts[j]);
      Pt bc = bisector(pts[i], pts[k]);
      Pt sred = cross(ab, bc);
      assert(sred.z != 0);
      sred.x /= sred.z; sred.y /= sred.z; sred.z = 0;

      double sol_R = get_len(sred - pts[i]);
      double closest = 1e100;
      REP(iter, n) {
        closest = min(closest, get_len(sred - pts[iter]));
      }
      if (eq(sol_R, closest)) ans = max(ans, closest);
    }
  }

  auto pravi = [](Pt a, Pt b, Pt c) -> bool {
    return eq(get_sq_len(a - b) + get_sq_len(b - c), get_sq_len(a-c));
  };

  REP(i, n) REP(j, n) {
    REP(k, n) {
      if (!pravi(pts[i], pts[j], pts[k])) continue;
      REP(l, n) {
        if (i == j || i == k || i == l || j == k || j == l || k == l) continue;
        if (pravi(pts[j], pts[k], pts[l]) && pravi(pts[k], pts[l], pts[i]) && pravi(pts[l], pts[i], pts[j])) {
          Pt sred = (pts[i] + pts[k]) / 2;
          double closest = 1e100;
          REP(iter, n) {
            closest = min(closest, get_len(sred - pts[iter]));
          }
          if (eq(closest, get_len(pts[i] - pts[j])/sqrt(2))) ans = max(ans, closest);
        }
      }
    }
  }

  if (ans == -1) printf("-1\n");
  else printf("%.8lf\n", ans);

  return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>
#include<vector>
#include<map>
#include<queue>
#include<string>
#include<bitset>
#include<iomanip>
#include<iostream>
#include<cmath>
using namespace std;
#define rep(i,x,y) for(i=x;i<=y;i++)
#define _rep(i,x,y) for(i=x;i>=y;i--)
#define REP(i,x,y) for(int i=(x);i<=(y);i++)
#define _REP(i,x,y) for(int i=(x);i>=(y);i--)
#define CL(S,x) memset(S,x,sizeof(S))
#define CP(S1,S2) memcpy(S1,S2,sizeof(S2))
#define ALL(x,S) for(x=S.begin();x!=S.end();x++)
#define pb push_back
#define IN insert
#define ER erase
#define BE begin()
#define ED end()
#define LB lower_bound
#define UB upper_bound
#define mp make_pair
#define fi first
#define se second
#define upmin(x,y) x=min(x,y)
#define upmax(x,y) x=max(x,y)
#define COUT(S,x) cout<<fixed<<setprecision(x)<<S<<endl
template<class T> inline void read(T&x){bool fu=0;char c;for(c=getchar();c<=32;c=getchar());if(c=='-')fu=1,c=getchar();for(x=0;c>32;c=getchar())x=x*10+c-'0';if(fu)x=-x;};
template<class T> inline void read(T&x,T&y){read(x);read(y);}
template<class T> inline void read(T&x,T&y,T&z){read(x);read(y);read(z);}
inline char getc(){char c;for(c=getchar();c<=32;c=getchar());return c;}

typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;

#define sqr(x) ((x)*(x))

int n,i,j,k,l,p;bool op;
struct node{ld x,y;}a[110];
node operator-(node a,node b){return(node){a.x-b.x,a.y-b.y};}
ld dis(node a){return sqrt(a.x*a.x+a.y*a.y);}

ld G(ld a,ld b,ld c,ld d){return a*d-b*c;}
node get(node p1,node p2,node p3)
{
	ld A1,B1,C1,A2,B2,C2;
	A1=2*(p2.x-p1.x);B1=2*(p2.y-p1.y);C1=(sqr(p2.x)+sqr(p2.y))-(sqr(p1.x)+sqr(p1.y));
	A2=2*(p3.x-p1.x);B2=2*(p3.y-p1.y);C2=(sqr(p3.x)+sqr(p3.y))-(sqr(p1.x)+sqr(p1.y));
	op=0;if(G(A1,A2,B1,B2)==0)return(node){0,0};
	op=1;return(node){G(C1,C2,B1,B2)/G(A1,A2,B1,B2),G(A1,A2,C1,C2)/G(A1,A2,B1,B2)};
}
bool same(ld x,ld y){return abs(x-y)<=1e-12;}

int main()
{
    //freopen("1.in","r",stdin);freopen("1.out","w",stdout);
	read(n);
	rep(i,1,n)read(a[i].x,a[i].y);
	ld ans=-1;
	rep(i,1,n)
		rep(j,i+1,n)
			rep(k,j+1,n)
			{
				ld D1=dis(a[i]-a[j]),D2=dis(a[i]-a[k]),D3=dis(a[j]-a[k]);
				if(D1>D2)swap(D1,D2);if(D2>D3)swap(D2,D3);
				if(D1*D1+D2*D2<D3*D3)continue;
				node u=get(a[i],a[j],a[k]);ld D=dis(u-a[i]);
				if(!op)continue;

				bool pd=1;REP(z,1,n)if(dis(u-a[z])+1e-12<D){pd=0;break;}
				if(pd)
                {
                    upmax(ans,D);
                }
			}
	cout<<fixed<<setprecision(10)<<ans<<endl;

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>
#include<vector>
#include<map>
#include<queue>
#include<string>
#include<bitset>
#include<iomanip>
#include<iostream>
#include<cmath>
using namespace std;
#define rep(i,x,y) for(i=x;i<=y;i++)
#define _rep(i,x,y) for(i=x;i>=y;i--)
#define REP(i,x,y) for(int i=(x);i<=(y);i++)
#define _REP(i,x,y) for(int i=(x);i>=(y);i--)
#define CL(S,x) memset(S,x,sizeof(S))
#define CP(S1,S2) memcpy(S1,S2,sizeof(S2))
#define ALL(x,S) for(x=S.begin();x!=S.end();x++)
#define pb push_back
#define IN insert
#define ER erase
#define BE begin()
#define ED end()
#define LB lower_bound
#define UB upper_bound
#define mp make_pair
#define fi first
#define se second
#define upmin(x,y) x=min(x,y)
#define upmax(x,y) x=max(x,y)
#define COUT(S,x) cout<<fixed<<setprecision(x)<<S<<endl
template<class T> inline void read(T&x){bool fu=0;char c;for(c=getchar();c<=32;c=getchar());if(c=='-')fu=1,c=getchar();for(x=0;c>32;c=getchar())x=x*10+c-'0';if(fu)x=-x;};
template<class T> inline void read(T&x,T&y){read(x);read(y);}
template<class T> inline void read(T&x,T&y,T&z){read(x);read(y);read(z);}
inline char getc(){char c;for(c=getchar();c<=32;c=getchar());return c;}

typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;

#define sqr(x) ((x)*(x))

int n,i,j,k,l,p;bool op;
struct node{ld x,y;}a[110];
node operator-(node a,node b){return(node){a.x-b.x,a.y-b.y};}
ld dis(node a){return sqrt(a.x*a.x+a.y*a.y);}

ld G(ld a,ld b,ld c,ld d){return a*d-b*c;}
node get(node p1,node p2,node p3)
{
	ld A1,B1,C1,A2,B2,C2;
	A1=2*(p2.x-p1.x);B1=2*(p2.y-p1.y);C1=(sqr(p2.x)+sqr(p2.y))-(sqr(p1.x)+sqr(p1.y));
	A2=2*(p3.x-p1.x);B2=2*(p3.y-p1.y);C2=(sqr(p3.x)+sqr(p3.y))-(sqr(p1.x)+sqr(p1.y));
	op=0;if(G(A1,A2,B1,B2)==0)return(node){0,0};
	op=1;return(node){G(C1,C2,B1,B2)/G(A1,A2,B1,B2),G(A1,A2,C1,C2)/G(A1,A2,B1,B2)};
}
bool same(ld x,ld y){return abs(x-y)<=1e-8;}

int main()
{
    //freopen("1.in","r",stdin);freopen("1.out","w",stdout);
	read(n);
	rep(i,1,n)read(a[i].x,a[i].y);
	ld ans=-1;
	rep(i,1,n)
		rep(j,i+1,n)
			rep(k,j+1,n)
			{
				ld D1=dis(a[i]-a[j]),D2=dis(a[i]-a[k]),D3=dis(a[j]-a[k]);
				if(D1>D2)swap(D1,D2);if(D2>D3)swap(D2,D3);
				if(D1*D1+D2*D2<D3*D3)continue;
				bool mark=same(D1*D1+D2*D2,D3*D3);
				node u=get(a[i],a[j],a[k]);ld D=dis(u-a[i]);
				if(!op)continue;
				bool pd=1;
                REP(z,1,n)if(z!=i&&z!=j&&z!=k)
                {
                    if(dis(u-a[z])<D)pd=0;
                    if(same(dis(u-a[z]),D))mark=0;
                }

				if(pd&&(!mark))
                {
                    upmax(ans,D);
                }
			}
	cout<<fixed<<setprecision(10)<<ans<<endl;

    return 0;
}


#include <math.h>
#include <cstdio>
#include <map>
#include <algorithm>
using namespace std;
const double eps = 1e-5;
struct point{double x,y;};
struct line{point a,b;};
point p[110],cen;
int n ;
double ans ;
double dis(point p1,point p2){
  return (p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y);
}
point intersection(line u,line v){
  point ret=u.a;
  double t=((u.a.x-v.a.x)*(v.a.y-v.b.y)-(u.a.y-v.a.y)*(v.a.x-v.b.x))
      /((u.a.x-u.b.x)*(v.a.y-v.b.y)-(u.a.y-u.b.y)*(v.a.x-v.b.x));
  ret.x+=(u.b.x-u.a.x)*t;
  ret.y+=(u.b.y-u.a.y)*t;
  return ret;
}
//外心
point circumcenter(point a,point b,point c){
  line u,v;
  u.a.x=(a.x+b.x)/2;
  u.a.y=(a.y+b.y)/2;
  u.b.x=u.a.x-a.y+b.y;
  u.b.y=u.a.y+a.x-b.x;
  v.a.x=(a.x+c.x)/2;
  v.a.y=(a.y+c.y)/2;
  v.b.x=v.a.x-a.y+c.y;
  v.b.y=v.a.y+a.x-c.x;
  return intersection(u,v);
}
void Init() {
  scanf("%d",&n);
  for(int i =0 ; i < n ; i++) scanf("%lf%lf",&p[i].x,&p[i].y);
}
void judge(int i,int j,int k,double dx)
{
     bool f = true;
     for(int kk = 0; kk < n; kk++){
          if(kk!=i && kk!=j && kk!=k) {
              double dd = dis(cen,p[kk]) ;
              if(dd - dx < -eps) { f = false;   break;}
          }
     }
     if(f) ans = max(ans,dx);
}
void Gao() {
  ans = -1;
 for(int i = 0; i < n; i++)
 for(int j = i+1; j < n; j++)
 for(int k = j+1; k < n; k++)
    {
        double d[3];
        d[0] = dis(p[i],p[j]);
        d[1] = dis(p[i],p[k]);
        d[2] = dis(p[j],p[k]);

        sort(d,d+3);
        if(d[0]+d[1] <= d[2]) continue;
        cen = circumcenter(p[i],p[j],p[k]);
        double dx = dis(cen,p[i]);
        judge(i,j,k,dx);
    }
   if(ans != -1) printf("%lf",sqrt(ans)); else puts("-1");
}
int main(){
  Init();
  Gao();
  return 0;
}


#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
const double eps = 1e-5;
struct point {
    double x, y;
}p[103], cent;
struct line {
    point a, b;
};
point intersection(line u,line v){
    point ret=u.a;
    double t=((u.a.x-v.a.x)*(v.a.y-v.b.y)-(u.a.y-v.a.y)*(v.a.x-v.b.x))
            /((u.a.x-u.b.x)*(v.a.y-v.b.y)-(u.a.y-u.b.y)*(v.a.x-v.b.x));
    ret.x+=(u.b.x-u.a.x)*t;
    ret.y+=(u.b.y-u.a.y)*t;
    return ret;
}
point circumcenter(point a,point b,point c){
    line u,v;
    u.a.x=(a.x+b.x)/2;
    u.a.y=(a.y+b.y)/2;
    u.b.x=u.a.x-a.y+b.y;
    u.b.y=u.a.y+a.x-b.x;
    v.a.x=(a.x+c.x)/2;
    v.a.y=(a.y+c.y)/2;
    v.b.x=v.a.x-a.y+c.y;
    v.b.y=v.a.y+a.x-c.x;
    return intersection(u,v);
}
double F(double x) { return x*x; }
double dis(point a, point b) {
    return F(a.x-b.x) + F(a.y-b.y);
}
int n;
double ans = -1;
void update(int a, int b, int c, point cent, double d) {
    int i;
    for(i = 0; i < n; i++) if(i != a && i != b && i != c && i != d) {
        if(dis(p[i], cent) -d < -eps) return;
    }
    if(d > ans) ans = d;
}
int main() {
    ios::sync_with_stdio(0);
    int i, j, k, u;
    cin >> n;
    for(i = 0; i < n; i++) cin >> p[i].x >> p[i].y;
    for(i = 0; i < n; i++)
        for(j = i+1; j < n; j++)
            for(k = j+1; k < n; k++) {
                double d[3];
                d[0] = dis(p[j], p[k]);
                d[1] = dis(p[i], p[j]);
                d[2] = dis(p[i], p[k]);
                if(d[0] == d[1] + d[2]) {
                    bool flag = 0;
                    for(u = 0; u < n; u++) if(u != i && u != j && u != k) {
                        double d1 = dis(p[j], p[u]);
                        double d2 = dis(p[k], p[u]);
                        if(d[0] == d1 + d2) { flag = 1; break; }
                    }
                    if(flag) {
                        cent.x = (p[j].x + p[k].x)/2;
                        cent.y = (p[j].y + p[k].y)/2;
                        update(i, j, k, cent, d[0]/4);
                    }
                }
                sort(d, d+3);
                if(d[0] + d[1] > d[2]) {
                    cent = circumcenter(p[i], p[j], p[k]);
                    double dd = dis(cent, p[i]);
                    update(i, j, k, cent, dd);
                }
            }
    if(ans == -1) puts("-1");
    else printf("%.6f\n", sqrt(ans));
    return 0;
}


#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
struct point {
    double x, y;
}p[103], cent;
struct line {
    point a, b;
};
point intersection(line u,line v){
    point ret=u.a;
    double t=((u.a.x-v.a.x)*(v.a.y-v.b.y)-(u.a.y-v.a.y)*(v.a.x-v.b.x))
            /((u.a.x-u.b.x)*(v.a.y-v.b.y)-(u.a.y-u.b.y)*(v.a.x-v.b.x));
    ret.x+=(u.b.x-u.a.x)*t;
    ret.y+=(u.b.y-u.a.y)*t;
    return ret;
}
point circumcenter(point a,point b,point c){
    line u,v;
    u.a.x=(a.x+b.x)/2;
    u.a.y=(a.y+b.y)/2;
    u.b.x=u.a.x-a.y+b.y;
    u.b.y=u.a.y+a.x-b.x;
    v.a.x=(a.x+c.x)/2;
    v.a.y=(a.y+c.y)/2;
    v.b.x=v.a.x-a.y+c.y;
    v.b.y=v.a.y+a.x-c.x;
    return intersection(u,v);
}
double F(double x) { return x*x; }
double dis(point a, point b) {
    return F(a.x-b.x) + F(a.y-b.y);
}
int n;
double ans = -1;
void update(int a, int b, int c, point cent, double d) {
    int i;
    for(i = 0; i < n; i++) if(i != a && i != b && i != c && i != d) {
        if(dis(p[i], cent) < d) return;
    }
    if(d > ans) ans = d;
}
int main() {
    ios::sync_with_stdio(0);
    int i, j, k, u;
    cin >> n;
    for(i = 0; i < n; i++) cin >> p[i].x >> p[i].y;
    for(i = 0; i < n; i++)
        for(j = i+1; j < n; j++)
            for(k = j+1; k < n; k++) {
                double d[3];
                d[0] = dis(p[j], p[k]);
                d[1] = dis(p[i], p[j]);
                d[2] = dis(p[i], p[k]);
                if(d[0] == d[1] + d[2]) {
                    bool flag = 0;
                    for(u = 0; u < n; u++) if(u != i && u != j && u != k) {
                        double d1 = dis(p[j], p[u]);
                        double d2 = dis(p[k], p[u]);
                        if(d[0] == d1 + d2) { flag = 1; break; }
                    }
                    if(flag) {
                        cent.x = (p[j].x + p[k].x)/2;
                        cent.y = (p[j].y + p[k].y)/2;
                        update(i, j, k, cent, d[0]/4);
                    }
                }
                sort(d, d+3);
                if(d[0] + d[1] > d[2]) {
                    cent = circumcenter(p[i], p[j], p[k]);
                    double dd = dis(cent, p[i]);
                    update(i, j, k, cent, dd);
                }
            }
    if(ans == -1) puts("-1");
    else printf("%.6f\n", sqrt(ans));
    return 0;
}


#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
const double eps = 1e-5;
struct point {
    double x, y;
}p[103], cent;
struct line {
    point a, b;
};
point intersection(line u,line v){
    point ret=u.a;
    double t=((u.a.x-v.a.x)*(v.a.y-v.b.y)-(u.a.y-v.a.y)*(v.a.x-v.b.x))
            /((u.a.x-u.b.x)*(v.a.y-v.b.y)-(u.a.y-u.b.y)*(v.a.x-v.b.x));
    ret.x+=(u.b.x-u.a.x)*t;
    ret.y+=(u.b.y-u.a.y)*t;
    return ret;
}
point circumcenter(point a,point b,point c){
    line u,v;
    u.a.x=(a.x+b.x)/2;
    u.a.y=(a.y+b.y)/2;
    u.b.x=u.a.x-a.y+b.y;
    u.b.y=u.a.y+a.x-b.x;
    v.a.x=(a.x+c.x)/2;
    v.a.y=(a.y+c.y)/2;
    v.b.x=v.a.x-a.y+c.y;
    v.b.y=v.a.y+a.x-c.x;
    return intersection(u,v);
}
double F(double x) { return x*x; }
double dis(point a, point b) {
    return F(a.x-b.x) + F(a.y-b.y);
}
int n;
double ans = -1;
void update(int a, int b, int c, point cent, double d) {
    int i;
    for(i = 0; i < n; i++) if(i != a && i != b && i != c) {
        if(dis(p[i], cent) -d < -eps) return;
    }
    if(d > ans) ans = d;
}
int main() {
    ios::sync_with_stdio(0);
    int i, j, k, u;
    cin >> n;
    for(i = 0; i < n; i++) cin >> p[i].x >> p[i].y;
    for(i = 0; i < n; i++)
        for(j = i+1; j < n; j++)
            for(k = j+1; k < n; k++) {
                double d[3];
                d[0] = dis(p[j], p[k]);
                d[1] = dis(p[i], p[j]);
                d[2] = dis(p[i], p[k]);
                if(d[0] == d[1] + d[2]) {
                    bool flag = 0;
                    for(u = 0; u < n; u++) if(u != i && u != j && u != k) {
                        double d1 = dis(p[j], p[u]);
                        double d2 = dis(p[k], p[u]);
                        if(d[0] == d1 + d2) { flag = 1; break; }
                    }
                    if(flag) {
                        cent.x = (p[j].x + p[k].x)/2;
                        cent.y = (p[j].y + p[k].y)/2;
                        update(i, j, k, cent, d[0]/4);
                    }
                }
                sort(d, d+3);
                if(d[0] + d[1] > d[2]) {
                    cent = circumcenter(p[i], p[j], p[k]);
                    double dd = dis(cent, p[i]);
                    update(i, j, k, cent, dd);
                }
            }
    if(ans == -1) puts("-1");
    else printf("%.6f\n", sqrt(ans));
    return 0;
}


#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
const double eps = 1e-5;
struct point {
    double x, y;
}p[103], cent;
struct line {
    point a, b;
};
point intersection(line u,line v){ // 直线相交
    point ret=u.a;
    double t=((u.a.x-v.a.x)*(v.a.y-v.b.y)-(u.a.y-v.a.y)*(v.a.x-v.b.x))
            /((u.a.x-u.b.x)*(v.a.y-v.b.y)-(u.a.y-u.b.y)*(v.a.x-v.b.x));
    ret.x+=(u.b.x-u.a.x)*t;
    ret.y+=(u.b.y-u.a.y)*t;
    return ret;
}
point circumcenter(point a,point b,point c){ // 外心
    line u,v;
    u.a.x=(a.x+b.x)/2;
    u.a.y=(a.y+b.y)/2;
    u.b.x=u.a.x-a.y+b.y;
    u.b.y=u.a.y+a.x-b.x;
    v.a.x=(a.x+c.x)/2;
    v.a.y=(a.y+c.y)/2;
    v.b.x=v.a.x-a.y+c.y;
    v.b.y=v.a.y+a.x-c.x;
    return intersection(u,v);
}
double F(double x) { return x*x; }
double dis(point a, point b) {
    return F(a.x-b.x) + F(a.y-b.y);
}
int n;
double ans = -1;
void update(int a, int b, int c, point cent, double d) { // 更新最大值
    int i;
    for(i = 0; i < n; i++) if(i != a && i != b && i != c) {
        if(dis(p[i], cent) -d < -eps) return;
    }
    if(d > ans) ans = d;
}
int main() {
    ios::sync_with_stdio(0);
    int i, j, k, u;
    cin >> n;
    for(i = 0; i < n; i++) cin >> p[i].x >> p[i].y;
    for(i = 0; i < n; i++) // 枚举i为直角顶点
        for(j = i+1; j < n; j++)
            for(k = j+1; k < n; k++) {
                double d[3];
                d[0] = dis(p[j], p[k]);
                d[1] = dis(p[i], p[j]);
                d[2] = dis(p[i], p[k]);
                if(d[0] == d[1] + d[2]) {
                    bool flag = 0;
                    // 找另一个直角顶点
                    for(u = 0; u < n; u++) if(u != i && u != j && u != k) {
                        double d1 = dis(p[j], p[u]);
                        double d2 = dis(p[k], p[u]);
                        if(d[0] == d1 + d2) { flag = 1; break; }
                    }
                    if(flag) {
                        cent.x = (p[j].x + p[k].x)/2;
                        cent.y = (p[j].y + p[k].y)/2;
                        update(i, j, k, cent, d[0]/4);
                    }
                }
                sort(d, d+3);
                if(d[0] + d[1] > d[2]) { // 锐角三角形
                    cent = circumcenter(p[i], p[j], p[k]);
                    double dd = dis(cent, p[i]);
                    update(i, j, k, cent, dd);
                }
            }
    if(ans == -1) puts("-1");
    else printf("%.6f\n", sqrt(ans));
    return 0;
}