import Data.List
import qualified Data.Set as S
import qualified Data.IntMap.Strict as M
import qualified Data.ByteString.Char8 as B

type Vertex = Int
type Weight = Int
type Edge = ((Vertex, Vertex), Weight)

snub = S.toList . S.fromList

readInt = maybe undefined fst . B.readInt

kruskal :: [Edge] -> Int
kruskal = fst . _kruskal initial 0 . sortOn snd

_kruskal :: UnionFind -> Int -> [Edge] -> (Int, UnionFind)
_kruskal uf acc [] = (acc, uf)
_kruskal uf acc (((a,b),d):abd)
  | same uf a b = _kruskal uf acc abd
  | otherwise = _kruskal (merge uf a b) (acc + d) abd

main = do
  _ <- getLine
  xys <- map ((\[x,y] -> (x+1, y+1)) . map readInt . B.words) . B.lines <$> B.getContents
  let xyis = zip (snub xys) [1 ..]
  let xysx = xyis
  let xysy = sortOn (snd . fst) xyis
  print (built xysx xysy)

built xysx xysy = kruskal (edgex ++ edgey)
  where
    edgex = zipWith (\((xi,yi),i) ((xj,yj),j) -> ((i,j), min (abs (xj-xi)) (abs (yj-yi)))) xysx (tail xysx)
    edgey = zipWith (\((xi,yi),i) ((xj,yj),j) -> ((i,j), min (abs (yj-yi)) (abs (xj-xi)))) xysy (tail xysy)

data UnionFind = UnionFind {
  tree :: M.IntMap Point,
  rk :: M.IntMap Rank
} deriving (Eq, Show)

type Point = Int -- greater than 0
type Rank = Int

initial :: UnionFind
initial = UnionFind M.empty M.empty

rep :: UnionFind -> Point -> Point
rep uf p
  | M.notMember p (tree uf) = p
  | tree uf M.! p == p = p
  | otherwise = rep uf (tree uf M.! p)

rank :: UnionFind -> Point -> Rank
rank uf p = M.findWithDefault 1 p (rk uf)

merge :: UnionFind -> Point -> Point -> UnionFind
merge uf p q
  | rp1 == rp2 = uf
  | otherwise = UnionFind (M.insert rp2 rp1 (M.insert p2 rp1 (tree uf))) (M.insert rp1 (rk1 + rk2) (rk uf))
  where
    p1 = ordBy uf p q
    p2 = if p1 == p then q else p
    rp1 = rep uf p1
    rp2 = rep uf p2
    rk1 = rank uf rp1
    rk2 = rank uf rp2

same :: UnionFind -> Point -> Point -> Bool
same uf p1 p2 = rep uf p1 == rep uf p2

ordBy :: UnionFind -> Point -> Point -> Point
ordBy uf x y
  | rx > ry = x
  | rx < ry = y
  | rep uf x < rep uf y = x
  | otherwise = y
  where
    rx = rank uf x
    ry = rank uf y