import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

public class Volcanoes {
    static ArrayList<Point> points = new ArrayList<>();
    static Point curr;
    static int index = 0;
    static boolean finished = false;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        for (int i = 0; i < n; i++) {
            points.add(new Point(scanner.nextInt(),scanner.nextInt()));
        }

        points.sort(new Comparator<Point>() {
            @Override
            public int compare(Point o1, Point o2) {
                if (o1.x != o2.x) {
                    return o1.x - o2.x;
                }

                return o1.y - o2.y;
            }
        });


        long distance = 0;

        curr = points.get(0);
        for (; index < points.size(); index++) {
            Point next = points.get(index);

            if (index + 1 < points.size() && next.x == points.get(index + 1).x) {
                distance += GetDistRec(0, index, index);
                curr = points.get(index);
            }
            else {
                distance += GetDist(curr, next);
                curr = next;
            }

            if (finished)
                break;
        }

        System.out.println(distance);
    }

    public static long GetDistRec(long dist, int prev, int startIndex) {
        ArrayList<Point> currCol = new ArrayList<>();
        currCol.add(points.get(startIndex));

        for (int i = 0; i + startIndex + 1 < points.size() && points.get(startIndex + i).x == points.get(startIndex + i + 1).x; i++)
            currCol.add(points.get(startIndex + i + 1));

        if (currCol.size() == 1) {
            dist += GetDist(points.get(prev), points.get(startIndex));
            index = startIndex;
            return dist;
        }

        dist += GetDist(points.get(startIndex), points.get(startIndex + currCol.size() - 1));
        int last = startIndex + currCol.size() - 1;
        if (last + 1 < points.size())
        {
            long result1 = GetDistRec(startIndex == 0? dist : dist + GetDist(points.get(prev), points.get(startIndex)), startIndex, last + 1);
            long result2 = GetDistRec(startIndex == 0? dist : dist + GetDist(points.get(prev), points.get(last)), last, last + 1);
            return Math.min(result1, result2);
        } else
        {
            long firstDist = GetDist(points.get(prev), points.get(startIndex));
            long secondDist = GetDist(points.get(prev), points.get(last));
            dist = Math.min(startIndex == 0? dist : dist + firstDist,
                    startIndex == 0? dist : dist + secondDist);
            finished = true;
        }

        return dist;
    }

    public static long GetDist(Point a, Point b) {
        int distanceX = Math.abs(a.x - b.x);
        int distanceY = Math.abs(a.y - b.y);

        return (distanceX + distanceY);
    }

    public static class Point {
        int x;
        int y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}