#include <bits/stdc++.h>
using namespace std;
template <class T>
struct point_t {
  T x, y;
  point_t() {}
  point_t(T x_, T y_) : x(x_), y(y_) {}
};
template <class T>
struct polygon_t {
  static const int MAX_N = 400000;
  polygon_t() : n(0) {}
  point_t<T> p[MAX_N];
  int n;
};
template <class T>
struct PointSort : public binary_function<int, int, bool> {
  PointSort(const polygon_t<T>& polygon_) : polygon(polygon_) {}
  bool operator()(int a, int b) {
    const point_t<T>& p1 = polygon.p[a];
    const point_t<T>& p2 = polygon.p[b];
    if (p1.y != p2.y) return p1.y < p2.y;
    if (p1.x != p2.x) return p1.x < p2.x;
    return a < b;
  }
  const polygon_t<T>& polygon;
};
template <class T>
struct PointEqual : public binary_function<int, int, bool> {
  PointEqual(const polygon_t<T>& polygon_) : polygon(polygon_) {}
  bool operator()(int a, int b) {
    const point_t<T>& p1 = polygon.p[a];
    const point_t<T>& p2 = polygon.p[b];
    return p1.x == p2.x && p1.y == p2.y;
  }
  const polygon_t<T>& polygon;
};
template <class T>
int Orientation(const point_t<T>& a, const point_t<T>& b, const point_t<T>& c,
                bool patch = false) {
  const T dx1 = b.x - a.x, dy1 = b.y - a.y;
  const T dx2 = c.x - a.x, dy2 = c.y - a.y;
  if (patch) {
    if (dx1 * dx2 < T(0) || dy1 * dy2 < T(0)) return +1;
    if (dx1 * dx1 + dy1 * dy1 > dx2 * dx2 + dy2 * dy2) return -1;
  }
  if (dy1 * dx2 < dx1 * dy2) return +1;
  if (dy1 * dx2 > dx1 * dy2) return -1;
  return 0;
}
template <class T>
void EraseConcave(vector<int>& hull, const polygon_t<T>& polygon, int fixed,
                  const point_t<T>& point) {
  while ((int)hull.size() >= 2 && (int)hull.size() > fixed) {
    if (Orientation(polygon.p[hull[(int)hull.size() - 2]],
                    polygon.p[hull[(int)hull.size() - 1]], point) > 0)
      break;
    hull.pop_back();
  }
}
template <class T>
int PushPoints(vector<int>& hull, const polygon_t<T>& polygon,
               const vector<int>& v, int fixed, int begin, int end) {
  const int dir = begin < end ? +1 : -1;
  for (int next = begin; next != end; next += dir) {
    EraseConcave(hull, polygon, fixed, polygon.p[v[next]]);
    if ((int)hull.size() < 2 ||
        Orientation(polygon.p[hull[(int)hull.size() - 2]],
                    polygon.p[hull[(int)hull.size() - 1]],
                    polygon.p[v[next]]) > 0)
      hull.push_back(v[next]);
  }
  return (int)hull.size();
}
template <class T>
vector<int> GetConvexHull(const polygon_t<T>& polygon) {
  vector<int> v(polygon.n);
  for (int i = 0; i < polygon.n; ++i) v[i] = i;
  sort(v.begin(), v.end(), PointSort<T>(polygon));
  v.erase(unique(v.begin(), v.end(), PointEqual<T>(polygon)), v.end());
  if ((int)v.size() == 1) return v;
  vector<int> hull;
  PushPoints(hull, polygon, v, 0, 0, (int)v.size());
  PushPoints(hull, polygon, v, (int)hull.size(), (int)v.size() - 2, 0);
  EraseConcave(hull, polygon, 2, polygon.p[v[0]]);
  return hull;
}
const int dx[] = {0, -1, 0, +1};
const int dy[] = {-1, 0, +1, 0};
long long myAbs64(long long x) { return x < 0 ? -x : +x; }
int main() {
  int n;
  scanf("%d", &n);
  static polygon_t<long long> poly;
  poly.n = 0;
  for (int i = 0; i < n; ++i) {
    long long x, y;
    scanf("%lld %lld", &x, &y);
    for (int k = 0; k < 4; ++k)
      poly.p[poly.n++] = point_t<long long>(x + dx[k], y + dy[k]);
  }
  const vector<int> hull = GetConvexHull(poly);
  const int m = (int)hull.size();
  long long total = 0;
  for (int k = 0; k < m; ++k) {
    const point_t<long long>& p1 = poly.p[hull[(k + 0) % m]];
    const point_t<long long>& p2 = poly.p[hull[(k + 1) % m]];
    const long long dx = myAbs64(p1.x - p2.x), dy = myAbs64(p1.y - p2.y);
    total += max(dx, dy);
  }
  printf("%lld\n", total);
  return 0;
}
