#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=(n)-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x,vector<x>,greater<x>>
#define all(x) (x).begin(),(x).end()
#define CST(x) cout<<fixed<<setprecision(x)
#define rev(x) reverse(x);
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
using pl=pair<ll,ll>;
using vpl=vector<pl>;
using vvpl=vector<vpl>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
template<class T> inline bool chmin(T& a, T b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}
template<class T> inline bool chmax(T& a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}



const double EPS=1e-9;
double add(double a,double b){
    if(abs(a+b)<EPS*(abs(a)+abs(b)))return 0;
    return a+b;
}

struct P{
    double x,y;
    P(){}
    P(double x,double y):x(x),y(y){}
    P operator-(P p) {
        return P(add(x,-p.x),add(y,-p.y));
    }
    bool operator< (const P &p) const {
        if(x!=p.x)return x<p.x;
        return y<p.y;
    }
    double det(P p){
        return add(x*p.y,-y*p.x);
    }
    double dot(P p){
        return add(x*p.x,y*p.y);
    }
};
bool cmp_x(const P p,const P q){
    if(p.x!=q.x)return p.x<q.x;
    return p.y<q.y;
}
double dist(P &p,P &q){
    return (p-q).dot(p-q);
}

vector<P> convex_hull(vector<P> ps){//点が一つの時は何も返さない
    sort(all(ps),cmp_x);
    int n=ps.size(),k=0;
    vector<P> qs(2*n);
    for(int i=0;i<n;i++){
        while(k>1&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)k--;
        qs[k++]=ps[i];
    }
    for(int i=n-2,t=k;i>=0;i--){
        while(k>t&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)k--;
        qs[k++]=ps[i];
    }
    qs.resize(k-1);
    return qs;
}
double caliper(vector<P> qs){
    ll n=qs.size();
    if(n==2)return dist(qs[0],qs[1]);
    int i=0,j=0;
    for(int k=0;k<n;k++){
        if(!cmp_x(qs[i],qs[k]))i=k;
        if(cmp_x(qs[j],qs[k]))j=k;
    }
    double res=0;
    int si=i,sj=j;
    while(i!=sj||j!=si){
        res=max(res,dist(qs[i],qs[j]));
        if((qs[(i+1)%n]-qs[i]).det(qs[(j+1)%n]-qs[j])<0){
            i=(i+1)%n;
        }
        else j=(j+1)%n;
    }
    return res;
}


struct UnionFind {
    vector<int> par;
    
    UnionFind(int n) : par(n, -1) {}

    int root(int x) {
        if (par[x] < 0) return x;
        else return par[x] = root(par[x]);
    }
    
    bool same(int x, int y) {
        return root(x) == root(y);
    }
    
    bool merge(int x, int y) {
        x = root(x); y = root(y);
        if (x == y) return false;
        if (par[x] > par[y]) swap(x, y);
        par[x] += par[y];
        par[y] = x;
        return true;
    }
    
    int size(int x) {
        return -par[root(x)];
    }
};

int main(){
    ll n;cin >> n;
    if(n==0)cout << 1 <<endl,exit(0);
    vector<P> v(n);
    map<P,ll> mp;
    rep(i,n){
        cin >> v[i].x >> v[i].y;
        mp[v[i]]=i;
    }
    UnionFind uf(n);
    rep(i,n){
        rep(j,21){
            rep(k,21){
                P np={v[i].x+j-10,v[i].y+k-10};
                if(dist(np,v[i])>100)continue;
                if(mp.count(np))uf.merge(i,mp[np]);
            }
        }
    }
    vvl g(n);
    rep(i,n)g[uf.root(i)].pb(i);
    double ans=2;
    rep(i,n){
        if(g[i].size()<=1)continue;
        vector<P> ch;
        for(auto p:g[i])ch.pb(v[p]);
        auto z=convex_hull(ch);
        chmax(ans,2+sqrt(caliper(z)));
    }
    CST(10);
    cout << ans <<endl;
}