#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define ld long double
#define mk make_pair
#define pb push_back
#define sz(a) (int)(a).size()
#define rep(i, a, b) for (int i = (a), _b = (int)(b); i < _b; ++i)

typedef complex<ld> cplex;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef pair<ii, int> iii;
typedef vector<ii> vii;
typedef vector<iii> viii;

const int inf = 1000000007;
const ll linf = 1ll * inf * inf;
const int N = 200000 + 7;
const int M = 10;
const int multipleTest = 0;
const ll pi = 3141592653589ll;




class SegmentTree {
public:
    const static  int MAXN = N + 7;
    struct node{
        int mx;
        int leftChild;
        int rightChild;
        int leftIdx, rightIdx;
        node() {
            mx = 0;
            rightChild = leftChild = -1;
        }
        void reset(int u, int v, int _left, int _right) {
            mx = 0;
            leftChild = _left;
            rightChild = _right;
            leftIdx = u;
            rightIdx = v;
        }
    };
    
    node tree[MAXN * 4];
    int cnt = 0;
    
    void buildTree(node& root, int l, int r) {
        if (l == r) {
            root.reset(l, r, -1, -1);
            return;
        }
        int g = (l + r) >> 1;
        int leftChild = cnt++, rightChild = cnt++;
        buildTree(tree[leftChild], l, g);
        buildTree(tree[rightChild], g + 1, r);
        root.reset(l, r, leftChild, rightChild);
    }
    
    void init(int l, int r) {
        cnt = 1;
        buildTree(tree[0], l, r);
    }
    
    void update(node& root, int pos, int val) {
        if (root.leftIdx == root.rightIdx) {
            root.mx = max(root.mx, val);
            return;
        }
        int g = (root.leftIdx + root.rightIdx) >> 1;
        if (pos <= g)
            update(tree[root.leftChild], pos, val);
        else
            update(tree[root.rightChild], pos, val);
        root.mx = max(tree[root.leftChild].mx, tree[root.rightChild].mx);
        return;
    }
    
    void update(int pos, int val) {
        update(tree[0], pos, val);
    }
    
    int get(node& root, int u, int v) {
        if (u <= root.leftIdx && root.rightIdx <= v) return root.mx;
        if (u > root.rightIdx || v < root.leftIdx) return 0;
        int res = max(get(tree[root.leftChild], u, v),get(tree[root.rightChild], u, v));
        return res;
    }
    
    int get(int u, int v) {
        assert(u <= v);
        return get(tree[0], u, v);
    }
} segmentTree;


int u1, v1, u2, v2;
int n;

struct point {
    int x, y;
};

point p[N];

void inv(int& x) {
    x = 100000000 - 1 - x;
}

map<int, int> st;

bool cmp(int i, int j) {
    return p[i].y < p[j].y;
}

int id[N];

ll pw = 1000000000000ll;

void print(ll x) {
    cout << ".";
    x %= pw;
    if (x < 0) x += pw;
    string s = "";
    rep(j, 0, 12) {
        s = s + char(x % 10 + '0');
        x/=10;
    }
    reverse(s.begin(), s.end());
    cout << s;
}

void solve() {
    cin >> u1 >> v1 >> u2 >> v2;
    cin >> n;
    rep(i, 0, n) {
        scanf("%d%d", &p[i].x, &p[i].y);
    }
    
    if (u1 > u2) {
        inv(u1); inv(u2);
        rep(i, 0, n) {
            inv(p[i].x);
        }
    }
    if (v1 > v2) {
        inv(v1); inv(v2);
        rep(i, 0, n) inv(p[i].y);
    }
    
    if (u1 == u2 || v1 == v2) {
        ll res = (abs(u1 - u2) + abs(v1 - v2)) * 100ll;
        ll shit = 0;
        rep(i, 0, n) {
            if (p[i].x >= u1 && p[i].x <= u2 && p[i].y >= v1 && p[i].y <= v2) {
                shit += 10 * pi - 10 * 2 * pw;
            }
        }
        cout << res + shit / pw;
        print(shit % pw);
        return;
    }
    int k = 0;
    rep(i, 0, n) {
        st[p[i].x] = 0;
        id[i] = i;
    }
    st[u1] = 0;
    st[u2] = 0;
    
    for (auto& it : st) {
        it.second = ++k;
    }
    
    sort(id, id + n, cmp);
    
    segmentTree.init(1, k);
    
    
    for (int j = 0; j < n; ++j) {
        int i = id[j];
        
        if (p[i].y >= v1 && p[i].y <= v2) {
            int xpoint = st[p[i].x];
            if (xpoint >= st[u1] && xpoint <= st[u2]) {
                int tmp = 0;
                tmp = segmentTree.get(1, xpoint);
                segmentTree.update(xpoint, tmp + 1);
            }
        }
    }
    
    ll res = (abs(u1 - u2) + abs(v1 - v2)) * 100ll;
    int tmp = segmentTree.get(st[u1], st[u2]);
    ll shit = 0;
    if (tmp == (min(abs(u1 - u2), abs(v1 - v2)) + 1)) {
        shit += 10 * pi - 10 * 2 * pw;
        tmp --;
    }
    if (!tmp) {
        cout << res;
        return;
    }
    shit += - tmp * 20 * pw + tmp * 5 * pi;
    cout << (res + shit / pw - ((shit < 0 && shit % pw != 0 )? 1 : 0));
    print(pw + (shit % pw));
}

int main() {
#ifdef _LOCAL_
    freopen("in.txt", "r", stdin);
    //    freopen("out.txt", "w", stdout);
#endif
    int Test = 1;
    if (multipleTest) {
        cin >> Test;
    }
    for(int i = 0; i < Test; ++i) {
        solve();
    }
#ifdef _LOCAL_
    cout<<"\n" << 1.0 * clock() / CLOCKS_PER_SEC <<endl;
#endif
}

Measured memory_bytes: 27648