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

// 定義
typedef long long         ll;
typedef pair<ll, ll>      P;
#define ALL(x)            (x).begin(),(x).end()
#define REP(i, n)         for(ll i = 0 ; i < (ll)n ; ++i)
#define REPN(i, m, n)     for(ll i = m ; i < (ll)n ; ++i)
#define VL                vector<ll>
#define VVL               vector<vector<ll>>
#define VVVL              vector<vector<vector<ll>>>
#define INF               (ll)2e9
#define INF_LL            1LL<<60
#define MOD             998244353
//#define MOD               1000000007

ll Ceil(ll val, ll div)   { return (val + div - 1) / div; }
ll CeilN(ll val, ll div)  { return Ceil(val, div) * div; }
ll FloorN(ll x, ll n)     { return (x - x % n); }
bool IsOdd(ll x)          { return ((x & 1) == 1); }
bool IsEven(ll x)         { return ((x & 1) == 0); }

template<class T>
class UnionFind
{
private:
	vector<T> parentNo;
	vector<T> parentRank;
	vector<T> parentSize;

public:
	// コンストラクタ
	UnionFind(int n)
	{
		parentNo.resize(n);
		parentRank.resize(n, 0);
		parentSize.resize(n, 1);
		for (int i = 0; i < n; i++) {
			// 始めは全部ROOT
			parentNo[i] = i;
		}
	}

	int root(T x)
	{
		if (parentNo[x] == x) {
			return x;
		} else {
			T rootParentNo = root(parentNo[x]);
			parentNo[x] = rootParentNo;
			return rootParentNo;
		}
	}

	bool same(T x, T y)
	{
		return root(x) == root(y);
	}

	int size(T x)
	{
		return parentSize[root(x)];
	}

	void unite(T xc, T yc)
	{
		T xr = root(xc);
		T yr = root(yc);
		if (xr == yr) {
			return;
		}
		if (parentRank[xr] < parentRank[yr]) {
			parentNo[xr] = yr;
			parentSize[yr] += parentSize[xr];
		} else {
			parentNo[yr] = xr;
			parentSize[xr] += parentSize[yr];
			if (parentRank[xr] == parentRank[yr]) {
				parentRank[xr]++;
			}
		}
	}
};

void Solve()
{
	ll N;
	cin >> N;
	vector<P> xy(N);
	REP(i, N) cin >> xy[i].first >> xy[i].second;
	sort(ALL(xy));

	auto compExec = [&](double mid) {
		ll s = N;
		ll t = N + 1;
		UnionFind<ll> uf(N + 2);
		REP(i, N) {
			if (100 - xy[i].second < mid) {
				uf.unite(i, s);
			}
			if (100 + xy[i].second< mid) {
				uf.unite(i, t);
			}
		}

		REP(i, N) {
			REP(j, N) {
				if (i == j) continue;
				auto a = xy[i];
				auto b = xy[j];
				double distOne = pow(b.first - a.first, 2) + pow(b.second - a.second, 2);
				if (distOne < pow(mid, 2)) {
					uf.unite(i, j);
				}
			}
		}

		return !uf.same(s, t);
	};

	double lb = 0;
	double lu = 200;
	double mid = 0;
	REP(i, 121) {
		mid = (lb + lu) / 2;
		if (compExec(mid)) {
			lb = mid;
		} else {
			lu = mid;
		}
	}

	cout << lb / 2 << endl;
}

// メイン
int main()
{
	cin.tie(nullptr);
	ios_base::sync_with_stdio(false);
	cout << fixed << setprecision(15);
	Solve();
	return 0;
}

#include <bits/stdc++.h>
#include <math.h>
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vvll = vector<vll>;
using vpl = vector<pair<ll, ll>>;
using pll = pair<ll, ll>;
#define rep(i, k, n) for(ll i = k; i < n; i++)
#define pb push_back
#define mp make_pair

int main(){
    ld n; cin >> n;
    ld x0, y0; cin >> x0 >> y0;
    ld xn, yn; cin >> xn >> yn;
    const long double pi = 3.141592653589793238462643;

    ld dx = x0-xn;
    ld dy = y0-yn;

    long double theta = (long double)(pi) / (long double)(n);

    // cout << theta << endl;

    ld dx1 = dx*(ld)(cos(theta)) - dy*(ld)(sin(theta));
    ld dy1 = dx*(ld)(sin(theta)) + dy*(ld)(cos(theta));



    ld x1 = xn + dx1*(ld)(cos(theta));
    ld y1 = yn + dy1*(ld)(cos(theta));

    cout << fixed << setprecision(10) << x1;
    cout << " ";
    cout << fixed << setprecision(10) << y1 << endl;
}