#include<iostream>
#include<iomanip>
#include<cassert>
#include<math.h>
#include<complex>
#include<algorithm>
#include<utility>
#include<queue>
#include<string.h>
#include<string>
#include<set>
#include<map>
#include<unordered_map>
#include<functional>
#include<vector>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
const ll INF=2e18;
const ll MOD=1e9+7;
const double EPS=1;

typedef complex<double> C;
#define cx real()
#define cy imag()
C MidPoint(C a,C b){ return C( (a.cx+b.cx)/2,(a.cy+b.cy)/2 ); }
bool isEqual(double a, double b) { return abs(a - b) < EPS; }
bool isCEqual(C a, C b) { return isEqual(a.cx, b.cx) && isEqual(a.cy, b.cy); }
bool isZero(double a) { return abs(a) < EPS; } // a == 0
bool isUZero(double a) { return a > EPS; } // a > 0
bool isUEZero(double a) { return a > -EPS; } // a >= 0
bool isLZero(double a) { return a < -EPS; } // a < 0
bool isLEZero(double a) { return a < EPS; } // a <= 0
C getUnitVector(C a) { double len = abs(a); return isZero(len) ? C(0.0, 0.0) : a / len; }
double dot(C a, C b) { return a.cx * b.cx + a.cy * b.cy; } // |a||b|cosθ
double det(C a, C b) { return a.cx * b.cy - a.cy * b.cx; } // |a||b|sinθ
bool isLineOrthogonal(C a1, C a2, C b1, C b2) { return isZero(dot(a1 - a2, b1 - b2)); } // a1-a2, b1-b2
bool isLineParallel(C a1, C a2, C b1, C b2) { return isZero(det(a1 - a2, b1 - b2)); } // a1-a2, b1-b2
bool isPointOnLine(C a, C b, C c) { return isZero(det(b - a, c - a)); } // a-b <- c
bool isPointOnLineSegment(C a, C b, C c) { return isZero(abs(a-c) + abs(c-b) - abs(a-b)); }
double distanceLineAndPoint(C a, C b, C c) { return abs(det(b-a, c-a)) / abs(b-a); } // a-b <- c
double distanceLineSegmentAndPoint(C a, C b, C c) { // a-b <- c
  if (isLEZero(dot(b-a, c-a))) return abs(c-a);
  if (isLEZero(dot(a-b, c-b))) return abs(c-b);
  return abs(det(b-a, c-a)) / abs(b-a);
}
bool isIntersectedLine(C a1, C a2, C b1, C b2) { // a1-a2, b1-b2
  return !isLineParallel(a1, a2, b1, b2);
}
C intersectionLine(C a1, C a2, C b1, C b2) { // isIntersectedLine-> true
  C a = a2 - a1, b = b2 - b1;
  return a1 + a * det(b, b1 - a1) / det(b, a);
}
bool IsIntersectedLineSegments(C a1,C a2,C b1,C b2){
	if(isLineParallel(a1,a2,b1,b2))return false;
	double ta = (b1.cx - b2.cx) * (a1.cy - b1.cy) + (b1.cy - b2.cy) * (b1.cx - a1.cx);
	double tb = (b1.cx - b2.cx) * (a2.cy - b1.cy) + (b1.cy - b2.cy) * (b1.cx - a2.cx);
	double tc = (a1.cx - a2.cx) * (b1.cy - a1.cy) + (a1.cy - a2.cy) * (a1.cx - b1.cx);
	double td = (a1.cx - a2.cx) * (b2.cy - a1.cy) + (a1.cy - a2.cy) * (a1.cx - b2.cx);
	return tc * td < 0 && ta * tb < 0;
}
bool comp_C(const C& c1, const C& c2) {
  if (c1.cx != c2.cx) return c1.cx < c2.cx;
  return c1.cy < c2.cy;
}
vector<C> convex_hull(C* ps, ll n) {
  sort(ps, ps+n, comp_C);
  ll k = 0;
  vector<C> qs(n*2);
  for (ll i = 0; i < n; i++) {
    while (k > 1 && det((qs[k-1] - qs[k-2]), (ps[i] - qs[k-1])) <= EPS) k--;
    qs[k++] = ps[i];
  }
  for (ll i = n-2, t = k; i >= 0; i--) {
    while (k > t && det((qs[k-1] - qs[k-2]), (ps[i] - qs[k-1])) <= EPS) k--;
    qs[k++] = ps[i];
  }
  qs.resize(k-1);
  return qs;
}

ll Dist(C c1,C c2){
    return abs(c1.cx-c2.cx)+abs(c1.cy-c2.cy);
}

ll rotating_calipers(vector<C> qs){
    ll n = qs.size();
    if (n == 2) return Dist(qs[0], qs[1]);
    ll i=0,j=0;
    for(ll k=0;k<n;k++){
        if(qs[k].cx < qs[i].cx) i = k;
        if(qs[j].cx < qs[k].cy) j = k;
    }
    ll res = 0;
    ll si = i,sj = j;
    while( i != sj || j != si){
        res = max(res, Dist(qs[i], qs[j]));
        if ( det(qs[(i+1)%n]-qs[i],qs[(j+1)%n]-qs[j]) <0 )
            i = (i + 1) % n;
        else
            j = (j + 1) % n;
    }
    return res;
}

ll N;
C xy[200010];
int main(){
    cin>>N;
    for(ll i=0;i<N;i++) {
        ll x,y;cin>>x>>y;
        xy[i]=C(x,y);
    }
    ll ans=0;
    vector<C> ch=convex_hull(xy,N);
    N=ch.size();
    for(ll i=0;i<N;i++){
        for(ll j=max(0ll,i+N/2-min(N,100ll));j<min(N,i+N/2+min(N,100ll));j++){
            ll dist=abs(ch[i].cx-ch[j].cx)+abs(ch[i].cy-ch[j].cy);
            ans=max(ans,dist);
        }
    }
    cout<<ans<<endl;

    return 0;
}

Measured memory_bytes: 12828