#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iomanip>
#include <numeric>
#include <queue>
#include <cmath>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<pair<int, int>> vp(n, make_pair(0, 0));
    for (int i = 0; i < n; i++) {
        cin >> vp[i].first >> vp[i].second;
    }
    sort(vp.begin(), vp.end());
    if (n == 2) {
        cout << setprecision(16) << powl(pow(vp[0].first - vp[1].first, 2) + pow(vp[1].second - vp[0].second, 2), 0.5) / 2 << endl;
        return 0;
    }
    long double res = -1;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            // if (i == j) continue;
            for (int k = 0; k < n; k++) {
                // if (k == i || k == j) continue;
                if (((vp[k].second - vp[j].second) * (vp[j].first - vp[i].first)) == ((vp[j].second - vp[i].second) * (vp[k].first - vp[j].first))) {
                    int max_x = max(vp[i].first, max(vp[j].first, vp[k].first));
                    int min_x = min(vp[i].first, min(vp[j].first, vp[k].first));
                    int max_y = max(vp[i].second, max(vp[j].second, vp[k].second));
                    int min_y = min(vp[i].second, min(vp[j].second, vp[k].second));
                    long double r = (pow(max_x - min_x, 2) + pow(max_y - min_y, 2)) / 4.0;
                    long double x = (max_x + min_x) / 2.0, y = (max_y + min_y) / 2.0;
                    int flag = 1;
                    for (int l = 0; l < n; l++) {
                        if (powl(x - vp[l].first, 2) + powl(y - vp[l].second, 2) > r) {
                            flag = 0;
                            break;
                        }
                    }
                    r = powl(r, 0.5);
                    if (flag == 1) if (res < 0 || r < res) res = r;
                    // if (r == 481) cout << vp[i].first << " " << vp[j].first << " " << vp[k].first << endl;
                    continue;
                }


                int a1 = 2 * (vp[j].first - vp[i].first);
                int b1 = 2 * (vp[j].second - vp[i].second);
                int c1 = pow(vp[j].first, 2) + pow(vp[j].second, 2) - pow(vp[i].first, 2) - pow(vp[i].second, 2);
                int a2 = 2 * (vp[k].first - vp[j].first);
                int b2 = 2 * (vp[k].second - vp[j].second);
                int c2 = pow(vp[k].first, 2) + pow(vp[k].second, 2) - pow(vp[j].first, 2) - pow(vp[j].second, 2);
                pair<int, int> a = make_pair(a1, a2), b = make_pair(b1, b2), c = make_pair(c1, c2);
                if (a.first * b.second - a.second * b.first == 0) {
                    continue;
                    swap(a, c);
                    if (a.first * b.second - a.second * b.first == 0) {
                        swap(a, b);
                    }
                }
                long double x = (long double)1.0 * (c.first * b.second - c.second * b.first) / (a.first * b.second - a.second * b.first);
                long double y = (long double)1.0 * (a.first * c.second - a.second * c.first) / (a.first * b.second - a.second * b.first);
                long double r = (x - vp[i].first) * (x - vp[i].first) + (y - vp[i].second) * (y - vp[i].second);
                int flag = 1;
                for (int l = 0; l < n; l++) {
                    if (powl(x - vp[l].first, 2) + powl(y - vp[l].second, 2) > r) {
                        flag = 0;
                        break;
                    }
                }
                if (flag == 1) {
                    r = powl(r, 0.5);
                    if (res < 0 || r < res) {
                        res = r;
                    }
                }
            }
        }
    }
    cout << setprecision(15) << res << endl;
}


Measured memory_bytes: 3808