#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <forward_list>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <optional>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using lint = long long;
using plint = pair<lint, lint>;
struct fast_ios { fast_ios(){ cin.tie(nullptr), ios::sync_with_stdio(false), cout << fixed << setprecision(20); }; } fast_ios_;
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define REP(i, n) FOR(i,0,n)
template <typename T> bool chmax(T &m, const T q) { return m < q ? (m = q, true) : false; }
template <typename T> bool chmin(T &m, const T q) { return m > q ? (m = q, true) : false; }


int main() {
    int N;
    cin >> N;
    vector<lint> X(N), Y(N), U(N), V(N);
    REP(i, N) {
        cin >> X.at(i) >> Y.at(i);
        U.at(i) = X.at(i) + Y.at(i);
        V.at(i) = X.at(i) - Y.at(i);
    }

    lint ng = -1, ok = 2e9;

    constexpr lint inf = 1LL << 60;

    while (ok - ng > 1) {
        const lint mid = (ok + ng) / 2;

        auto gen_rec = [&](int S, lint ulo, lint uhi, lint vlo, lint vhi) -> tuple<lint, lint, lint, lint> {
            lint ul, ur, vl, vr;
            if (S & 1) {
                ul = ulo, ur = ulo + mid;
            } else {
                ul = uhi - mid, ur = uhi;
            }

            if (S & 2) {
                vl = vlo, vr = vlo + mid;
            } else {
                vl = vhi - mid, vr = vhi;
            }

            return {ul, ur, vl, vr};
        };

        bool found = false;

        const lint ulo = *min_element(ALL(U)), uhi = *max_element(ALL(U));
        const lint vlo = *min_element(ALL(V)), vhi = *max_element(ALL(V));

        REP(tp1, 4) {
            const auto [ul1, ur1, vl1, vr1] = gen_rec(tp1, ulo, uhi, vlo, vhi);
            vector<plint> rem_uvs;
            REP(i, N) {
                const lint u = U.at(i), v = V.at(i);
                if (ul1 <= u and u <= ur1 and vl1 <= v and v <= vr1) continue;
                rem_uvs.emplace_back(u, v);
            }

            if (rem_uvs.empty()) {
                found = true;
                break;
            }

            const lint ulo = min_element(ALL(rem_uvs), [](const plint &a, const plint &b) { return a.first < b.first; })->first;
            const lint uhi = max_element(ALL(rem_uvs), [](const plint &a, const plint &b) { return a.first < b.first; })->first;
            const lint vlo = min_element(ALL(rem_uvs), [](const plint &a, const plint &b) { return a.second < b.second; })->second;
            const lint vhi = max_element(ALL(rem_uvs), [](const plint &a, const plint &b) { return a.second < b.second; })->second;

            REP(tp2, 4) {
                const auto [ul2, ur2, vl2, vr2] = gen_rec(tp2, ulo, uhi, vlo, vhi);

                lint badulo = inf, baduhi = -inf, badvlo = inf, badvhi = -inf;

                for (auto [u, v] : rem_uvs) {
                    if (ul1 <= u and u <= ur1 and vl1 <= v and v <= vr1) continue;
                    if (ul2 <= u and u <= ur2 and vl2 <= v and v <= vr2) continue;
                    chmin(badulo, u), chmax(baduhi, u);
                    chmin(badvlo, v), chmax(badvhi, v);
                }

                if (baduhi - badulo <= mid and badvhi - badvlo <= mid) found = true;
            }
        }

        if (found) {
            ok = mid;
        } else {
            ng = mid;
        }
    }

    cout << ok << '\n';
}