#include <bits/stdc++.h>

using namespace std;
using ll = int64_t;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using mii = map<int, int>;
using vi = vector<int>;
using vii = vector<vi>;
using vl = vector<ll>;
using vll = vector<vl>;
using tpi = tuple<int, int, int>;

using vqi = vector<queue<int>>;
using vpi = vector<pii>;
using bs = bitset<60>;
using vbi = vector<bs>;
constexpr ll MOD = 1e9 + 7;
constexpr double EPS = 1e-7;


int main() {
    int N;
    cin >> N;
    vi X(N);
    vi Y(N);
    for (int i = 0; i < N; i++) {
        int x = 0, y = 0;
        cin >> x >> y;
        X[i] = x;
        Y[i] = y;
    }

    if (N == 2) {
        double cx = (X[0] + X[1]) / 2.;
        double cy = (Y[0] + Y[1]) / 2.;
        double r = sqrt((X[0] - cx) * (X[0] - cx) + (Y[0] - cy) * (Y[0] - cy));
        cout << r << endl;
        return 0;
    }
    double min_d = 1000000;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            if (j == i) {
                continue;
            }
            for (int k = 0; k < N; k++) {
                if (k == i || k == j) {
                    continue;
                }

                double g = X[i] * Y[j] - X[j] * Y[i] + X[j] * Y[k] - X[k] * Y[j] + X[k] * Y[i] - X[i] * Y[k];
                double cx = 0, cy = 0;
                if (g != 0) {
                    cx =
                            (X[i] * X[i] + Y[i] * Y[i]) * (Y[j] - Y[k]) + (X[j] * X[j] + Y[j] * Y[j]) * (Y[k] - Y[i]) +
                            (X[k] * X[k] + Y[k] * Y[k]) * (Y[i] - Y[j]);
                    cx /= (2 * g);
                    cy = -((X[i] * X[i] + Y[i] * Y[i]) * (X[j] - X[k]) +
                           (X[j] * X[j] + Y[j] * Y[j]) * (X[k] - X[i]) +
                           (X[k] * X[k] + Y[k] * Y[k]) * (X[i] - X[j]));
                    cy /= (2 * g);
                } else {
                    continue;
                }
                double r = sqrt((X[i] - cx) * (X[i] - cx) + (Y[i] - cy) * (Y[i] - cy));

                bool is_satisfy = true;
                for (int n = 0; n < N; n++) {
                    if (n == i || n == j || n == k) {
                        continue;
                    }
                    double nr = sqrt((X[n] - cx) * (X[n] - cx) + (Y[n] - cy) * (Y[n] - cy));
                    if (nr > r + EPS) {
                        is_satisfy = false;
                        break;
                    }
                }
                if (is_satisfy) {
                    min_d = min(min_d, r);
                }
            }
        }
    }

    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            if (j == i) {
                continue;
            }
            double cx = (X[i] + X[j]) / 2.;
            double cy = (Y[i] + Y[j]) / 2.;
            double r = sqrt((X[i] - cx) * (X[i] - cx) + (Y[i] - cy) * (Y[i] - cy));

            bool is_satisfy = true;
            for (int n = 0; n < N; n++) {
                if (n == i || n == j) {
                    continue;
                }
                double nr = sqrt((X[n] - cx) * (X[n] - cx) + (Y[n] - cy) * (Y[n] - cy));
                if (nr > r + EPS) {
                    is_satisfy = false;
                    break;
                }
            }
            if (is_satisfy) {
                min_d = min(min_d, r);
            }
        }
    }
    std::cout.precision(10);
    cout << min_d << endl;
    return 0;
}


Measured memory_bytes: 256