#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <cmath>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#include <random>
#include <cassert>
#include <fstream>
#include <utility>
#include <functional>
#include <time.h>
#include <stack>
#include <array>
#define popcount __builtin_popcount
using namespace std;
typedef long long int ll;
//typedef pair<int, int> P;
#define EPS 1e-10
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));
    }
    P operator- (P p){
        return P(add(x, -p.x), add(y, -p.y));
    }
    P operator* (double d){
        return P(x*d, y*d);
    }
    double dot(P p){
        return add(x*p.x, y*p.y);
    }
    double det(P p){
        return add(x*p.y, -y*p.x);
    }
    bool operator< (const P& p) const{
        if(abs(x-p.x)>EPS){
            return x<p.x;
        }else{
            return y<p.y-EPS;
        }
    }
	bool operator== (const P& p) const{
        if(abs(x-p.x)<EPS && abs(y-p.y)<EPS) return true;
        else return false;
    }
};
double dist(P p1, P p2){
  return sqrt((p1-p2).dot(p1-p2));
}
vector<P> convex_hull(vector<P> ps){
	int n=ps.size();
  sort(ps.begin(), ps.end());
  int k=0;
  vector<P> qs(n*2);
  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 maxdist(vector<P> v){
	int n=v.size();
	double ret=0;
	int i=0, j=0;
	for(int k=0; k<n; k++){
		if(v[k]<v[i]) i=k;
		if(v[j]<v[k]) j=k;
	}
	int i0=i, j0=j;
	do{
		ret=max(ret, dist(v[i], v[j]));
		P r1=v[(i+1)%n]-v[i], r2=v[(j+1)%n]-v[j];
		if(r1.det(r2)>=0) j=(j+1)%n;
		else i=(i+1)%n;
	}while(i0!=i || j0!=j);
	return ret;
}
struct unionfind{
    vector<int> par, sz;
    unionfind() {}
    unionfind(int n):par(n), sz(n, 1){
        for(int i=0; i<n; i++) par[i]=i;
    }
    int find(int x){
        if(par[x]==x) return x;
        return par[x]=find(par[x]);
    }
    void unite(int x, int y){
        x=find(x); y=find(y);
        if(x==y) return;
        if(sz[x]>sz[y]) swap(x, y);
        par[x]=y;
        sz[y]+=sz[x];
    }
    bool same(int x, int y){
        return find(x)==find(y);
    }
    int size(int x){
        return sz[find(x)];
    }
};
int main()
{
	int n;
	cin>>n;
	if(n==0){
		cout<<1<<endl;
		return 0;
	}
	P p[120020];
	for(int i=0; i<n; i++){
		cin>>p[i].x>>p[i].y;
	}
	sort(p, p+n);
	unionfind uf(n);
	vector<P> w;
	for(int i=-10; i<=10; i++){
		for(int j=-10; j<=10; j++){
			if(i*i+j*j<=100){
				w.push_back(P(i, j));
			}
		}
	}
	for(int i=0; i<n; i++){
		for(auto q:w){
			int k=lower_bound(p, p+n, p[i]+q)-p;
			if(k<n && p[k]==p[i]+q) uf.unite(i, k);
		}
	}
	vector<P> v[120020];
	for(int i=0; i<n; i++) v[uf.find(i)].push_back(p[i]);
	double ans=0;
	for(int i=0; i<n; i++){
		if(v[i].size()<=1) continue;
		ans=max(ans, maxdist(convex_hull(v[i])));
	}
	printf("%.7lf\n", ans+2);
	return 0;
}