#include <bits/stdc++.h>
using namespace std;
struct Point {
  Point(double x = 0, double y = 0) : x(x), y(y) {}
  double x, y;
};
Point first;
Point operator-(const Point& p1, const Point& p2) {
  return Point(p1.x - p2.x, p1.y - p2.y);
}
double operator^(const Point& p1, const Point& p2) {
  return p1.x * p2.y - p1.y * p2.x;
}
double distanceS(const Point& p1, const Point& p2) {
  return pow(p1.x - p2.x, 2.0) + pow(p1.y - p2.y, 2.0);
}
struct CmpXY {
  bool operator()(const Point& p1, const Point& p2) {
    if (p1.y > p2.y)
      return false;
    else if (p1.y < p2.y)
      return true;
    return p1.x < p2.x;
  }
};
struct CmpAngle {
  bool operator()(const Point& p1, const Point& p2) {
    if ((p1 - first) ^ (p2 - first)) return ((p1 - first) ^ (p2 - first)) > 0;
    return distanceS(first, p1) < distanceS(first, p2);
  }
};
void convexHull(vector<Point>& points, vector<Point>& res) {
  vector<Point> points2;
  int n = (int)points.size();
  sort(points.begin(), points.end(), CmpXY());
  int i, j;
  for (i = j = 0; i < n;) {
    points2.push_back(points[i++]);
    while (i < n && !distanceS(points[i - 1], points[i])) ++i;
  }
  n = (int)points2.size();
  first = points2[0];
  sort(points2.begin() + 1, points2.end(), CmpAngle());
  for (i = j = 1; i < n;) {
    ++i;
    while (i < n && ((points2[i - 1] - first) ^ (points2[i] - first)) == 0) ++i;
    points2[j++] = points2[i - 1];
  }
  n = j;
  res.push_back(first);
  res.push_back(points2[1]);
  res.push_back(points2[2]);
  for (int i = 3; i < n; ++i) {
    while (((points2[i] - res[res.size() - 2] ^
             (res.back() - res[res.size() - 2])) >= 0))
      res.pop_back();
    res.push_back(points2[i]);
  }
}
int main() {
  cin.sync_with_stdio(false);
  cout.sync_with_stdio(false);
  int n;
  cin >> n;
  vector<Point> points;
  for (int i = (0); i < ((n)); ++i) {
    int x, y;
    cin >> x >> y;
    int const DX[] = {0, 1, 1, 1, 0, -1, -1, -1};
    int const DY[] = {-1, -1, 0, 1, 1, 1, 0, -1};
    for (int k = (0); k < ((8)); ++k)
      if (k % 2 == 0) {
        points.push_back(Point(x + DX[k], y + DY[k]));
      }
  }
  vector<Point> hull;
  convexHull(points, hull);
  int res = 0;
  for (int i = (0); i < (((int)hull.size())); ++i) {
    Point const& p1 = hull[i];
    Point const& p2 = hull[(i + 1) % (int)hull.size()];
    int const dx = abs(p1.x - p2.x);
    int const dy = abs(p1.y - p2.y);
    int moves = min(dx + dy, max(dx, dy));
    res += moves;
  }
  cout << res << endl;
  return 0;
}
