macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String {
            bytes
                .by_ref()
                .map(|r| r.unwrap() as char)
                .skip_while(|c| c.is_whitespace())
                .take_while(|c| !c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };

    ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, [ $t:tt ]) => {
        {
            let len = read_value!($next, usize);
            (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
        }
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

#[allow(unused_imports)]
use std::cmp::{min, max};

fn main() {
    input!{
        s: (i64, i64),
        t: (i64, i64),
        n: usize,
        mut v: [(i64, i64); n]
    }
    let mut g = (t.0 - s.0, t.1 - s.1);
    v = v.iter().map(|x| (x.0 - s.0, x.1 - s.1)).filter(|x| x.0 * (x.0 - g.0) <= 0 && x.1 * (x.1 - g.1) <= 0).collect();
    if g.0 < 0 {
        g.0 *= -1;
        for i in 0..v.len() {
            v[i].0 *= -1;
        }
    }
    if g.1 < 0 {
        g.1 *= -1;
        for i in 0..v.len() {
            v[i].1 *= -1;
        }
    }
    let pi = std::f64::consts::PI;
    let mut d0 = (g.0 + g.1) as f64 * 100.0;
    if v.len() == 0 {
        println!("{}", d0);
        return;
    }
    v.sort_by_key(|x| x.0);
    let mut comp: Vec<i64> = v.iter().map(|x| x.1).collect();
    comp.sort();
    let mut bit = BIT::new(v.len() + 1);
    for &(_, y) in &v {
        let i = comp.binary_search(&y).unwrap();
        let m = bit.max(i);
        bit.update(i, m + 1);
    }
    let c = bit.max(v.len());
    if g.0 as usize + 1 == c || g.1 as usize + 1 == c {
        d0 += 5.0 * pi;
    }
    println!("{}", d0 + (5.0 * pi - 20.0) * c as f64);
}

struct BIT {
    v: Vec<usize>,
    n: usize
}

impl BIT {
    fn new(n: usize) -> BIT {
        BIT{v: vec![0; n + 1], n: n}
    }

    // update i th element by x
    fn update(&mut self, i: usize, x: usize) {
        let mut id = i as i64 + 1;
        while id <= self.n as i64 && self.v[id as usize] < x {
            self.v[id as usize] = x;
            id += id & -id;
        }
    }

    // max in 0 to i th element
    fn max(&self, i: usize) -> usize {
        let mut id = i + 1;
        let mut ret = 0;
        while id > 0 {
            ret = std::cmp::max(ret, self.v[id]);
            id &= id - 1;
        }
        ret
    }
}


Measured memory_bytes: 13560