#include <iostream>
#include <algorithm>
#include <bitset>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <array>
#include <unordered_map>
#include <complex>
#include <deque>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <chrono>
#include <random>
#include <numeric>
using namespace std;

#define forr(x,arr) for(auto&& x:arr)
#define _overload3(_1,_2,_3,name,...) name
#define _rep2(i,n) _rep3(i,0,n)
#define _rep3(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload3(__VA_ARGS__,_rep3,_rep2,)(__VA_ARGS__)
#define _rrep2(i,n) _rrep3(i,0,n)
#define _rrep3(i,a,b) for(int i=int(b)-1;i>=int(a);i--)
#define rrep(...) _overload3(__VA_ARGS__,_rrep3,_rrep2,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define bit(n) (1LL<<(n))
#define sz(x) ((int)(x).size())
#define TEN(n) ((ll)(1e##n))
#define fst first
#define snd second

string DBG_DLM(int &i){return(i++==0?"":", ");}
#define DBG_B(exp){int i=0;os<<"{";{exp;}os<<"}";return os;}
template<class T>ostream&operator<<(ostream&os,vector<T>v);
template<class T>ostream&operator<<(ostream&os,set<T>v);
template<class T>ostream&operator<<(ostream&os,queue<T>q);
template<class T>ostream&operator<<(ostream&os,priority_queue<T>q);
template<class T,class K>ostream&operator<<(ostream&os,pair<T,K>p);
template<class T,class K>ostream&operator<<(ostream&os,map<T,K>mp);
template<class T,class K>ostream&operator<<(ostream&os,unordered_map<T,K>mp);
template<int I,class TPL>void DBG(ostream&os,TPL t){}
template<int I,class TPL,class H,class...Ts>void DBG(ostream&os,TPL t){os<<(I==0?"":", ")<<get<I>(t);DBG<I+1,TPL,Ts...>(os,t);}
template<class T,class K>void DBG(ostream&os,pair<T,K>p,string delim){os<<"("<<p.first<<delim<<p.second<<")";}
template<class...Ts>ostream&operator<<(ostream&os,tuple<Ts...>t){os<<"(";DBG<0,tuple<Ts...>,Ts...>(os,t);os<<")";return os;}
template<class T,class K>ostream&operator<<(ostream&os,pair<T,K>p){DBG(os,p,", ");return os;}
template<class T>ostream&operator<<(ostream&os,vector<T>v){DBG_B(forr(t,v){os<<DBG_DLM(i)<<t;});}
template<class T>ostream&operator<<(ostream&os,set<T>s){DBG_B(forr(t,s){os<<DBG_DLM(i)<<t;});}
template<class T>ostream&operator<<(ostream&os,queue<T>q){DBG_B(for(;q.size();q.pop()){os<<DBG_DLM(i)<<q.front();});}
template<class T>ostream&operator<<(ostream&os,priority_queue<T>q){DBG_B(for(;q.size();q.pop()){os<<DBG_DLM(i)<<q.top();});}
template<class T,class K>ostream&operator<<(ostream&os,map<T,K>m){DBG_B(forr(p,m){os<<DBG_DLM(i);DBG(os,p,"->");});}
template<class T,class K>ostream&operator<<(ostream&os,unordered_map<T,K>m){DBG_B(forr(p,m){os<<DBG_DLM(i);DBG(os,p,"->");});}
#define DBG_OVERLOAD(_1,_2,_3,_4,_5,_6,macro_name,...)macro_name
#define DBG_LINE(){char s[99];sprintf(s,"line:%3d | ",__LINE__);cerr<<s;}
#define DBG_OUTPUT(v){cerr<<(#v)<<"="<<(v);}
#define DBG1(v,...){DBG_OUTPUT(v);}
#define DBG2(v,...){DBG_OUTPUT(v);cerr<<", ";DBG1(__VA_ARGS__);}
#define DBG3(v,...){DBG_OUTPUT(v);cerr<<", ";DBG2(__VA_ARGS__);}
#define DBG4(v,...){DBG_OUTPUT(v);cerr<<", ";DBG3(__VA_ARGS__);}
#define DBG5(v,...){DBG_OUTPUT(v);cerr<<", ";DBG4(__VA_ARGS__);}
#define DBG6(v,...){DBG_OUTPUT(v);cerr<<", ";DBG5(__VA_ARGS__);}
#define DEBUG0(){DBG_LINE();cerr<<endl;}
#ifdef LOCAL
#define out(...){DBG_LINE();DBG_OVERLOAD(__VA_ARGS__,DBG6,DBG5,DBG4,DBG3,DBG2,DBG1)(__VA_ARGS__);cerr<<endl;}
#else
#define out(...)
#endif

