#include <iostream>
#include <map>
#include <set>
#include <algorithm>
#include <vector>
#include <sstream>
#include <string>
#include <functional>
#include <queue>
#include <deque>
#include <stack>
#include <limits>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <fstream>
#include <iterator>
#include <random>
#include <chrono>


#define forr(i,start,count) for (int i = (start); i < (start)+(count); ++i)
#define set_map_includes(set, elt) (set.find((elt)) != set.end())
#define readint(i) int i; cin >> i
#define readll(i) ll i; cin >> i
#define readdouble(i) double i; cin >> i
#define readstring(s) string s; cin >> s

typedef long long ll;

using namespace std;

ll modd = 1000 * 1000 * 1000 + 7;

template<class T>
T fastpower(T x, ll pw) {
    T w = x, res = 1;
    while (pw>0) {
        if (pw&1) {
            res *= w; res %= modd;
        }
        pw >>= 1;
        w *= w; w %= modd;
    }
    return res;
}

template<class T>
class Vec2 {
    public:
      T x, y;

      Vec2() : x(0), y(0) {   }

      Vec2(T xx, T yy) : x(xx), y(yy) {   }

      Vec2 operator+(const Vec2& b) { 
          Vec2 ret;
          ret.x = x + b.x; ret.y = y + b.y;
          return ret;   }

      Vec2 operator-(const Vec2& b) { 
          Vec2 ret;
          ret.x = x - b.x; 
          ret.y = y - b.y;
          return ret;   }

      static T dot(Vec2 a, Vec2 b) {  return (a.x*b.x+a.y*b.y);    }

      static T det(Vec2 a, Vec2 b) {  return (a.x*b.y-a.y*b.x);    }

      static T l1_dist(Vec2 a, Vec2 b) {   return (abs(a.x - b.x) + abs(a.y - b.y));   }

      static T linf_dist(Vec2 a, Vec2 b) {   return max(abs(a.x - b.x), abs(a.y - b.y));   }

      bool operator<(const Vec2& b) const {    return ((x == b.x) ? y < b.y : x < b.x);    }

      bool operator==(const Vec2& b) const {
          return ((x == b.x) && (y == b.y));
      }
};


typedef Vec2<long long> v2;


int main()   {


      ios_base::sync_with_stdio(false);

      cout.precision(17);
      mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
      uniform_int_distribution<int> rand_gen(0, modd);   // rand_gen(rng) gets the rand no



//    readint(test_cases);
    int test_cases = 1;
    forr(t, 1, test_cases) {
        readint(n);
        vector<v2> pts;
        map<ll,set<pair<ll,int>>> plus_;
        map<ll,set<pair<ll,int>>> minus_;
        forr(i,0,n) {
            readint(x); readint(y);
            pts.push_back(v2(x,y));
            plus_[x+y].insert(make_pair(x-y, i));
            minus_[x-y].insert(make_pair(x+y, i));
        }

        vector<int> candidates;
        candidates.push_back(plus_.begin()->second.begin()->second);
        candidates.push_back(prev(plus_.begin()->second.end())->second);
        candidates.push_back(prev(plus_.end())->second.begin()->second);
        candidates.push_back(prev(prev(plus_.end())->second.end())->second);
        candidates.push_back(minus_.begin()->second.begin()->second);
        candidates.push_back(prev(minus_.begin()->second.end())->second);
        candidates.push_back(prev(minus_.end())->second.begin()->second);
        candidates.push_back(prev(prev(minus_.end())->second.end())->second);

        ll ret = 0;
        for(auto x : candidates) {
            for(auto y : candidates) {
                ret = max(ret, v2::l1_dist(pts[x], pts[y]));
            }
        }
        cout << ret << endl;

    }
    return 0;
}


Measured memory_bytes: 68888