#include <bits/stdc++.h>
using namespace std;

using ll = long long;
using ull = unsigned long long;
using ld = long double;

#define forn(i, a, n) for (int i = (int)(a); i < (int)(n); ++i)
#define ford(i, a, n) for (int i = (int)(n - 1); i >= (int)(a); --i)
#define fore(i, a, n) for (int i = (int)(a); i <= (int)(n); ++i)
#define all(a) (a).begin(), (a).end()
#define fs first
#define sn second
#define trace(a)\
    for (auto i : a) cerr << i << ' ';\
    cerr << '\n'
#define eb emplace_back

#undef M_PI
//#ifndef M_PI
const ld M_PI = acosl(-1.0);
//#endif

template<typename T>
inline void setmax(T& a, T b) {
    if (a < b) a = b;
}

template<typename T>
inline void setmin(T& a, T b) {
    if (a > b) a = b;
}

const ld eps = 1e-9;
const int INF = 2000000000;
const ll LINF = 1ll * INF * INF;
const ll MOD = 1000000007;

const int N = 1 << 18;
using T = int;
inline T combine(T a, T b) {
    return max(a, b);
}
T DEFAULT = 0;

#define COMMUTE

T a[2 * N];
struct SegmentTreeBottomUp {

    SegmentTreeBottomUp () {
        for (int i = 0; i < 2 * N; ++i)
            a[i] = DEFAULT;
    };

    SegmentTreeBottomUp (vector<T> _a) {
        for (int i = 0; i < (int)_a.size(); ++i)
            a[i + N] = _a[i];
        for (int i = 0; i < N; ++i)
            a[i + N] = DEFAULT;
        for (int i = N - 1; i >= 0; --i)
            a[i] = combine(a[2 * i], a[2 * i + 1]);
    }

#ifdef COMMUTE
    T get(int l, int r) {
        T res = DEFAULT;
        l += N, r += N;
        while (l < r) {
            if (l % 2)
                res = combine(a[l++], res);
            if (r % 2)
                res = combine(res, a[--r]);
            l /= 2;
            r /= 2;
        }
        return res;
    }
#else
    T get(int l, int r) {
        T res_l = DEFAULT, res_r = DEFAULT;
        l += N, r += N;
        while (l < r) {
            if (l % 2)
                res_l = combine(res_l, a[l++]);
            if (r % 2)
                res_r = combine(a[--r], res_r);
            l /= 2;
            r /= 2;
        }
        return combine(res_l, res_r);
    }
#endif // COMMUTE

    void set(int pos, T val) {
        pos += N;
        a[pos] = val;
        pos /= 2;
        while (pos) {
            a[pos] = combine(a[2 * pos], a[2 * pos + 1]);
            pos /= 2;
        }
    }
};

const ld LEN = 100;
const ld HALF = 10 * M_PI - 20;
const ld QUARTER = 5 * M_PI - 20;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0); 
    srand((unsigned)chrono::high_resolution_clock::now().time_since_epoch().count());
    cout << fixed << setprecision(20);
    int x1, y1, x2, y2;
    cin >> x1 >> y1 >> x2 >> y2;
    int n;
    cin >> n;
    vector<pair<int, int>> pt(n);
    forn(i, 0, n) cin >> pt[i].fs >> pt[i].sn;
    if (x1 > x2) {
        x1 *= -1;
        x2 *= -1;
        forn(i, 0, n) pt[i].fs *= -1;
    }
    if (y1 > y2) {
        y1 *= -1;
        y2 *= -1;
        forn(i, 0, n) pt[i].sn *= -1;
    }
    if (x1 == x2) {
        int ans = y2 - y1;
        int circ = 0;
        forn(i, 0, n) if (pt[i].fs == x1 && pt[i].sn > y1 && pt[i].sn < y2) ++circ;
        cout << LEN * ans + HALF * circ << '\n';
        return 0;
    }
    if (y1 == y2) {
        int ans = x2 - x1;
        int circ = 0;
        forn(i, 0, n) if (pt[i].sn == y1 && pt[i].fs > x1 && pt[i].fs < x2) ++circ;
        cout << LEN * ans + HALF * circ << '\n';
        return 0;
    }
    int ans = (x2 - x1) + (y2 - y1);
    map<int, int> ys;
    vector<int> y_cmp(n);
    forn(i, 0, n) y_cmp[i] = pt[i].sn;
    sort(all(y_cmp));
    forn(i, 0, n) ys[y_cmp[i]] = i;
    sort(all(pt));
    SegmentTreeBottomUp tree(vector<int>(n, -1));
    int qs = 0;
    forn(i, 0, n) {
        if (pt[i].fs < x1 || pt[i].fs > x2 || pt[i].sn < y1 || pt[i].sn > y2)
            continue;
        int cur = ys[pt[i].sn];
        int res = tree.get(0, cur);
        //cerr << pt[i].fs << ' ' << pt[i].sn << ' ' << res << '\n';
        //if (res + 1 > a[N + cur]) {
            tree.set(cur, res + 1);
            setmax(qs, res + 1);
        //}
    }
    if (qs == x2 - x1 + 1 || qs == y2 - y1 + 1) {
        cout << LEN * ans + QUARTER * (qs - 1) + HALF << '\n';
        return 0;
    }
    //cerr << qs << '\n';
    cout << LEN * ans + QUARTER * qs << '\n';
}


Measured memory_bytes: 14848