#include <bits/stdc++.h>          
using namespace std;
using ll = long long;
using ld = long double;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repp(i, st, en) for (ll i = (ll)st; i < (ll)(en); i++)
#define repm(i, st, en) for (ll i = (ll)st; i >= (ll)(en); i--)
#define all(v) v.begin(), v.end()
void chmax(ll &x, ll y) {x = max(x,y);}
void chmin(ll &x, ll y) {x = min(x,y);}
void Yes() {cout << "Yes" << endl; exit(0);}
void No() {cout << "No" << endl; exit(0);}
template<class in_Cout> void Cout(in_Cout x) {cout << x << endl; exit(0);}
template<class in_vec_cout>
void vec_cout(vector<in_vec_cout> vec) {
    for (in_vec_cout res : vec) {cout << res << " ";}
    cout << endl;
}

const ll inf = 1e18;
const ll mod = 1e9 + 7;

ll N;
vector<pair<ld,ld>> P;
ld dist[110][110];

map<ld,bool> rad;

void init() {
    cin >> N;
    rep(i,N) {
        ld x, y; cin >> x >> y;
        P.push_back({x,y});
    }
    rep(i,N) {
        rep(j,N) {
            if (i==j) continue;
            ld from_x = P[i].first, from_y = P[i].second;
            ld to_x = P[j].first, to_y = P[j].second;
            ld dx = to_x - from_x, dy = to_y - from_y;
            dist[i][j] = sqrt(dx*dx+dy*dy);
        }
        dist[i][N] = dist[N][i] = (ld)100 - P[i].second;
        dist[i][N+1] = dist[N+1][i] = P[i].second + (ld)100;
    }
    dist[N][N+1] = dist[N+1][N] = 200.0;
    rep(i,N+2) rep(j,N+2) {
        rad[dist[i][j]*0.5] = true;
    }
    rad[100.0] = true;
}

bool judge(ld r) {
    ld d = (ld)2*r;
    vector<vector<ll>> G(N+2);
    rep(i,N+2) rep(j,N+2) {
        if (dist[i][j]>=d) continue;
        G[i].push_back(j);
    }
    queue<ll> que;
    que.push(N);
    vector<bool> seen(N+2);
    seen[N] = true;
    while (que.size()) {
        ll x = que.front();
        que.pop();
        for (ll y : G[x]) {
            if (seen[y]) continue;
            seen[y] = true;
            que.push(y);
        }
    }
    return seen[N+1];
}

void solve() {
    init();
    ld ans = 0.0;
    for (auto p : rad) {
        ld r = p.first;
        bool NG = judge(r);
        if (NG) break;
        ans = r;
    }
    cout << fixed << setprecision(10);
    cout << ans << endl;
}

int main() {
    solve();
}
#include <bits/stdc++.h>

using namespace std;

#define vt          vector
#define sz(x)       int((x).size())
#define all(x)      (x).begin(), (x).end()
#define rall(x)     (x).rbegin(), (x).rend()
#define fi          first
#define se          second

using ll = long long;
using pii = pair<int, int>;

#define die return void(cout << "No")
#define die2 { pass = false; break; }

void solve() {
    int n;
    cin >> n;
    vt<pii> a(n);
    for (pii &x : a) cin >> x.fi >> x.se;
    sort(all(a));

    set<int> check;
    for (int i = 0; i < n; i++) {
        if (~a[i].fi && ~a[i].se && a[i].fi >= a[i].se) die;
        if (~a[i].fi && check.count(a[i].fi)) die;
        if (~a[i].se && check.count(a[i].se)) die;

        check.insert(a[i].fi);
        check.insert(a[i].se);
    }

    vt<bool> ok(n * 2 + 1);
    vt<int> m1cnt(n * 2 + 1);
    ok[0] = true;
    for (int i = 0; i < n; i++) {
        if (!~a[i].fi && !~a[i].se) m1cnt[0]++;
    }

    for (int i = 0; i < n * 2; i += 2) {
        if (!ok[i]) continue;

        for (int j = i + 2; j <= n * 2; j += 2) {
            int jump = (j - i) / 2;
            bool pass = true;
            vt<bool> used(n * 2 + 1);

            for (pii &x : a) {
                if (~x.fi && ~x.se &&
                        i < x.fi && x.fi <= j &&
                        i < x.se && x.se <= j) {
                    if (x.se - x.fi != jump) die2;
                    if (x.fi > i + jump) die2;
                    if (x.se <= i + jump) die2;

                    if (used[x.fi]) die2;
                    used[x.fi] = true;
                } else if (~x.fi && i < x.fi && x.fi <= j) {
                    if (x.fi > i + jump) die2;

                    if (used[x.fi]) die2;
                    used[x.fi] = true;
                } else if (~x.se && i < x.se && x.se <= j) {
                    if (x.se <= i + jump) die2;

                    if (used[x.se - jump]) die2;
                    used[x.se - jump] = true;
                }
            }

            if (pass) {
                int r_cnt = jump;
                for (int k = i + 1; k <= i + jump; k++) {
                    if (used[k]) r_cnt--;
                }

                if (m1cnt[i] >= r_cnt) {
                    m1cnt[j] = max(m1cnt[j], m1cnt[i] - r_cnt);
                    ok[j] = true;
                }
            }
        }
    }

    if (ok.back()) cout << "Yes";
    else cout << "No";
}

int main() {
    ios::sync_with_stdio(0), cin.tie(0);

    int tcs = 1;
    for (int tc = 1; tc <= tcs; tc++) {
        // cout << "Case " << tc << ": ";
        solve();
    }
}

