// #pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
// #pragma GCC optimization ("unroll-loops") 

#include<bits/stdc++.h>
using namespace std;
#define crap ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL) 
 
typedef long long int ll;
typedef unsigned long long ull;
 
#define int ll
 
typedef std::vector<int> vi;
typedef std::vector<ll> vll;
typedef std::vector<vi > vvi;
typedef std::vector<vll > vvll;
typedef std::pair<int,int> ii;
typedef std::pair<int, ii > iii;
typedef std::pair< ll, ll > lp;
typedef std::vector<ii> vii;
typedef std::vector<vii > vvii;
 
#define pb push_back 
#define PB pop_back
#define pf push_front
#define PF pop_front
#define mp make_pair
#define ub(a,b) upper_bound(all(a),b)
#define lb(a,b) lower_bound(all(a),b)
#define bs(a,b) binary_search(all(a),b)
#define mem(a,b) memset(a,b,sizeof(a))
#define in(a,n) F(i,0,n-1)cin>>a[i]
#define in1(a,n) F(i,1,n)cin>>a[i]
#define out(a,n) F(i,0,n-1)cout<<a[i]<<" ";cout<<endl
#define ff first
#define ss second
#define F(i,a,b) for (ll i=a;i<=b;i++)
#define RF(i,a,b) for(ll i=a;i>=b;i--)
#define rep(i,n) F(i,0,n-1)
#define clr(a) (a).clear()
#define rz resize
#define sqr(a) ((a) * (a))
#define sz(a) int((a).size())
#define len(a) int((a).length())
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin() ,(a).rend()
#define endl '\n'
#define flush cout.flush()
 
// int mod;
// #define mod (int)1e9+123
#define mod 1000000007
// #define mod 998244353
 
// ################################## Debugging statements  ##################################
string to_string(string s) {return '"' + s + '"';}
string to_string(const char* s) {return to_string((string) s);}
string to_string(bool b) {return (b ? "true" : "false");}
template <typename A, typename B>
string to_string(pair<A, B> p) {return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
template <typename A>
string to_string(A v) {bool first = true;  string res = "{";for (const auto &x : v) {if (!first) { res += ", "; }first = false; res += to_string(x);}res += "}";return res;}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {cerr << " " << to_string(H);debug_out(T...);}
#define TRACE // comment this out for submission
#ifdef TRACE
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
// ###########################################################################################
 
inline int add(int a, int b){a += b; if(a >= mod)a -= mod; return a;}
inline int sub(int a, int b){a -= b; if(a < 0)a += mod; return a;}
inline int mul(int a, int b){return (int)((long long) a * b %mod);}
inline int poww(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = mul(res, a); a = mul(a, a);b /= 2;} return res;}
inline int inv(int a){return poww(a, mod - 2);}
int gcd(int a, int b, int &x, int &y){if(a == 0){x = 0, y = 1; return b;} int x1, y1;  int d = gcd(b%a, a, x1, y1); x = y1 - (b/a) * x1; y = x1; return d;}
 
// #################################### matrix operations ####################################
inline vvi matmul(vvi A, vvi B) {int p = A.size(), q = A[0].size();int r = B.size(), s = B[0].size();assert(q == r);vvi C(p, vi(s, 0LL));
    rep(i, p){rep(j, s){rep(k, q){
                // C[i][j] += A[i][k] * B[k][j]; 
                C[i][j] = add(C[i][j], mul(A[i][k], B[k][j]));
    }}}return C;}
 
inline vvi matpow(vvi A, int n){int p = A.size(), q = A[0].size();assert(p == q);vvi res(p, vi(p, 0));rep(i, p)res[i][i] = 1;while (n){if (n&1)res = matmul(res, A);A = matmul(A, A);n >>= 1;}return res;}
 
// ###########################################################################################
 
// #################################### Combinatorics template ###############################
struct factorial{
    int N;int *fac;int *ifac; int *der; int MOD;
    factorial(int n, int m = 1000000007){N = n;MOD = m;fac = new int[1+N];ifac = new int[1+N];der= new int[N+1];pre_calc(); calc_derangement();}
    int add(int a, int b){a += b; if(a >= MOD)a -= MOD; return a;}
    int subtract(int a, int b){a -= b; if(a < 0)a += MOD; return a;}
    int multiply(int a, int b){return (int)((long long) a * b %MOD);}
    int binpow(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = multiply(res, a); a = multiply(a, a);b /= 2;} return res;}
    int inverse(int a){return binpow(a, MOD - 2);}
    void pre_calc(){fac[0] = ifac[0] = 1;for (int i = 1 ; i <= N ; i++){fac[i] = multiply(fac[i-1], i);ifac[i] = multiply(ifac[i-1], inverse(i));}}
    int ncr(int n , int r){return multiply(fac[n], multiply(ifac[r], ifac[n-r]));}
    void calc_derangement(){
        der[1] = 0;der[2] = 1;
        for (int i = 3; i <= N; i++){
            der[i] = multiply(i-1, add(der[i-1], der[i-2]));
        }
    }
    int derangement(int n){
        if (n == 1) return 1;
        return der[n];
    }
};
 
