#include <bits/stdc++.h>
#define X first
#define Y second
#define T long double
#define int long long
using namespace std;

const int MAXN = 200000 + 10;

int n;
pair<int,int> f, t;
vector<pair<int,int>> p;

map<int,int> M;

const int SIZ = 1<<21;

int tree[2*SIZ];
int query(int a, int b) {
    a += SIZ; b += SIZ;
    int res = max(tree[a], tree[b]);
    while (a/2 != b/2) {
        if (a%2 == 0) res = max(res, tree[a+1]);
        if (b%2 == 1) res = max(res, tree[b-1]);
        a/=2; b/=2;
    }
    return res;
}

void put(int x, int v) {
    x += SIZ;
    tree[x] = max(tree[x], v);
    x /= 2;
    while (x > 0) {
        tree[x] = max(tree[2*x], tree[2*x+1]);
        x/=2;
    }
}
int di;
int dif;
int32_t main() {
    ios_base::sync_with_stdio(0);
    cin >> f.X >> f.Y >> t.X >> t.Y;

    di = abs(t.X - f.X) + abs(t.Y - f.Y);
    dif = min(abs(t.X - f.X), abs(t.Y - f.Y));
    cin >> n;

    for (int i = 0; i < n; i++) {
        int x, y;
        cin >> x;
        cin >> y;

        if (x < t.X && x < f.X) continue;
        if (x > t.X && x > f.X) continue;
        if (y > t.Y && y > f.Y) continue;
        if (y < t.Y && y < f.Y) continue;

        //cerr << "A " << x << " " << y << "\n";
        if (f.X > t.X) {
            x *= -1;
        }
        if (f.Y > t.Y) {
            y *= -1;
        }
        p.push_back({x,y});
    }

    if (f.X > t.X) {
        f.X *= -1;
        t.X *= -1;
    }
    if (f.Y > t.Y) {
        f.Y *= -1;
        t.Y *= -1;
    }

    t.X -= f.X;
    t.Y -= f.Y;


    int cnt = 0;
    vector<int> coords;
    coords.push_back(0);
    coords.push_back(t.X);
    //coords.push_back(t.Y);
    for (int i = 0; i < p.size(); i++) {
        p[i].X -= f.X;
        p[i].Y -= f.Y;

        coords.push_back(p[i].X);
        //coords.push_back(p[i].Y);


        assert(p[i].X >= 0);
        assert(p[i].X <= t.X);
        assert(p[i].Y >= 0);
        assert(p[i].Y <= t.Y);
        //cerr << p[i].X << " " << p[i].Y << "\n";
    }

    set<int> S(begin(coords), end(coords));
    coords.assign(begin(S), end(S));

    for (int i = 0; i <coords.size(); i++) {
        M[coords[i]] = i;
    }

    for (int i = 0; i < p.size(); i++) {
        p[i].X = M[p[i].X];
        //p[i].Y = M[p[i].Y];
    }

    t.X = M[t.X];
    //t.Y = M[t.Y];

    sort(begin(p), end(p), [](pair<int,int> a, pair<int,int> b) { if (a.Y != b.Y) return a.Y < b.Y; return a.X < b.X; });

  std::cout << std::fixed;
    if (t.X == 0 || t.Y == 0) {
        T res = 0.0;
        assert(p.size() < 2);
        if (p.size() == 1) {
            res = (T) 100.0 * di - (T) 20.0 + (T)10.0 * M_PI;
        } else {
            res = (T) 100.0 * di;
        }
            std::cout << std::setprecision(20) << res << '\n';
            return 0;

    }

    int be = 0;

    for (int i = 0; i < p.size(); i++) {
        auto x = p[i].X;
        int q = query(0, x);
        put(x, q+1);
        be = max(be, q+1);
    }

    be = query(0, t.X);

    T res = 0;
    if (be == dif+1)
        res = (T)100.0 * di - (T)20.0 * (be-1) + (T) 5.0 * (be-1) * M_PI - (T)20.0 + 10.0 * M_PI;
    else
        res = (T)100.0 * di - (T)20.0 * be + (T) 5.0 * be * M_PI;

            std::cout << std::setprecision(20) << res << '\n';

    return 0;
}


Measured memory_bytes: 35948