#[allow(unused_macros)]
macro_rules! parse_line {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            iter.next().unwrap().parse::<$t>().unwrap()
        }
    );

    ( $( $t:ty), +) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            ( $(iter.next().unwrap().parse::<$t>().unwrap()),* )
        }
    );
}

#[allow(unused_macros)]
macro_rules! read_line {
    () => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            line.pop();
            line
        }
    )
}

#[allow(unused_macros)]
macro_rules! parse_vec {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let iter = line.split_whitespace();
            iter.map(|v| v.parse::<$t>().unwrap()).collect::<Vec<_>>()
        }
    )
}

fn solve(xys: Vec<(i64, i64)>) -> i64 {
    use std::collections::BinaryHeap;
    use std::cmp::min;

    let n = xys.len();
    let mut used = vec![false; n];
    let mut heap = BinaryHeap::new();

    let mut total = 0;

    heap.push((0i64, 0));

    while !heap.is_empty() {
        let (cost, dest) = heap.pop().unwrap();
        if used[dest] {
            continue
        }

        used[dest] = true;
        let cost = -cost;
        total += cost;

        let (dx,dy) = xys[dest];

        for i in 0..n {
            if !used[i] {
                let (sx,sy) = xys[i];
                let c = min((dx-sx).abs(), (dy-sy).abs());
                heap.push((-c, i));
            }
        }
    }

    total
}

fn main() {
    let n = parse_line!(usize);
    let xys = (0..n).into_iter().map(|_| parse_line!(i64, i64)).collect::<Vec<_>>();

    println!("{}", solve(xys));
}

#[test]
fn solve_test() {
    assert_eq!(solve(vec![(1,5), (3,9), (7,8)]), 3);
    assert_eq!(solve(vec![(8,3),
                          (4,9),
                          (12,19),
                          (18,1),
                          (13,5),
                          (7,6)]), 8);
}
