#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000;
template <typename T>
struct Pt {
  T x, y;
  Pt() {}
  Pt(T _x, T _y) : x(_x), y(_y) {}
  Pt(const Pt &pt) : x(pt.x), y(pt.y) {}
  bool operator==(const Pt pt) const { return x == pt.x && y == pt.y; }
  Pt<T> operator+(const Pt pt) const { return Pt<T>(x + pt.x, y + pt.y); }
  Pt<T> operator-() const { return Pt<T>(-x, -y); }
  Pt<T> operator-(const Pt pt) const { return Pt<T>(x - pt.x, y - pt.y); }
  Pt<T> operator*(T t) const { return Pt<T>(x * t, y * t); }
  Pt<T> operator/(T t) const { return Pt<T>(x / t, y / t); }
  T dot(Pt v) const { return x * v.x + y * v.y; }
  T cross(Pt v) const { return x * v.y - y * v.x; }
  bool operator<(const Pt &pt) const {
    return x < pt.x || (x == pt.x && y < pt.y);
  }
  void print() { printf("(%lld,%lld)\n", x, y); }
};
void convex_hull(const vector<Pt<long long> > &ps,
                 vector<Pt<long long> > &chs) {
  int n = ps.size();
  vector<Pt<long long> > lhs, uhs;
  lhs.push_back(ps[0]);
  lhs.push_back(ps[1]);
  for (int i = 2; i < n; i++) {
    while (lhs.size() >= 2) {
      int ln = lhs.size();
      Pt<long long> &lh0 = lhs[ln - 2], &lh1 = lhs[ln - 1];
      if ((lh1 - lh0).cross(ps[i] - lh1) > 0) break;
      lhs.pop_back();
    }
    lhs.push_back(ps[i]);
  }
  uhs.push_back(ps[n - 1]);
  uhs.push_back(ps[n - 2]);
  for (int i = n - 3; i >= 0; i--) {
    while (uhs.size() >= 2) {
      int un = uhs.size();
      Pt<long long> &uh0 = uhs[un - 2], &uh1 = uhs[un - 1];
      if ((uh1 - uh0).cross(ps[i] - uh1) > 0) break;
      uhs.pop_back();
    }
    uhs.push_back(ps[i]);
  }
  lhs.pop_back();
  uhs.pop_back();
  chs.clear();
  chs.reserve(lhs.size() + uhs.size());
  chs.assign(lhs.begin(), lhs.end());
  chs.insert(chs.end(), uhs.begin(), uhs.end());
}
void printvpt(vector<Pt<long long> > &ps) {
  printf("%lu\n", ps.size());
  for (int i = 0; i < ps.size(); i++) ps[i].print();
}
int main() {
  int n;
  scanf("%d", &n);
  vector<Pt<long long> > ps(n);
  for (int i = 0; i < n; i++) scanf("%lld%lld", &ps[i].x, &ps[i].y);
  sort(ps.begin(), ps.end());
  ps.erase(unique(ps.begin(), ps.end()), ps.end());
  vector<Pt<long long> > chs;
  if (ps.size() < 3)
    chs = ps;
  else
    convex_hull(ps, chs);
  vector<Pt<long long> > qs((int)chs.size() * 4);
  for (int i = 0; i < chs.size(); i++) {
    long long &xi = chs[i].x, &yi = chs[i].y;
    qs[4 * i] = Pt<long long>(xi + 1, yi);
    qs[4 * i + 1] = Pt<long long>(xi, yi - 1);
    qs[4 * i + 2] = Pt<long long>(xi - 1, yi);
    qs[4 * i + 3] = Pt<long long>(xi, yi + 1);
  }
  sort(qs.begin(), qs.end());
  qs.erase(unique(qs.begin(), qs.end()), qs.end());
  vector<Pt<long long> > qchs;
  convex_hull(qs, qchs);
  long long sum = 0;
  int m = qchs.size();
  for (int i = 0; i < m; i++) {
    Pt<long long> &p0 = qchs[i], &p1 = qchs[(i + 1) % m];
    sum += max(abs(p1.x - p0.x), abs(p1.y - p0.y));
  }
  printf("%lld\n", sum);
  return 0;
}
