#include <ios>
#include <iostream>
#include <iomanip>
#include <vector>
#include <utility>
#include <map>
#include <algorithm>

int x[200005] = {};
int y[200005] = {};
int dp[200005] = {};
int par[200005] = {};
std::vector<std::pair<int, int> > v;
std::map<int, int> mp;
std::vector<int> ans;

inline int minimum(int a, int b)
{
    return (a < b ? a : b);
}

inline int maximum(int a, int b)
{
    return (a > b ? a : b);
}

inline int absolute(int a)
{
    return (a < 0 ? -a : a);
}

struct segtree
{
    int l, r;
    int max_val;
    int max_ind;
    segtree *left;
    segtree *right;

    segtree(int i, int j)
    {
        l = i;
        r = j;
        if (l == r)
        {
            left = NULL;
            right = NULL;
            max_val = 0;
            max_ind = -1;
        }
        else
        {
            int k = (l+r)/2;
            left = new segtree(l, k);
            right = new segtree(k+1, r);
            if (left->max_val > right->max_val)
            {
                max_ind = left->max_ind;
                max_val = left->max_val;
            }
            else
            {
                max_ind = right->max_ind;
                max_val = right->max_val;
            }
        }
    }

    void upd(int i, int a, int b)
    {
        if (l <= i && i <= r)
        {
            if (l == r)
            {
                max_val = a;
                max_ind = b;
            }
            else
            {
                left->upd(i, a, b);
                right->upd(i, a, b);
                if (left->max_val > right->max_val)
                {
                    max_ind = left->max_ind;
                    max_val = left->max_val;
                }
                else
                {
                    max_ind = right->max_ind;
                    max_val = right->max_val;
                }
            }
        }
    }

    std::pair<int, int> rmq(int i, int j)
    {
        if (i <= l && r <= j)
            return std::make_pair(max_val, max_ind);
        else if (j < l || r < i)
            return std::make_pair(0, -1);
        else
        {
            std::pair<int, int> lf = left->rmq(i, j);
            std::pair<int, int> rg = right->rmq(i, j);
            if (lf.first > rg.first)
                return lf;
            else
                return rg;
        }
    }
};

int main()
{
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);
    std::cout.tie(NULL);
    int n;
    int x_s, y_s, x_t, y_t;
    std::cin >> x_s >> y_s >> x_t >> y_t;
    if (y_s > y_t)
    {
        int temp_x = x_s;
        int temp_y = y_s;
        x_s = x_t;
        y_s = y_t;
        x_t = temp_x;
        y_t = temp_y;
    }
    //s is the lower one
    std::cin >> n;
    for (int i = 0; i < n; i++)
    {
        std::cin >> x[i] >> y[i];
        if (y[i] < y_s || y[i] > y_t || x[i] < minimum(x_s, x_t) || x[i] > maximum(x_s, x_t))
        {
            i--;
            n--;
        }
    }
    if (n == 0)
        std::cout << 100LL*(absolute(x_s-x_t) + absolute(y_s-y_t)) << '\n';
    else
    {
        //compute LIS of the remaining
        if (x_s < x_t)
        {
            for (int i = 0; i < n; i++)
                v.push_back(std::make_pair(x[i], y[i]));
            std::sort(v.begin(), v.end());
        }
        else
        {
            for (int i = 0; i < n; i++)
                v.push_back(std::make_pair(-x[i], y[i]));
        }
        std::sort(v.begin(), v.end());
        int c = 0;
        for (int i = 0; i < n; i++)
            mp[v[i].second];
        for (std::map<int, int>::iterator it = mp.begin(); it != mp.end(); it++)
            it->second = c++;
        for (int i = 0; i < n; i++)
            v[i].second = mp[v[i].second];
        segtree *tree = new segtree(0, n-1);
        for (int i = 0; i < n; i++)
        {
            if (v[i].second != 0)
            {
                std::pair<int, int> u = tree->rmq(0, v[i].second-1);
                dp[i] = u.first+1;
                par[i] = u.second;
            }
            else
            {
                dp[i] = 1;
                par[i] = -1;
            }
            tree->upd(v[i].second, dp[i], i);
        }
        int maxi = 0;
        for (int i = 0; i < n; i++)
        {
            if (dp[i] > dp[maxi])
                maxi = i;
        }
        while (maxi >= 0)
        {
            ans.push_back(maxi);
            maxi = par[maxi];
        }
        std::reverse(ans.begin(), ans.end());
        if (ans.size() == minimum(y_t - y_s + 1, absolute(x_t-x_s)+1))
            std::cout << std::fixed << std::setprecision(15) << 100LL*(absolute(x_s-x_t) + absolute(y_s-y_t)) - 4.292036732051031*((double)(ans.size())) + 15.707963267948969 << '\n';
        else
            std::cout << std::fixed << std::setprecision(15) << 100LL*(absolute(x_s-x_t) + absolute(y_s-y_t)) - 4.292036732051031*((double)(ans.size())) << '\n';
    }
}

/*
. . > > O > B
A > O . . . .

0 0 6 1
2
2 0
4 1

0 0 100000000 100000000
1
50000000 50000000

. . O . > > B
A > > > O . .

. . . . O . B
. . . O . . .
A . O . . . .

. . . . O . B
. . . . . . .
. . . O . . .
A . O . . . .

. . . . O . B
. . . . . O .
. . . O . . .
A . O . . . .

0 0 0 2
1
0 1
*/


Measured memory_bytes: 34928