#include <bits/stdc++.h>

typedef long double T;
const T eps = 1e-10;

using std::cin;
using std::cout;
using std::endl;

struct pt
{
	T x, y;
	pt (T x = 0.0, T y = 0.0) : x(x), y(y) { }
	pt operator+(const pt &z) const { return pt(x + z.x, y + z.y); }
	pt operator-(const pt &z) const { return pt(x - z.x, y - z.y); }
	pt operator*(const T k) const { return pt(x * k, y * k); }
	pt operator/(const T k) const { return pt(x / k, y / k); }
	bool operator==(const pt &z) const
	{
		return x == z.x && y == z.y;
	}
	bool operator!=(const pt &z) const
	{
		return x != z.x || y != z.y;
	}
};
pt operator*(const T k, const pt &z) { return pt(z.x * k, z.y * k); }
pt operator/(const T k, const pt &z) { return pt(z.x / k, z.y / k); }

std::istream& operator>>(std::istream &inf, pt &p)
{
	return inf >> p.x >> p.y;
}

std::ostream& operator<<(std::ostream &ouf, const pt &p)
{
	return ouf << p.x << " " << p.y;
}

inline T dot(const pt &a, const pt &b) 
{
	return a.x * b.x + a.y * b.y;
}
inline T cross(const pt &a, const pt &b)
{
	return a.x * b.y - a.y * b.x;
}
inline T sq(const pt &a)
{
	return a.x * a.x + a.y * a.y;
}
inline T abs(const pt &a)
{
	return sqrtl(sq(a));
}
inline pt perp(const pt &p)
{
	return pt(-p.y, p.x);
}
inline int dcmp(const T x)
{
	if (x > eps) return 1;
	if (x < -eps) return -1;
	return 0;
}

struct ln
{
	pt v; T c;
	ln(pt v, T c) : v(v), c(c) { } // direction vector + offset
	ln(T a, T b, T c) : v({b, -a}), c(c) { } // ax + by = c
	ln(pt p, pt q) : v(q - p), c(cross(v, p)) { } // p, q
	T side(const pt &p) const
	{
		return cross(v, p) - c;
	}
	T dist(const pt &p) const
	{
		return abs(side(p)) / abs(v);
	}
	ln perpThough(const pt &p) const
	{
		return ln(p, p + perp(v));
	}
	pt proj(const pt &p) const
	{
		T k = -side(p) / sq(v);
		return p + k * perp(v);
	}
	pt refl(const pt &p) const
	{
		T k = -2 * side(p) / sq(v);
		return p + k * perp(v);
	}
	bool cmpProj(const pt &p, const pt &q) const
	{
		return dot(v, p) < dot(v, q);
	}
};
inline bool inter(const ln &l1, const ln &l2, pt &out)
{
	T d = cross(l1.v, l2.v);
	if (dcmp(d) == 0) return false;
	out = (l1.c * l2.v - l1.v * l2.c) / d;
	return true;
}

// a, b, c clockwise <=> < 0
// a, b, c counter-clockwise <=> > 0
inline T orient(const pt &a, const pt &b, const pt &c)
{
	return cross(b - a, c - a);
}

inline bool inDisk(const pt &a, const pt &b, const pt &p)
{
	return dot(a - p, b - p) <= 0;
}

inline bool onSegment(const pt &a, const pt &b, const pt &p)
{
	return dcmp(orient(a, b, p)) == 0 && inDisk(a, b, p);
}

inline bool properInter(const pt &a, const pt &b, const pt &c, const pt &d, pt &out)
{
	T oa = orient(c, d, a), ob = orient(c, d, b), oc = orient(a, b, c), od = orient(a, b, d);
	if (oa * ob < 0 && oc * od < 0)
	{
		out = (a * ob - b * oa) / (ob - oa);
		return true;
	}
	return false;
}

inline T segPoint(const pt &a, const pt &b, const pt &p)
{
	if (a != b)
	{
		ln l(a, b);
		if (l.cmpProj(a, p) && l.cmpProj(p, b))
			return l.dist(p);
	}
	return std::min(abs(p - a), abs(p - b));
}

inline T segSeg(const pt &a, const pt &b, const pt &c, const pt &d)
{
	pt dummy;
	if (properInter(a, b, c, d, dummy)) return 0;
	return std::min({ segPoint(a, b, c), segPoint(a, b, d), segPoint(c, d, a), segPoint(c, d, b) });
}

inline T areaPolygon(std::vector<pt> p)
{
	T area = 0.0;
	for (int i = 0, n = p.size(); i < n; ++i)
	{
		area += cross(p[i], p[(i + 1) % n]);
	}
	return abs(area) / 2.0;
}

inline bool above(const pt &a, const pt &b)
{
	return a.y >= b.y;
}

inline bool crossesRay(const pt &a, const pt &p, const pt &q)
{
	return (above(a, q) - above(a, p)) * orient(a, p, q) > 0;
}

inline bool inPolygon(std::vector<pt> p, const pt &a, bool strict = true)
{
	int c = 0;
	for (int i = 0, n = p.size(); i < n; ++i)
	{
		if (onSegment(p[i], p[(i + 1) % n], a))
			return !strict;
		c ^= crossesRay(a, p[i], p[(i + 1) % n]);
	}
	return c & 1;
}

inline std::vector<pt> convexHull(std::vector<pt> p)
{
	if (p.size() <= 2) return p;
	std::sort(p.begin(), p.end(), [&](const pt &x, const pt &y) { return x.x == y.x ? x.y < y.y : x.x < y.x; });
	std::vector<int> st, vis(p.size());
	st.push_back(0);	
	for (int i = 1; i < p.size(); ++i)
	{
		
		while (st.size() > 1 && orient(p[st[st.size() - 2]], p[st[st.size() - 1]], p[i]) < 0) vis[st.back()] = false, st.pop_back();
		st.push_back(i); vis[i] = true;
	}
	int cur = st.size();
	for (int i = p.size() - 2; i >= 0; --i)
	{
		if (!vis[i])
		{
			while (st.size() > cur && orient(p[st[st.size() - 2]], p[st[st.size() - 1]], p[i]) < 0) vis[st.back()] = false, st.pop_back();
			st.push_back(i); vis[i] = true;
		}
	}
	std::vector<pt> res;
	for (int i = 0; i < st.size() - 1; ++i) res.push_back(p[st[i]]);
	return res;
}

inline T convexDiameter(std::vector<pt> p)
{
	if (p.size() <= 1) return 0;
	int i0 = 0, j0 = 0, n = p.size();
	auto cmp = [&](const pt &a, const pt &b) 
	{
		return a.x == b.x ? a.y < b.y : a.x < b.x;
	};
	for (int i = 1; i < n; ++i)
	{
		if (cmp(p[i0], p[i])) i0 = i;
		if (cmp(p[i], p[j0])) j0 = i;
	}
	int i = i0, j = j0; T d = 0.0;
	do
	{
		d = std::max(d, abs(p[i] - p[j]));
		if (cross(p[(i + 1) % n] - p[i], p[(j + 1) % n] - p[j]) < 0) i = (i + 1) % n;
		else j = (j + 1) % n;
	} while (i != i0 || j != j0);
	return d;
}

int main()
{
	std::ios::sync_with_stdio(false);
	cin.tie(nullptr); cout.tie(nullptr);
	cout << std::fixed << std::setprecision(15);

	int n;
	cin >> n;
	assert(n>=300);
	std::vector<pt> v(n);
	for (int i = 0; i < n; ++i) cin >> v[i];
	cout << convexDiameter(v);
	return 0;
}