using ll=long long;
using pii=pair<int,int>;using pll=pair<ll,ll>;using pil=pair<int,ll>;using pli=pair<ll,int>;
using vs=vector<string>;using vvs=vector<vs>;using vvvs=vector<vvs>;
using vb=vector<bool>;using vvb=vector<vb>;using vvvb=vector<vvb>;
using vi=vector<int>;using vvi=vector<vi>;using vvvi=vector<vvi>;
using vl=vector<ll>;using vvl=vector<vl>;using vvvl=vector<vvl>;
using vd=vector<double>;using vvd=vector<vd>;using vvvd=vector<vvd>;
using vpii=vector<pii>;using vvpii=vector<vpii>;using vvvpii=vector<vvpii>;
template<class A,class B>bool amax(A&a,const B&b){return b>a?a=b,1:0;}
template<class A,class B>bool amin(A&a,const B&b){return b<a?a=b,1:0;}
ll ri(){ll l;cin>>l;return l;} string rs(){string s;cin>>s;return s;}

#define X first
#define Y second

template <class IT> int count_lis(const IT &beg, const IT &end) {
  int n = end - beg;
  const auto inf = numeric_limits<typename IT::value_type>::max();
  vector<typename IT::value_type> dp(n, inf);
  for (auto it = beg; it < end; it++) *lower_bound(dp.begin(), dp.end(), *it) = *it;
  return lower_bound(dp.begin(), dp.end(), inf) - dp.begin();
}

double solve() {
	int x1 = ri(), y1 = ri(), x2 = ri(), y2 = ri();
	int n = ri();

	if (y1 > y2 && x1 > x2) {
		out("swap1");
		swap(x1, x2);
		swap(y1, y2);
	}

	vpii F(n);

	vi X(n);

	rep(i, n) {
		F[i].X = ri();
		F[i].Y = ri();
		X[i] = F[i].X;
	}

	const long double PI = 3.1415926535897932384626;
	const long double bene = 20 - 10 * 2 * PI / 4;
	const long double loss = 10 * 2 * PI / 2 - 20;
	ll massugu = (abs(x1 - x2) + abs(y1 - y2)) * ((ll) 100);

	out(bene, loss, massugu);

	if (x1 == x2) {
		int mi = min(y1, y2);
		int ma = max(y1, y2);
		int cnt = 0;
		rep(i, n) {
			if (F[i].X == x1) {
				if (F[i].Y >= mi && F[i].Y <= ma) cnt++;
			}
		}
		return massugu + loss * cnt;
	}

	if (y1 == y2) {
		int mi = min(x1, x2);
		int ma = max(x1, x2);
		int cnt = 0;
		rep(i, n) {
			if (F[i].Y == y1) {
				if (F[i].X >= mi && F[i].X <= ma) cnt++;
			}
		}
		return massugu + loss * cnt;
	}

	X.emplace_back(x1);
	X.emplace_back(x2);
	sort(all(X));
	X.erase(unique(X.begin(), X.end()), X.end());

	const int inf = 1e9;

	auto comp = [&](int x) {
		return lower_bound(all(X), x) - X.begin();
	};

	int c1 = comp(x1);
	int c2 = comp(x2);

	rep(i, n) {
		F[i].X = comp(F[i].X);
	}

	if (c1 > c2) {
		out("swap2");
		rep(i, n) {
			F[i].X = c1 - F[i].X;
		}
		c2 = c1 - c2;
		c1 = 0;
		swap(x1, x2);
	}

	if (y1 > y2) {
		out("swap3");
		rep(i, n) {
			F[i].Y = y1 - F[i].Y;
		}
		y2 = y1 - y2;
		y1 = 0;

		int mi = 0;
		rep(i, n) amin(mi, F[i].Y);

		rep(i, n) {
			F[i].Y -= mi;
		}
		y1 -= mi;
		y2 -= mi;
	}

	vi A(c2 - c1 + 1, inf);
	rep(i, n) {
		if (F[i].X >= c1 && F[i].X <= c2) {
			A[F[i].X-c1] = F[i].Y;
		}
	}

	vi B;
	forr(a, A) {
		if (a >= y1 && a <= y2) B.emplace_back(a + 1);
	}


	int lis = count_lis(all(B));
	out(massugu, lis);

	long double ans;
	out(y1, y2);
	out(x1, x2, c1, c2);
	int mind = min(y2 - y1, x2 - x1) + 1;

	if (lis && lis == mind) {
		out("p1");
		ans = massugu - (bene * (lis - 1) - loss);
	}
	else {
		out("p2");
		ans = massugu - bene * lis;
	}

	return ans;
}

void Main() {
	cout << fixed << setprecision(10);
	cout << solve() << endl;
}
signed main() {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  Main();
  return 0;
}


Measured memory_bytes: 5232