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

#define rep(i,x,y) for(int i=(x);i<(y);++i)
#define debug(x) #x << "=" << (x)

#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif

const int inf=1e9;
const int64_t inf64=1e18;
const double eps=1e-9;

template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec){
    os << "[";
    for (const auto &v : vec) {
    	os << v << ",";
    }
    os << "]";
    return os;
}

using i64=int64_t;

template<class T,T op(T,T)> class segtree{
public:
    int n,size_;
    vector<T> dat;
    T id_;
    segtree()=default;
    segtree(int size,T id,T initial_value){ init(size,id,initial_value); }
    void init(int size,T id,T initial_value){
        size_=size;
        id_=id;
        n=1;
        while(n<size) n*=2;
        dat.assign(2*n-1,id);
        for(int i=0; i<size; ++i) update(i,initial_value);
    }
    int size()const{ return size_; }
    void update(int k, T a) {
        k+=n-1; // leaf
        dat[k]=a;
        while(k>0) {
            k=(k-1)/2;
            dat[k]=op(dat[k*2+1],dat[k*2+2]);
        }
    }
    T at(int index){ return dat[index+n-1]; }
    void add(int k,T a){ update(k,at(k)+a); }
    T query(int a,int b) { return query(a,b,0,0,n); }
    T query(int a,int b,int k,int l,int r) {
        if(r<=a or b<=l) return id_;
        if(a<=l and r<=b) return dat[k];
        int m=(l+r)/2;
        return op(query(a,b,k*2+1,l,m),query(a,b,k*2+2,m,r));
    }
};

i64 max_(i64 a,i64 b){
    return max(a,b);
}

void solve(){

    i64 x1,y1,x2,y2,N;
    cin >> x1 >> y1 >> x2 >> y2 >> N;

    vector<pair<i64,i64>> XY(N);
    rep(i,0,N) cin >> XY[i].first >> XY[i].second;
    
    if(x1>x2){
        x1=100000000-1-x1;
        x2=100000000-1-x2;
        rep(i,0,N) XY[i].first=100000000-1-XY[i].first;
    }

    if(y1>y2){
        y1=100000000-1-y1;
        y2=100000000-1-y2;
        rep(i,0,N) XY[i].second=100000000-1-XY[i].second;
    }

    vector<i64> ys;
    ys.push_back(y1);
    ys.push_back(y2);
    rep(i,0,N) ys.push_back(XY[i].second);
    sort(ys.begin(),ys.end());
    ys.erase(unique(ys.begin(),ys.end()),ys.end());

    unordered_map<i64,i64> y_to_i;
    rep(i,0,ys.size()) y_to_i[ys[i]]=i;

    segtree<i64,max_> seg(ys.size(),-inf64,0);
    sort(XY.begin(),XY.end());
    
    i64 lb=y_to_i[y1],ub=y_to_i[y2];
    rep(i,0,N){
        if(XY[i].first<x1) continue;
        if(x2<XY[i].first) break;
        i64 i_=y_to_i[XY[i].second];
        if(i_<lb or ub<i_) continue;
        seg.update(i_,seg.query(lb,i_+1)+1);
    }

    i64 ma=seg.query(lb,ub+1);
    const long double pi=acosl(-1);
    if(ma<min(x2-x1,y2-y1)+1) cout << 100*((x2-x1)+(y2-y1))+5*(pi-4)*ma << endl;
    else cout << 100*((x2-x1)+(y2-y1))+5*(pi-4)*(ma-1)+10*(pi-2) << endl;
    
}

int main(){
    std::cin.tie(0);
    std::ios::sync_with_stdio(false);
    cout.setf(ios::fixed);
    cout.precision(16);
    solve();
    return 0;
}


/*
    891.415926535897938
    891.4159265358979324

    211.415926535897938
    211.        4159265358979324
    10000000011.4159265356138349
    10000000011.4159265356138349
*/

Measured memory_bytes: 17392