#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define int long long

#define all(X) (X).begin(), (X).end()
#define reset(X) memset(X, 0, sizeof(X))
#define mp(a, b) make_pair(a, b)
#define pb push_back
#define endl '\n'
#define fi first
#define se second

using namespace __gnu_pbds;
using namespace std;
const int mod = 1e9+7;
//const int mod=998'244'353;
//const int mod=1e9+9;

const int MOD = mod;

const int INF=4e18+10;
// const int INF = 4e18 + 10;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using ordered_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define read(n) \
    int n;      \
cin >> n;
#define readv(x, n)   \
    vector<int> x(n); \
for (auto &i : x) \
cin >> i;

typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef pair<int, int> pii;

template <typename T1, typename T2>
void set_min(T1 &a, T2 b){
    a = min(a, (T1)b);
}
/* template <typename T1, typename T2> */
bool sort_by_sec(pair<int, int> a, pair<int,int> b)
{
    return make_pair(a.se, a.fi)<make_pair(b.se,b.fi);
}

int multiply(int a, int b, int in_mod) { return (int)(1LL*a * b % in_mod );}
int mult_identity(int a) { return 1; }

int mod_inv(int q, int in_mod);

// const int mod = 998244353;
// const int root  = 15311432;
// const int root_pw = 1<<23;
// const int root_1 = mod_inv(root, mod);

//const int mod = 7340033;
//const int root  = 5;
//const int root_pw = 1<<20;
//const int root_1 = 4404020;

vector<int >multiply(const vector<int>& a, const vector<int>& b,int mod);
vector<int> mult_identity(vector<int> a)
{
    return {1};
}

vector<int> operator%(vector<int> a, int mod)
{
    return a;
}





auto power(auto a, int b, int in_mod)
{

    // if(b>=in_mod)
    //     b%=in_mod-1;
    auto prod = mult_identity(a);
    auto mult = a % in_mod;
    while (b != 0)
    {
        if (b % 2)
        {
            prod = multiply(prod, mult, in_mod);
        }
        mult = multiply(mult, mult, in_mod);
        b /= 2;
    }
    return prod;
}
int mod_inv(int q, int in_mod)
{

    return power(q, in_mod - 2, in_mod);
}

std::vector<long long> factorial;
std::vector<long long> infactorial;

void precompute_factorial(int ma)
{
    factorial.push_back(1);
    infactorial.pb(1);
    for (int i = 1; i <= ma; i++)
    {
        factorial.push_back((factorial.back() * i) % MOD);
        infactorial.push_back((infactorial.back() * mod_inv(i,mod)) % MOD);
    }
}
void solve()
{
    int n;
    cin>>n;
    vector<pair<int, int>> v;
    for(int i = 0;i<n;i++)
    {
        int x, y;
        cin>>x>>y;
        v.pb({x,y});
    }
    int mx = 0;
    for(int j= 0;j<(1<<2);j++)
    {
        set<int> values;
        for(auto i:v)
        {
            int x = 0;
            if(j%2)
                x += i.fi;
            else
                x -= i.fi;

            if(j>>1)
                x += i.se;
            else
                x -= i.se;
            if(values.size())
            {
                mx = max(mx, x - *values.begin());
                mx = max(mx, x - *values.rbegin());
            }
            values.insert(x);

        }
    }
    cout<<mx<<endl;
}
    


signed main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cerr.tie(NULL);
     #ifndef ONLINE_JUDGE
         if (fopen("INPUT.txt", "r"))
         {
             freopen("INPUT.txt", "r", stdin);
             freopen("OUTPUT.txt", "w", stdout);
         }
     #endif
    auto clk = clock();
    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
    // -------------------------------------Code starts here---------------------------------------------------------------------

    int t = 1;
    /* cin >> t; */

    for (int test = 1; test <= t; test++)
    {
        /* cout<<"Case #"<<test<<": "; */
        solve();
        // cout<<endl;
    }

    // -------------------------------------Code ends here------------------------------------------------------------------

    clk = clock() - clk;
    // cerr << fixed << setprecision(6) << "Time: " << ((long double)clk) / CLOCKS_PER_SEC << "\n";
    return 0;
}


Measured memory_bytes: 15900