#include <bits/stdc++.h>
using namespace std;
const long double pi = acosl(-1);
const long double radian = 180 / pi;
const long double eps = 1e-12;
const long double infl = 1e20;
inline int sgn(const long double &x) { return (x > eps) - (x < -eps); }
inline int sgn(const long long &x) { return (x > 0) - (x < 0); }
inline long long sqr(const long long &x) { return x * x; }
inline long double refresh(const long double &x) {
  if (x < -1 + eps)
    return -1;
  else if (x > 1 - eps)
    return 1;
  else
    return x;
}
struct Point {
  long long x, y;
  Point() : x(0), y(0) {}
  Point(const long long &x, const long long &y) : x(x), y(y) {}
  long double length() const { return sqrtl(sqr(x) + sqr(y)); }
  long long length2() const { return sqr(x) + sqr(y); }
  long double distance(const Point &rhs) const {
    return sqrtl(sqr(rhs.x - x) + sqr(rhs.y - y));
  }
  long double distance2(const Point &rhs) const {
    return sqr(rhs.x - x) + sqr(rhs.y - y);
  }
  Point conjugate() const { return Point(x, -y); }
  Point normal(const bool &lft = true) const {
    return lft ? Point(-y, x) : Point(y, -x);
  }
  Point moderate() const { return *this * (this->quadrant() <= 4 ? -1 : 1); }
  long long vect(const Point &lhs, const Point &rhs) const {
    return (lhs - *this) * (rhs - *this);
  }
  long long scal(const Point &lhs, const Point &rhs) const {
    return (lhs - *this) & (rhs - *this);
  }
  long double distance_to_line(const Point &p, const Point &q) const {
    return fabsl(p.vect(q, *this) / p.distance(q));
  }
  long double distance_to_segment(const Point &p, const Point &q) const {
    if (p.scal(q, *this) < 0)
      return p.distance(*this);
    else if (q.scal(p, *this) < 0)
      return q.distance(*this);
    else
      return this->distance_to_line(p, q);
  }
  bool on_line(const Point &p, const Point &q) const {
    return sgn(p.vect(q, *this)) == 0;
  }
  bool on_halfline(const Point &p, const Point &q,
                   const bool &inclusive = true) const {
    if (*this == p)
      return inclusive;
    else
      return sgn(this->vect(p, q)) == 0 && sgn(p.scal(q, *this)) >= 0;
  }
  bool on_segment(const Point &p, const Point &q,
                  const bool &inclusive = true) const {
    if (*this == p || *this == q)
      return inclusive;
    else
      return sgn(this->vect(p, q)) == 0 && sgn(this->scal(p, q)) <= 0;
  }
  bool in_triangle(const Point &u, const Point &v, const Point &w,
                   const bool &inclusive = true) const {
    Point p[3] = {u, v, w};
    if (sgn(u.vect(v, w)) < 0) reverse(p, p + 3);
    for (int i = 0; i < 3; i++) {
      if (this->on_segment(p[i], p[(i + 1) % 3]))
        return inclusive;
      else if (sgn(this->vect(p[i], p[(i + 1) % 3])) < 0)
        return false;
    }
    return true;
  }
  bool in_angle(const Point &o, const Point &p, const Point &q,
                const bool &inclusive = true) const {
    if (this->on_halfline(o, p) || this->on_halfline(o, q)) return inclusive;
    int vp = sgn(o.vect(p, *this)), vq = sgn(o.vect(*this, q));
    if (sgn(o.vect(p, q)) >= 0)
      return vp > 0 && vq > 0;
    else
      return vp > 0 || vq > 0;
  }
  Point operator+(const Point &rhs) const {
    return Point(x + rhs.x, y + rhs.y);
  }
  Point operator-(const Point &rhs) const {
    return Point(x - rhs.x, y - rhs.y);
  }
  Point operator*(const long long &rhs) const {
    return Point(x * rhs, y * rhs);
  }
  Point operator/(const long long &rhs) const {
    return Point(x / rhs, y / rhs);
  }
  long long operator*(const Point &rhs) const { return x * rhs.y - y * rhs.x; }
  long long operator&(const Point &rhs) const { return x * rhs.x + y * rhs.y; }
  Point operator<<(const Point &rhs) const {
    return Point(x * rhs.x - y * rhs.y, x * rhs.y + y * rhs.x);
  }
  long double operator^(const Point &rhs) const {
    int s = sgn(*this * rhs);
    long double a = acosl(
        refresh((long double)(*this & rhs) / this->length() / rhs.length()));
    return s < 0 ? -a : a;
  }
  bool operator==(const Point &rhs) const { return x == rhs.x && y == rhs.y; }
  inline int quadrant() const {
    if (x == 0 && y == 0)
      return 0;
    else if (x < 0 && y < 0)
      return 1;
    else if (x == 0 && y < 0)
      return 2;
    else if (x > 0 && y < 0)
      return 3;
    else if (x > 0 && y == 0)
      return 4;
    else if (x > 0 && y > 0)
      return 5;
    else if (x == 0 && y > 0)
      return 6;
    else if (x < 0 && y > 0)
      return 7;
    else
      return 8;
  }
  bool operator<(const Point &rhs) const {
    int lq = quadrant(), rq = rhs.quadrant();
    if (lq != rq)
      return lq < rq;
    else {
      int s = sgn(*this * rhs);
      return s != 0 ? s > 0 : sgn(length2() - rhs.length2()) < 0;
    }
  }
  bool on_left(const Point &rhs, const bool &inclusive = true) const {
    long long s = *this * rhs, t = *this & rhs;
    return s == 0 ? t >= 0 || inclusive : s > 0;
  }
  bool on_right(const Point &rhs, const bool &inclusive = true) const {
    long long s = *this * rhs, t = *this & rhs;
    return s == 0 ? t >= 0 || inclusive : s < 0;
  }
};
inline bool xycmp(const Point &lhs, const Point &rhs) {
  if (sgn(lhs.x - rhs.x) != 0)
    return lhs.x < rhs.x;
  else
    return lhs.y < rhs.y;
}
inline bool yxcmp(const Point &lhs, const Point &rhs) {
  if (sgn(lhs.y - rhs.y) != 0)
    return lhs.y < rhs.y;
  else
    return lhs.x < rhs.x;
}
void convex_hull(Point *first, Point *last, vector<Point> &ans) {
  Point *&p = first;
  const int n = last - first;
  int mn = -1;
  for (int i = 0; i < n; i++) {
    if (mn == -1 || yxcmp(p[i], p[mn])) mn = i;
  }
  Point org = p[mn];
  for (int i = 0; i < n; ++i) p[i] = p[i] - org;
  sort(p, p + n);
  for (int i = 0; i < n; i++) p[i] = org + p[i];
  ans.resize(n);
  int sz = 0;
  ans[sz++] = p[0];
  for (int i = 1; i < n; i++) {
    for (; sz > 1 && sgn(ans[sz - 2].vect(ans[sz - 1], p[i])) <= 0; sz--)
      ;
    ans[sz++] = p[i];
  }
  ans.resize(sz);
}
vector<Point> convex_hull(Point *first, Point *last) {
  vector<Point> ans;
  convex_hull(first, last, ans);
  return ans;
}
Point *convex_hull(Point *first, Point *last, Point *q) {
  vector<Point> ans;
  convex_hull(first, last, ans);
  for (int i = 0; i < ans.size(); i++) q[i] = ans[i];
  return q + ans.size();
}
const int maxN = 100000;
int N;
Point p[maxN];
Point q[maxN << 2];
int main() {
  ios::sync_with_stdio(false);
  cin >> N;
  for (int i = 0; i < N; i++) cin >> p[i].x >> p[i].y;
  int sz = 0;
  for (int i = 0; i < N; i++) {
    q[sz++] = Point(p[i].x + 1, p[i].y);
    q[sz++] = Point(p[i].x, p[i].y + 1);
    q[sz++] = Point(p[i].x - 1, p[i].y);
    q[sz++] = Point(p[i].x, p[i].y - 1);
  }
  vector<Point> ch;
  convex_hull(q, q + N * 4, ch);
  int m = ch.size();
  long long ans = 0;
  for (int i = 0; i < m; i++)
    ans +=
        max(abs(ch[(i + 1) % m].x - ch[i].x), abs(ch[(i + 1) % m].y - ch[i].y));
  cout << ans << endl;
  return 0;
}
