#include <bits/stdc++.h>

using namespace std;

typedef long double ld;

const ld eps = 1e-9;
const ld pi = acos(- 1);

bool leq(ld a, ld b) {
    return a <= b + eps;
}

struct point {
    int x, y;

    point() {}
    point(int _x, int _y) {
        x = _x, y = _y;
    }

    point operator - (point p) {
        return point(x - p.x, y - p.y);
    }

    ld norm() {
        return hypot(x, y);
    }
};

int n;
vector <point> vecP;

void Task() {
    ios_base :: sync_with_stdio(false); cin.tie(0); cout.tie(0);
    if (fopen("test.inp", "r")) {
        freopen("test.inp", "r", stdin);
        freopen("test.out", "w", stdout);
    }
}

ld Angle(ld a) {
    while (a < 0) {
        a += pi / 2;
    }
    while (a > pi / 2) {
        a -= pi / 2;
    }
    return a;
}

bool Check(ld m) {
    vector <pair <ld, bool>> vecInterval;
    for (int i = 0; i < n; ++i) {
        ld d = (vecP[i] - point(0, 0)).norm();
        if (leq(m * sqrt(2), d)) {
            vecInterval.push_back({0, true});
            vecInterval.push_back({pi / 2, false});
        } else {
            ld a = atan2(vecP[i].y, vecP[i].x);
            vector <ld> vecL = {Angle(- a), Angle(asin(m / d) - a)};
            vector <ld> vecR = {Angle(acos(m / d) - a), Angle(pi / 2 - a)};
            for (int j = 0; j < 2; ++j) {
                if (leq(vecL[j], vecR[j])) {
                    vecInterval.push_back({vecL[j], true});
                    vecInterval.push_back({vecR[j], false});
                } else {
                    vecInterval.push_back({0, true});
                    vecInterval.push_back({vecR[j], false});
                    vecInterval.push_back({vecL[j], true});
                    vecInterval.push_back({pi / 2, false});
                }
            }
        }
    }
    sort(vecInterval.begin(), vecInterval.end());
    int status = 0;
    for (int i = 0; i < vecInterval.size(); ++i) {
        if (vecInterval[i].second) {
            status++;
            if (status == n) {
                return true;
            }
        } else {
            status--;
        }
    }
    return false;
}

void Solve() {
    cin >> n;
    vecP.resize(n);
    ld l = 0, r = 1e9;
    for (int i = 0; i < n; ++i) {
        cin >> vecP[i].x >> vecP[i].y;
        r = min(r, (vecP[i] - point(0, 0)).norm());
    }
    for (int loop = 0; loop <= 100; ++loop) {
        ld m = (l + r) / 2;
        if (Check(m)) {
            l = m;
        } else {
            r = m;
        }
    }
    cout << fixed << setprecision(4) << l * 8;
}

int main() {
    Task();
    Solve();
}