vi factors_n(int n){std::vector<int> fac;for (int i = 1; i * i <= n ; i++){if (n % i == 0){fac.push_back(i);if (i * i != n){fac.push_back(n/i);}}}return fac;}
// ###########################################################################################
 
// ##################################### Fenwick Tree template ###############################
struct fenwick_tree{
    int *bit;int n;
    fenwick_tree(){this->n = 1000005;this->bit = new int[1000005+1]; init_bit();}
    fenwick_tree(int n){this->n = n;this->bit = new int[n+1]; init_bit();}
    void init_bit(){for (int i=0; i <= this->n; i++)this->bit[i]=0;}
    void add(int i, int v){for (; i<=this->n; i+= i&-i){this->bit[i] += v; this->bit[i] %= mod; }}
    int get(int i){int s = 0;for (; i; i -= i&-i){s += this->bit[i]; s %= mod; }return s;}
};
// ###########################################################################################
 
// ######################################## Policy-based DS ##################################
// #include<ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
 
// template<class key, class value = null_type, class cmp = std::less<key>>
// using ordered_tree = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// order_of_key (val): returns the no. of values less than val
// find_by_order (k): returns the iterator to kth largest element.(0-based)
 
// ###########################################################################################
 
// ######################################## Bit manipulations ##################################
int no_of_ones(int n){return __builtin_popcount(n);}
int setmask(int mask, int i){return mask | (1 << i);}
int unsetmask(int mask, int i){return (mask & !(1 << i));}
// ###########################################################################################
 
// ###################################### Convex Hull Trick  ##################################
// struct Line {
//     mutable ll k, m, p;
//     bool operator<(const Line& o) const { return k < o.k; }
//     bool operator<(ll x) const { return p < x; }
// };
 
// struct LineContainer : multiset<Line, less<>> {
//     // (for doubles, use inf = 1/.0, div(a,b) = a/b)
//     const ll inf = LLONG_MAX;
//     ll div(ll a, ll b) { // floored division
//         return a / b - ((a ^ b) < 0 && a % b); }
//     bool isect(iterator x, iterator y) {
//         if (y == end()) { x->p = inf; return false; }
//         if (x->k == y->k) x->p = x->m > y->m ? inf : -inf;
//         else x->p = div(y->m - x->m, x->k - y->k);
//         return x->p >= y->p;
//     }
//     void add(ll k, ll m) { // y = k * x + m
//         auto z = insert({k, m, 0}), y = z++, x = y;
//         while (isect(y, z)) z = erase(z);
//         if (x != begin() && isect(--x, y)) isect(x, y = erase(y));
//         while ((y = x) != begin() && (--x)->p >= y->p)
//             isect(x, erase(y));
//     }
//     ll query(ll x) {
//         assert(!empty());
//         auto l = *lower_bound(x);
//         return l.k * x + l.m;
//     }
// };
// ###########################################################################################
 
// ######################################## Disjoint Set ##################################
struct disjoint_sets{
    int n;
    vector<int> par;
    vector<int> ranks;
    disjoint_sets(int _n):n(_n){
        for (int i = 0; i <= n; i++){
            par.emplace_back(i);
            ranks.emplace_back(1);
        }
    }
    int find_root(int u){// path compression
        return (par[u] == u) ? u : (par[u] = find_root(par[u]));
    }
    void merge_node(int u, int v){
        u = find_root(u), v = find_root(v);
        if (u == v)
            return;
        if (ranks[u] < ranks[v])
            swap(u, v);
        par[v] = u;
        ranks[u] += ranks[v];
    }
};
// ###########################################################################################
 
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
 
// ################################### Template ends here ####################################

const int N = 1e5 + 5;




void solve(){
    int n;
    cin >> n;
    vi a, b, c, d;
    rep(i, n){
        int x, y;
        cin >> x >> y;
        a.pb(x+y);
        b.pb(x-y);
        c.pb(-x+y);
        d.pb(-x-y);
    }
    sort(all(a));
    int ans = a[n-1] - a[0];
    sort(all(d));
    sort(all(b));
    sort(all(c));
    ans = max(ans, abs(*b.rbegin()-*b.begin()));
    ans = max(ans, abs(*c.rbegin()-*c.begin()));
    ans = max(ans, abs(*d.rbegin()-*d.begin()));
    cout << ans << endl;
}

signed main(){
    crap;
    int t = 1;
    // cin >> t;
    int t0 = 1;
    while (t--){
        // cout<<"Case #"<< t0++ <<": ";
        solve();
        auto init = [&](){
            // clear glbl var here
            
        };
        init();
    }
}

Measured memory_bytes: 9728