using System;
using System.IO;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using Enu = System.Linq.Enumerable;

class Program
{
    static readonly int[] DX = { 0, 0, 1, 1, 1 };
    static readonly int[] DY = { 0, 1, -1, 0, 1 };

    void Solve()
    {
        int N = reader.Int();
        var P = reader.IntGrid(N).Select((a, i) => new Vec(a[0], a[1], i)).ToArray();
        var dic = new Dictionary<int, List<Vec>>();
        Func<long, long, int> Key = (x, y) => (int)(x * 10000 + y);
        Array.ForEach(P, p => AddDic(dic, Key(p.X / 10, p.Y / 10), p));
        var uf = new UnionFind(N);

        foreach (var a in P)
            for (int d = 0; d < DX.Length; d++)
            {
                long x = a.X / 10 + DX[d], y = a.Y / 10 + DY[d];
                if (!dic.ContainsKey(Key(x, y))) continue;
                foreach (var b in dic[Key(x, y)])
                    if (a.DistSquare(b) <= 100)
                        uf.Unite(a.Id, b.Id);
            }
        var component = new Dictionary<int, List<Vec>>();
        for (int i = 0; i < N; i++)
            if (uf.NumElements(i) > 1)
                AddDic(component, uf.Root(i), P[i]);
        double ans = (N > 0) ? 2 : 1;
        foreach (var list in component.Values.Select(li => ConvexHull(li)))
            for (int a = 0; a < list.Count; a++)
                for (int b = a + 1; b < list.Count; b++)
                    ans = Math.Max(ans, list[a].Dist(list[b]) + 2);
        Console.WriteLine(ans);
    }

    List<Vec> ConvexHull(List<Vec> Ps)
    {
        Ps.Sort();
        var res = new List<Vec>();
        for (int i = 0; i < Ps.Count; i++)
        {
            while (res.Count > 1 && (res[res.Count - 1] - res[res.Count - 2]).Det(Ps[i] - res[res.Count - 1]) <= 0)
                res.RemoveAt(res.Count - 1);
            res.Add(Ps[i]);
        }
        for (int i = Ps.Count - 2, t = res.Count; i >= 0; i--)
        {
            while (res.Count > t && (res[res.Count - 1] - res[res.Count - 2]).Det(Ps[i] - res[res.Count - 1]) <= 0)
                res.RemoveAt(res.Count - 1);
            res.Add(Ps[i]);
        }
        return res.GetRange(0, res.Count - 1);
    }

    void AddDic(Dictionary<int, List<Vec>> dic, int key, Vec val)
    {
        if (!dic.ContainsKey(key)) dic[key] = new List<Vec>();
        dic[key].Add(val);
    }

    class Vec : Vector2D
    {
        public int Id;
        public Vec(int x, int y, int i) : base(x, y) { Id = i; }
    }
    class Vector2D : IEquatable<Vector2D>, IComparable<Vector2D>
    {
        public long X, Y;
        public Vector2D(long x, long y) { X = x; Y = y; }
        public static Vector2D operator +(Vector2D a, Vector2D b)
        {
            return new Vector2D(a.X + b.X, a.Y + b.Y);
        }
        public static Vector2D operator -(Vector2D a, Vector2D b)
        {
            return new Vector2D(a.X - b.X, a.Y - b.Y);
        }
        public long DistSquare(Vector2D b) { return (X - b.X) * (X - b.X) + (Y - b.Y) * (Y - b.Y); }
        public double Dist(Vector2D b) { return Math.Sqrt(DistSquare(b)); }
        public long InnerProduct(Vector2D b) { return X * b.X + Y * b.Y; }
        public long Det(Vector2D b) { return X * b.Y - Y * b.X; }
        public override int GetHashCode() { return (int)(X * 10007 + Y); }
        public bool Equals(Vector2D b) { return X == b.X && Y == b.Y; }
        public int CompareTo(Vector2D b) { return X != b.X ? Math.Sign(X - b.X) : Math.Sign(Y - b.Y); }
    }

    class UnionFind
    {
        private int[] parent;
        private int[] rank;
        private int[] numElements;

        public UnionFind(int N)
        {
            parent = new int[N];
            rank = new int[N];
            numElements = new int[N];
            for (int i = 0; i < N; i++)
            {
                parent[i] = i;
                numElements[i] = 1;
            }
        }
        public int Root(int x)
        {
            if (parent[x] == x) return x;
            return parent[x] = Root(parent[x]);
        }
        public bool Same(int x, int y)
        {
            return Root(x) == Root(y);
        }
        public int NumElements(int x)
        {
            return numElements[Root(x)];
        }
        public void Unite(int x, int y)
        {
            x = Root(x); y = Root(y);
            if (x == y) return;
            if (rank[x] < rank[y])
            {
                parent[x] = y;
                numElements[y] += numElements[x];
            }
            else
            {
                parent[y] = x;
                if (rank[x] == rank[y]) { rank[x]++; }
                numElements[x] += numElements[y];
            }
        }
    }





    Reader reader = new Reader(Console.In);
    static void Main() { new Program().Solve(); }
}

class Reader
{
    private readonly TextReader reader;
    private readonly char[] separator = { ' ' };
    private readonly StringSplitOptions removeOp = StringSplitOptions.RemoveEmptyEntries;
    private string[] A = new string[0];
    private int i;

    public Reader(TextReader r) { reader = r; }
    public Reader(string file) { reader = new StreamReader(file); }
    public bool HasNext() { return Enqueue(); }
    public string String() { return Dequeue(); }
    public int Int() { return int.Parse(Dequeue()); }
    public long Long() { return long.Parse(Dequeue()); }
    public double Double() { return double.Parse(Dequeue()); }
    public int[] IntLine() { var s = Line(); return s == "" ? new int[0] : Array.ConvertAll(Split(s), int.Parse); }
    public int[] IntArray(int N) { return Enu.Range(0, N).Select(i => Int()).ToArray(); }
    public int[][] IntGrid(int H) { return Enu.Range(0, H).Select(i => IntLine()).ToArray(); }
    public string[] StringArray(int N) { return Enu.Range(0, N).Select(i => Line()).ToArray(); }
    public string Line() { return reader.ReadLine().Trim(); }
    private string[] Split(string s) { return s.Split(separator, removeOp); }
    private bool Enqueue()
    {
        if (i < A.Length) return true;
        string line = reader.ReadLine();
        if (line == null) return false;
        if (line == "") return Enqueue();
        A = Split(line);
        i = 0;
        return true;
    }
    private string Dequeue() { Enqueue(); return A[i++]; }
}