#!/usr/bin/python3

import array
from fractions import Fraction
import functools
import itertools
import math
import os
import sys


def main():
    N = read_int()
    P = []
    for _ in range(N):
        x, y = [Fraction(s) for s in inp().split()]
        P.append(Vec(x, y))
    print(solve(N, P))


def lcm(a, b):
    return a * b // math.gcd(a, b)


def solve(N, P):
    factor = 1
    for p in P:
        factor = lcm(lcm(factor, p.x.denominator), p.y.denominator)

    F = [Vec(int(p.x * factor), int(p.y * factor)) for p in P]

    pi = 0
    pyx = (F[0].y, F[0].x)
    qi = 0
    qyx = pyx

    for i, a in enumerate(F):
        ayx = (a.y, a.x)
        if pyx > ayx:
            pi = i
            pyx = ayx
        if qyx < ayx:
            qi = i
            qyx = ayx

    p0i = pi
    q0i = qi
    best = (F[pi] - F[qi]).abs2()
    while True:
        p = F[pi]
        p1 = F[(pi + 1) % N]
        q = F[qi]
        q1 = F[(qi + 1) % N]
        if (p1 - p).cross(q1 - q) >= 0:
            qi = (qi + 1) % N
        else:
            pi = (pi + 1) % N

        best = max(best, (F[pi] - F[qi]).abs2())

        if pi == p0i and qi == q0i:
            break

    return math.sqrt(Fraction(best, factor * factor))


###############################################################################
# AUXILIARY FUNCTIONS

class Vec(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y
        super().__init__()

    def __add__(self, other):
        return Vec(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return Vec(self.x - other.x, self.y - other.y)

    def __mul__(self, scalar):
        return Vec(self.x * scalar, self.y * scalar)

    def __rmul__(self, scalar):
        return Vec(self.x * scalar, self.y * scalar)

    def __truediv__(self, scalar):
        return Vec(self.x / scalar, self.y / scalar)

    def __iadd__(self, other):
        self.x += other.x
        self.y += other.y
        return self

    def __isub__(self, other):
        self.x -= other.x
        self.y -= other.y
        return self

    def __imul__(self, scalar):
        self.x *= scalar
        self.y *= scalar
        return self

    def __idiv__(self, scalar):
        self.x /= scalar
        self.y /= scalar
        return self

    def __neg__(self):
        return Vec(-self.x, -self.y)

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

    def __ne__(self, other):
        return not self.__eq__(other)

    def __hash__(self):
        return hash('Vec', self.x, self.y)

    def dot(self, other):
        return self.x * other.x + self.y * other.y

    def cross(self, other):
        return self.x * other.y - self.y * other.x

    def abs2(self):
        return self.x * self.x + self.y * self.y

    def __abs__(self):
        return math.sqrt(float(self.abs2()))

    def __repr__(self):
        return '({}, {})'.format(self.x, self.y)


DEBUG = 'DEBUG' in os.environ


def inp():
    return sys.stdin.readline().rstrip()


def read_int():
    return int(inp())


def read_ints():
    return [int(e) for e in inp().split()]


def dprint(*value, sep=' ', end='\n'):
    if DEBUG:
        print(*value, sep=sep, end=end)


if __name__ == '__main__':
    main()



Measured memory_bytes: 52440