#include <bits/stdc++.h>
using namespace std;
enum orientation_t { Colinear, Clockwise, Counterclockwise };
int origin;
struct point_t {
  int x, y;
  point_t(int X = 0, int Y = 0) : x(X), y(Y) {}
  long long dist2() const {
    long long x2 = x, y2 = y;
    return (x2 *= x2) + (y2 *= y2);
  }
  int max_abs() const { return max(abs(x), abs(y)); }
  friend point_t operator-(const point_t& p, const point_t& q) {
    return point_t(p.x - q.x, p.y - q.y);
  }
  long long dist2(const point_t& p) const { return (*this - p).dist2(); }
  long long cross_product(const point_t& p) const {
    long long x2 = x, y2 = y;
    return (x2 *= p.y) - (y2 *= p.x);
  }
  long long cross_product(const point_t& p, const point_t& q) const {
    return (q - p).cross_product(p - *this);
  }
  orientation_t orientation(const point_t& p, const point_t& q) const {
    long long z = cross_product(p, q);
    if (z == 0) return Colinear;
    if (z > 0) return Clockwise;
    return Counterclockwise;
  }
};
struct points_t : vector<point_t> {
  orientation_t orientation(int i, int j, int k) const {
    return at(i).orientation(at(j), at(k));
  }
  int max_abs_difference(int i, int j) const {
    return (at(i) - at(j)).max_abs();
  }
  long long dist2(int i, int j) const { return at(i).dist2(at(j)); }
  bool compare_points(const int p1, const int p2) const {
    auto z = orientation(origin, p1, p2);
    if (z == Colinear) return dist2(origin, p1) < dist2(origin, p2);
    return z == Counterclockwise;
  }
} point;
bool compare_points(int p1, int p2) { return point.compare_points(p1, p2); }
struct graham_scan : vector<int> {
  graham_scan() {
    int m = 1, n = point.size();
    point_t q = point.front();
    struct index_t : vector<int> {
      index_t(int n) {
        resize(n);
        for (int i = 0; i < n; i++) at(i) = i;
      }
      void order() { sort(begin() + 1, end(), compare_points); }
    } p_index(n);
    for (int i = 1; i < n; i++) {
      point_t& p = point[i];
      if (p.y < q.y or (p.y == q.y and p.x < q.x)) origin = i, q = p;
    }
    if (origin != 0) std::swap(p_index[0], p_index[origin]);
    p_index.order();
    for (int i = 1, j = 2, p = n - 1; i < n; p_index[m++] = p_index[i], i = j++)
      while (i < p and
             point.orientation(origin, p_index[i], p_index[j]) == Colinear)
        i = j++;
    for (int i = 0, k = min(3, m); i < k; i++) push_back(p_index[i]);
    for (int i = 3; i < m; push_back(p_index[i++]))
      while (point.orientation(at(size() - 2), back(), p_index[i]) !=
             Counterclockwise)
        pop_back();
  }
  long long min_surroundings() const {
    long long ans = 0;
    for (int i = 0, j = 1, k = size(); i < k; i++, j++, j %= k)
      ans += point.max_abs_difference(at(i), at(j));
    return ans;
  }
};
int main() {
  ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
  int n;
  cin >> n, point.resize(4 * n);
  for (int i = 0, j = 0; i < n; i++) {
    point_t p;
    cin >> p.x >> p.y;
    for (int k = 0; k < 4; k++) point[j++] = p;
    point[j - 4].x--, point[j - 3].x++, point[j - 2].y--, point[j - 1].y++;
  }
  cout << graham_scan().min_surroundings();
}
