```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

type LevelInfo struct {
	minX int64
	minY int64
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	
	n := readInt(scanner)
	
	levels := make(map[int64]*LevelInfo)
	
	for i := 0; i < n; i++ {
		x := readInt64(scanner)
		y := readInt64(scanner)
		k := max(x, y)
		
		if info, ok := levels[k]; ok {
			if x < info.minX {
				info.minX = x
			}
			if y < info.minY {
				info.minY = y
			}
		} else {
			levels[k] = &LevelInfo{
				minX: x,
				minY: y,
			}
		}
	}
	
	keys := make([]int64, 0, len(levels))
	for k := range levels {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	
	type Point struct {
		x, y int64
	}
	
	abs := func(a int64) int64 {
		if a < 0 {
			return -a
		}
		return a
	}
	
	dist := func(p1, p2 Point) int64 {
		return abs(p1.x-p2.x) + abs(p1.y-p2.y)
	}
	
	var dp0, dp1 int64
	var prevL, prevB Point
	
	k := keys[0]
	info := levels[k]
	L := Point{info.minX, k}
	B := Point{k, info.minY}
	length := (k - info.minX) + (k - info.minY)
	
	start := Point{0, 0}
	dp0 = dist(start, B) + length
	dp1 = dist(start, L) + length
	prevL, prevB = L, B
	
	for i := 1; i < len(keys); i++ {
		k = keys[i]
		info = levels[k]
		L = Point{info.minX, k}
		B = Point{k, info.minY}
		length = (k - info.minX) + (k - info.minY)
		
		newDp0 := min(dp0+dist(prevL, B), dp1+dist(prevB, B)) + length
		newDp1 := min(dp0+dist(prevL, L), dp1+dist(prevB, L)) + length
		
		dp0, dp1 = newDp0, newDp1
		prevL, prevB = L, B
	}
	
	fmt.Println(min(dp0, dp1))
}

func readInt(scanner *bufio.Scanner) int {
	scanner.Scan()
	n, _ := strconv.Atoi(scanner.Text())
	return n
}

func readInt64(scanner *bufio.Scanner) int64 {
	scanner.Scan()
	n, _ := strconv.ParseInt(scanner.Text(), 10, 64)
	return n
}

func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

func min(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}
```