#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vl2;
const bool multiple_queries = false;
#define rep(i, n) for(ll i = 0; i < (n) ; ++i)
#define For(i, a, b) for(ll i = (a); i < (b) ; ++i)
#define revrep(i, n) for(ll i = (n) - 1; i >= 0 ; --i)
#define revFor(i, b, a) for(ll i = (b) - 1; i >= (a) ; --i)
#define all(v) v.begin(), v.end()
#define rall(v) (v).rbegin(), (v).rend()
#define popcount(i) __builtin_popcountl((i))
#define substring(s, start, end) s.substr((start), (end) - (start) + 1)

void print(){cout;}
void println(){cout << endl;}

template <class Head, class... Tail>
void print(Head&& head, Tail&&... tail) {
    cout << head;
    if (sizeof...(tail) != 0) cout << " ";
    print(forward<Tail>(tail)...);
}

template <class Head, class... Tail>
void println(Head&& head, Tail&&... tail) {
    cout << head;
    if (sizeof...(tail) != 0) cout << " ";
    println(forward<Tail>(tail)...);
}

struct point {
    ll x = 0; ll y = 0;
    bool operator<(const point& p) const{
        if (x == p.x) return y < p.y;
        return x < p.x;
    }

    bool operator==(const point& p) const{
        if (x == p.x && y == p.y) return true;
        return false;
    }

    bool operator!=(const point& p) const{
        if (x != p.x || y != p.y) return true;
        return false;
    }

    point& operator+=(const ll a){x += a, y += a; return *this;}
    point& operator-=(const ll a){x -= a, y -= a; return *this;}
    point& operator*=(const ll a){x *= a, y *= a; return *this;}
    point& operator+=(const point p){x += p.x, y += p.y; return *this;}
    point& operator-=(const point p){x -= p.x, y -= p.y; return *this;}
    point& operator*=(const point p){x *= p.x, y *= p.y; return *this;}
    void operator++(int){x++, y++;}
    void operator++(){x++, y++;}
    void operator--(int){x--, y--;}
    void operator--(){x--, y--;}
    point operator+(const point p) const {return point(*this) += p;}
    point operator-(const point p) const {return point(*this) -= p;}
    point operator*(const point p) const {return point(*this) *= p;}
    point operator+(const ll a) const {return point(*this) += a;}
    point operator-(const ll a) const {return point(*this) -= a;}
    point operator*(const ll a) const {return point(*this) *= a;}
    ll dot(const point& p) const {return x * p.x + y * p.y;}
    ll cross(const point& p) const {return x * p.y - y * p.x;}
    ll squared_norm() const {return x * x + y * y;}
    tuple<ll, ll> get_value(){return make_tuple(x, y);}

    ll which_quadrant() const{
        if (x == 0 && y == 0) return 0;
        if (x >= 0 && y >= 0) return 1;
        else if (x <= 0 && y >= 0) return 2;
        else if (x <= 0 && y <= 0) return 3;
        else return 4;
    }

    bool is_zero(){
        point z = {0, 0};
        return z == *this;
    }

    /*
    // fpoint
    fpoint to_fpoint(){
        fpoint ret = {ld(x), ld(y)};
        return ret;
    }
    */
};
string to_string(point p){return "{" + to_string(p.x) + ", " + to_string(p.y) + "}";}
typedef std::vector<point> points;
const points dirs = {{-1, 0}, { 1, 0}, { 0,  1}, {0, -1},  // four directions
                     { 1, 1}, {-1, 1}, {-1, -1}, {1, -1},  // diagonal
                     { 0, 0}};  // self

points convex_hull(points& ps){
    ll n = ps.size(), last = 0, n_lower;
    sort(all(ps));
    points p_stack(n * 2);

    // Lower Convex hull
    rep(i, n){
        // while the last three points make upper convex
        while(last - 2 >= 0 && (p_stack[last - 2] - ps[i]).cross(p_stack[last - 1] - ps[i]) <= 0) --last;
        p_stack[last++] = ps[i];
    }
  
    n_lower = last; // p_stack must include first and final elements here.
    // Upper Convex hull
    revrep(i, n - 1){
        // while the last three points make lower convex (the angle is reversed, because we see from the last element.)
        while(last - 1 >= n_lower && (p_stack[last - 2] - ps[i]).cross(p_stack[last - 1] - ps[i]) <= 0) --last;
        p_stack[last++] = ps[i];
    }
    p_stack.resize(last - 1);
    return p_stack;
}

void solve(){
    int n;
    cin >> n;
    points ps(n);
    rep(i, n) {
        ll x, y;
        cin >> x >> y;
        ps[i] = {x, y};
    }

    auto manh = [&](point p1, point p2){
        point v = p1 - p2;
        return abs(v.x) + abs(v.y);
    };
    points pc = convex_hull(ps);
    ll ans = 0, sz = pc.size();
    rep(i, sz) rep(j, i)
            ans = max(ans, manh(pc[i], pc[j]));

    cout << ans << endl;
}

void test(ll num = 0, bool verbose = false){
    rep(i, max(1LL, num)){
        ll t = clock();
        if (verbose) cout << "\n#####" << " " << i + 1 << " " << "#####" << " " << "\n## Answer ##\n";
        solve();
        if (verbose) {cout << "\nElapsed Time:" << " " << 1000.0 * (clock() - t) / CLOCKS_PER_SEC << " " << "[ms]" << endl;}
    }
}

int main(void){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    #ifdef _LOCAL
        test(6, true);
    #else
        ll t = 0;
        if (multiple_queries) cin >> t;
        test(t, false);
    #endif
    return 0;
}

Measured memory_bytes: 12768