#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> ii;
typedef tuple<ll, ll, ll> iii;
typedef vector<ll> vi;
typedef vector<ii> vii;
typedef vector<iii> viii;
typedef vector<vi> vvi;
typedef vector<vii> vvii;
#define REP(i,n) for (ll i = 0; i < n; ++i)
#define REPR(i,n) for (ll i = n-1; i >= 0; --i)
#define FOR(i,m,n) for (ll i = m; i < n; ++i)
#define FORR(i,m,n) for (ll i = n-1; i >= m; --i)
#define FORE(x,xs) for (const auto& x : xs)
#define FORI(i,v) for (auto i = v.begin(); i != v.end(); i++)
#define ALL(v) v.begin(), v.end()
#define SORT(v) sort(ALL(v))
#define REV(v) reverse(ALL(v))
#define UNIQ(v) sort(ALL(v)); v.erase(unique(ALL(v)),end(v))
#define CHMIN(x,y) x = min(x, y)
#define CHMAX(x,y) x = max(x, y)
#define YES(b) cout << ((b) ? "YES" : "NO") << endl
#define Yes(b) cout << ((b) ? "Yes" : "No") << endl


struct UnionFind {
private:
    int N;
    vi parent;
    vi rank_;

    void init(int n) {
        N = n;
        parent.resize(0); parent.clear(); parent.resize(n);
        REP (i, N) parent[i] = i;
        rank_.resize(0); rank_.clear(); rank_.resize(n);
    }

public:
    UnionFind() { init(0); }
    UnionFind(int n) { init(n); }

    int root(int x) {
        return (parent[x] == x) ? x : parent[x] = root(parent[x]);
    }

    bool isSame(int x, int y) {
        return root(x) == root(y);
    }

    void merge(int x, int y) {
        x = root(x);
        y = root(y);
        if (x == y) return;

        if (rank_[x] < rank_[y])
            parent[x] = y;
        else {
            parent[y] = x;
            if (rank_[x] == rank_[y]) rank_[x]++;
        }
    }
};

const int MAX = 111;

int N;
int X[MAX], Y[MAX];

bool check(ld r) {
    UnionFind uf(N+2);

    REP (i, N) REP (j, i) {
        ld dist = pow(pow(X[i]-X[j],2) + pow(Y[i]-Y[j],2), .5);
        if (dist < 2*r) uf.merge(i, j);
    }
    REP (i, N) {
        if (100 - Y[i] < 2*r) uf.merge(i, N);
        if (Y[i] + 100 < 2*r) uf.merge(i, N+1);
    }

    return !uf.isSame(N, N+1);
}

ld solve() {
    ld ok = 0, ng = 200;
    REP (i, 100) {
        ld m = (ok + ng) / 2;
        if (check(m)) ok = m;
        else ng = m;
    }
    return ok;
}

int main() {
    cout << fixed << setprecision(15);
    cin >> N;
    REP (i, N) cin >> X[i] >> Y[i];
    cout << solve() << endl;
}

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

using namespace std;


const int N = 200;

int a[N], b[N], c[N], d[N];

int main()
{
    int n;
    cin >> n;
    for (int _ = 0; _ < 2; _ ++)
    {
        for (int i = 0; i < n; i ++) cin >> a[i] >> b[i];
        int x = 0, y = 0;
        for (int i = 0; i < n; i ++)
        {
            x += a[i]; y += b[i];
            a[i] *= n; b[i] *= n;
        }
        for (int i = 0; i < n; i ++)
        {
            a[i] -= x;
            b[i] -= y;
        }
        swap(a, c);
        swap(b, d);
    }
    for (int i = 0; i < n; i ++)
        if (a[i] || b[i])
        {
            swap(a[i], a[0]);
            swap(b[i], b[0]);
        }
    string ans = "No";
    double eps = 1e-6;
    for (int i = 0; i < n; i ++)
    {
        double angle = atan2(d[i], c[i]) - atan2(b[0], a[0]);
        bool flag = true;
        for (int j = 0; j < n; j ++)
        {
            double u = a[j] * cos(angle) - b[j] * sin(angle);
            double v = a[j] * sin(angle) + b[j] * cos(angle);
            bool flag2 = false;
            for (int k = 0; k < n; k ++)
                if (abs(u - c[k]) <= eps && abs(v - d[k]) < eps) flag2 = true;
            flag &= flag2;
        }
        if (flag) ans = "Yes";
    }
    cout << ans << endl;
    return 0;
}