#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORR(i, m, n) for (int i = m; i >= n; --i)
#define ALL(v) (v).begin(),(v).end()
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const ll INF=1LL<<60;
const int inf=(1<<30)-1;
const int mod=1e9+7;
int dx[8]={1,0,-1,0,-1,-1,1,1};
int dy[8]={0,1,0,-1,-1,1,-1,1};
struct dsu {
  public:
    dsu() : _n(0) {}
    dsu(int n) : _n(n), parent_or_size(n, -1) {}

    int merge(int a, int b) {
        assert(0 <= a && a < _n);
        assert(0 <= b && b < _n);
        int x = leader(a), y = leader(b);
        if (x == y) return x;
        if (-parent_or_size[x] < -parent_or_size[y]) std::swap(x, y);
        parent_or_size[x] += parent_or_size[y];
        parent_or_size[y] = x;
        return x;
    }

    bool same(int a, int b) {
        assert(0 <= a && a < _n);
        assert(0 <= b && b < _n);
        return leader(a) == leader(b);
    }

    int leader(int a) {
        assert(0 <= a && a < _n);
        if (parent_or_size[a] < 0) return a;
        return parent_or_size[a] = leader(parent_or_size[a]);
    }

    int size(int a) {
        assert(0 <= a && a < _n);
        return -parent_or_size[leader(a)];
    }

    std::vector<std::vector<int>> groups() {
        std::vector<int> leader_buf(_n), group_size(_n);
        for (int i = 0; i < _n; i++) {
            leader_buf[i] = leader(i);
            group_size[leader_buf[i]]++;
        }
        std::vector<std::vector<int>> result(_n);
        for (int i = 0; i < _n; i++) {
            result[i].reserve(group_size[i]);
        }
        for (int i = 0; i < _n; i++) {
            result[leader_buf[i]].push_back(i);
        }
        result.erase(
            std::remove_if(result.begin(), result.end(),
                           [&](const std::vector<int>& v) { return v.empty(); }),
            result.end());
        return result;
    }

  private:
    int _n;
    // root node: -1 * component size
    // otherwise: parent
    std::vector<int> parent_or_size;
};
vector<double> x(105),y(105);
double dis(int i,int j){
    return sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]));
}
int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    int n;cin >> n;
    REP(i,n) cin >> x[i] >> y[i];
    vector<pair<double,pair<int,int>>> p;
    REP(i,n){
        FOR(j,i+1,n){
            p.push_back({dis(i,j),{i,j}});
        }
        p.push_back({y[i]+100.0,{i,n}});
        p.push_back({100.0-y[i],{i,n+1}});
    }
    double l=0,r=200;
    for(int t=0;t<100;t++){
        double mid=(l+r)/2.0;
        dsu uf(n+2);
        for(auto e:p){
            if(e.first<=mid){
                uf.merge(e.second.first,e.second.second);
            }
        }
        if(uf.same(n,n+1)) r=mid;
        else l=mid;
    }
    cout << fixed << setprecision(10) << l/2.0 << endl;
}
#include<iostream>
#include<utility>
#include <queue>
#include<vector>
#include <functional>
double h[30][29],v[29][30];

typedef std::pair<int, std::pair<int,int>> P;

char prev[30][30] = {0};
int d[30][30] = {0};
const int INF = 9000*30*30;

void dijkstra(int ti,int tj) {
    const int dir[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};
    const char dirc[4] = {'D','U','R','L'};
    for(int i=0;i<30;i++){
        for(int j=0;j<30;j++){
            prev[i][j] = '\0';
            d[i][j] = INF;
        }
    }
    std::priority_queue<P, std::vector<P>, std::greater<P>> que;
    d[ti][tj] = 0;
    que.push(P(0, std::pair<int,int>(ti,tj)));
    while (!que.empty()) {
        P p = que.top();
        que.pop();
        std::pair<int,int> point = p.second;
        int vi = point.first,vj = point.second;
        if (d[vi][vj] < p.first) {
            continue;
        }
        for (int i=0;i<4;i++) {
            int mvi = vi+dir[i][0],mvj = vj+dir[i][1];
            if(mvi>=30||mvi<0||mvj>=30||mvj<0){
                continue;
            }
            int cost;
            if(i<2){
                cost = d[vi][vj] + v[vi+(-1+dir[i][0])/2][vj];
            }else{
                cost = d[vi][vj] + h[vi][vj+(-1+dir[i][1])/2];
            }
            if (d[mvi][mvj] > cost) {
                d[mvi][mvj] = cost;
                prev[mvi][mvj] = dirc[i];
                que.push(P(cost,std::pair<int,int>(mvi,mvj)));
            }
        }
    }
}

int main(){
    for(int i=0;i<30;i++){
        for(int j=0;j<29;j++){
            h[i][j] = 1000;
            v[j][i] = 1000;
        }
    }

    for(int i=0;i<1000;i++){
        int si,sj,ti,tj;
        std::cin >> si>>sj>>ti>>tj;
        dijkstra(ti,tj);
        while(si!=ti||sj!=tj){
            char dir = prev[si][sj];
            std::cout<<dir;
            switch (dir)
            {
            case 'U':
                si--;
                break;
            case 'D':
                si++;
                break;
            case 'L':
                sj--;
                break;
            case 'R':
                sj++;
                break;
            default:
                break;
            }
        } 
        std::cout<<std::endl;
        int cost;
        std::cin >> cost;
    }
}