/* Generated by cf-tool.
 * You can download the binary file in here: 
 * https://github.com/xalanq/cf-tool (Windows, macOS, Linux)
 * Author: $%U%$
 * Time: $%Y%$-$%M%$-$%D%$ $%h%$:$%m%$:$%s%$
**/

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

template <typename T = double>
using point = complex<T>; // 2D point only

using ll = long long;
using ull = unsigned long long;

using ii = pair<int,int>;
using iii = pair<int, ii>;
using ii_i = pair<ii, int>;
using vi = vector<int>;
using vvi = vector<vi>;
using vii = vector<ii>;
using viii = vector<iii>;
template <typename T = int>
using lim = numeric_limits<T>;

#ifdef _DEBUG
#define debug_text(...) printf(__VA_ARGS__)
#else
#define debug_text(...) /* --- NOTHING --- */
#endif

#define re real()
#define im imag()
#define fi first
#define se second
#define sz(v) (v).size()
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()

// OST
template <typename T>
using ordered_set = __gnu_pbds::tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

// from: https://codeforces.com/blog/entry/62393
// struct custom_hash {
// 	static uint64_t splitmix64(uint64_t x) {
// 		// http://xorshift.di.unimi.it/splitmix64.c
// 		x += 0x9e3779b97f4a7c15;
// 		x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
// 		x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
// 		return x ^ (x >> 31);
// 	}

// 	size_t operator()(uint64_t x) const {
// 		static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
// 		return splitmix64(x + FIXED_RANDOM);
// 	}
// };

const int INF = ~(1<<31);
const ll LINF = (1LL << 60);
const long double EPS = 1e-9;
const long double PI = acos(-1);

const int N = 1005;
const int M = 1 << 19;
const int MOD = 1e9+7; // 998244353;
const int MOD2 = 1e9+9;
const int IMAX = 1e9+7;
const ll LMOD = 1LL << 59;
const ll LMAX = 1e16+7;
const ll Pr = 131;
const ll P2 = 151;
const int dx[4] = {0,0,-1,1};
const int dy[4] = {-1,1,0,0};
const int dx8[8] = {-1,-1,-1,0,0,1,1,1};
const int dy8[8] = {-1,0,1,-1,1,-1,0,1};

template <typename T>
struct vector2D {
	T x, y;
	vector2D(T _x = 0, T _y = 0): x(_x), y(_y) {}
	vector2D& operator+=(const vector2D& rhs) { x += rhs.x; y += rhs.y; return *this; }
	vector2D& operator-=(const vector2D& rhs) { x -= rhs.x; y -= rhs.y; return *this; }
	vector2D& operator*=(const T& rhs) { x *= rhs; y *= rhs; return *this; }
	vector2D& operator/=(const T& rhs) { x /= rhs; y /= rhs; return *this; }
	vector2D operator-() const { return vector2D(-x,-y); }
	vector2D operator+(const vector2D& rhs) const { return vector2D(*this) += rhs; }
	vector2D operator-(const vector2D& rhs) const { return vector2D(*this) -= rhs; }
	vector2D operator*(const T& rhs) const { return vector2D(*this) *= rhs; }
	vector2D operator/(const T& rhs) const { return vector2D(*this) /= rhs; }
	T operator*(const vector2D& rhs) const { return x*rhs.x+y*rhs.y; } // dot
	T operator%(const vector2D& rhs) const { return x*rhs.y-rhs.x*y; } // cross
	bool operator==(const vector2D& rhs) const { return abs(x-rhs.x) < EPS and abs(y-rhs.y) < EPS; }
	bool operator!=(const vector2D& rhs) const { return not (*this == rhs); }
	bool operator<(const vector2D& rhs) const { return x < rhs.x-EPS or (abs(x-rhs.x) < EPS and y < rhs.y-EPS); }
	vector2D perp() const { return vector2D(-y,x); }
	T angle() const {return atan2(y,x);}
	T squared_norm() const { return (*this)*(*this); }
	T norm() const {return sqrt(squared_norm()); }
	T scalar_project(const vector2D& v) const {return (*this)*v/v.norm();}
	vector2D vector_project(const vector2D& v) const {return v*(((*this)*v)/(v*v));}
	vector2D normalized() const {return *this/norm(); }
	vector2D rotate(const T& a) const {return vector2D(cos(a)*x-sin(a)*y,sin(a)*x+cos(a)*y); }
	friend vector2D operator*(const T& lhs, const vector2D& rhs) {return rhs*lhs; }
	friend ostream& operator<<(ostream& o, const vector2D& v) {return o << "(" << v.x << "," << v.y << ")"; }
	friend istream& operator>>(istream& i, vector2D& v) {return i >> v.x >> v.y;}
};

using P = vector2D<ll>;

vector<P> convex_hull(vector<P> pts) {
	sort(pts.begin(), pts.end());
	int top = 0;
	vector<P> stk(2*pts.size());
	for (int i = 0; i < pts.size(); ++i) {
		while (top >= 2 and (stk[top-1]-stk[top-2])%(pts[i]-stk[top-2]) <= 0) top--;
		stk[top++] = pts[i];
	}
	for (int i = pts.size()-2, t = top+1; i >= 0; --i) {
		while (top >= t and (stk[top-1]-stk[top-2])%(pts[i]-stk[top-2]) <= 0) top--;
		stk[top++] = pts[i];
	}
	stk.resize(top-1);
	return stk;
}

void solution() {
	int n; cin >> n;
	vector<P> pts(n);
	for (int i = 0; i < n; ++i) {
		cin >> pts[i].x >> pts[i].y;
	}

	vector<P> chull = convex_hull(pts);

	int nn = sz(chull);

	ll ans = 0;
	int nxt = 0;
	for (int i = 0; i < nn; ++i) {
		// if (i == 0) {
		// 	int tmp = 0;
		// 	while (abs(chull[i].x-chull[nxt].x) + abs(chull[i].y-chull[nxt].y) > tmp) {
		// 		tmp = abs(chull[i].x-chull[nxt].x) + abs(chull[i].y-chull[nxt].y);
		// 		nxt = (nxt+1)%nn;
		// 	}
		// 	ans = max(ans, tmp);
		// } else {
		// 	while (abs(chull[i].x-chull[nxt].x) + abs(chull[i].y-chull[nxt].y) < abs(chull[i].x-chull[(nxt+1)%nn].x) + abs(chull[i].y-chull[(nxt+1)%nn].y))
		// 		nxt = (nxt+1)%nn;
		// 	ans = max(ans, abs(chull[i].x-chull[nxt].x) + abs(chull[i].y-chull[nxt].y));
		// }
		for (int j = 0; j < nn; ++j) {
			ans = max(ans, abs(chull[i].x - chull[j].x) + abs(chull[i].y - chull[j].y));
		}
	}

	cout << ans << endl;

}

void pregen() {
	
}

void prepare() {
	
}

int main () {
	ios_base::sync_with_stdio(false); cin.tie(0); // cout.tie(0);
	// cout.precision(2); cout << fixed;

	int T = 1;
	// cin >> T;
	pregen();
	for (int i = 1; i <= T; ++i) {
		prepare();
		solution();
	}

	return 0;
}

Measured memory_bytes: 15864