// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



#define FOR(i,a,b) for(int i = (a); i < (b); i++)

#define RFOR(i,b,a) for(int i = (b) - 1; i >= (a); i--)

#define ITER(it, a) for(typeof(a.begin()) it = a.begin(); it != a.end(); it++)

#define FILL(a, value) memset(a, value, sizeof(a))



#define SZ(a) (int) a.size()

#define ALL(a) a.begin(),a.end()

#define PB push_back

#define MP make_pair



typedef long long LL;

typedef vector<int> VI;

typedef pair<int, int> PII;



const double PI = acos(-1.0);

const LL INF = 1000 * 1000 * 1000 + 7;

const LL LINF = INF * (LL)INF;



const int MAX = 400400;



PII A[MAX];



VI v;

int get(int x)

{

	return lower_bound(ALL(v), x) - v.begin();

}



struct Fen

{

	int A[MAX];

	int n;



	void init(int n)

	{

		this->n = n;

		FOR (i, 0, n)

		{

			A[i] = -INF;

		}

	}



	void add(int x, int val)

	{

		for (; x < n; x = x | (x+1))

		{

			A[x] = max(A[x], val);

		}

	}



	int get(int x)

	{

		int res = -INF;

		for (; x >= 0; x = (x & (x + 1)) - 1)

		{

			res = max(res, A[x]);

		}

		return res;

	}

} F;



int main()

{

	//freopen("in.txt", "r", stdin);

	//ios::sync_with_stdio(false); cin.tie(0);



	int x1, y1, x2, y2;

	scanf("%d%d%d%d", &x1, &y1, &x2, &y2);

	int n;

	scanf("%d", &n);



	FOR (i, 0, n)

	{

		int x, y;

		scanf("%d%d", &x, &y);

		A[i] = MP(x, y);

	}



	if (x2 > x1)

	{

		FOR (i, 0, n)

		{

			A[i].first *= -1;

		}

		x1 *= -1;

		x2 *= -1;

	}



	if (y2 > y1)

	{

		FOR (i, 0, n)

		{

			A[i].second *= -1;

		}

		y1 *= -1;

		y2 *= -1;

	}



	int dx = abs(x1 - x2);

	int dy = abs(y1 - y2);



	double res = (dx + dy) * 100.;



	v.PB(x1);

	v.PB(y1);

	v.PB(x2);

	v.PB(y2);

	FOR (i, 0, n)

	{

		v.PB(A[i].first);

		v.PB(A[i].second);

	}



	sort(ALL(v));

	v.erase(unique(ALL(v)), v.end());



	x1 = get(x1);

	y1 = get(y1);

	x2 = get(x2);

	y2 = get(y2);

	FOR (i, 0, n)

	{

		A[i].first = get(A[i].first);

		A[i].second = get(A[i].second);

	}



	sort(A, A+n);



	F.init(SZ(v));



	F.add(y2, 0);



	FOR (i, 0, n)

	{

		if (A[i].first < x2) continue;

		if (A[i].first > x1) break;

		int v = F.get(A[i].second) + 1;

		F.add(A[i].second, v);

	}



	int cnt = F.get(y1);



	int a, b;



	//double sub = (20 - PI * 10 / 2) * cnt;

	//res -= sub;

	a = cnt;

	b = 0;



	if (cnt == min(dx, dy) + 1)

	{

		a--;

		b++;

	}



	res -= a * (20 - PI * 5);

	res += b * (PI*10 - 20);



	printf("%.15f\n", res);



}


// Optimized solution to the same problem (faster):
#include<cstdio>

#include<cstring>

#include<algorithm>

#define MAXN 200000

using namespace std;

struct Point

{

	int x,y;

	Point(){};

	Point(int _x,int _y):x(_x),y(_y){};

}ft[MAXN+5],P1,P2;

int N;

int B[MAXN+5];

bool cmp1(const Point &a,const Point &b)

{return a.x<b.x;}

bool cmp2(const Point &a,const Point &b)

{return a.x>b.x;}

int main()

{

	scanf("%d %d %d %d",&P1.x,&P1.y,&P2.x,&P2.y);

	if(P1.x>P2.x)

		swap(P1,P2);

	double ans=0;

	if(P1.y<P2.y)

	{

		scanf("%d",&N);

		for(int i=1;i<=N;i++)

		{

			scanf("%d %d",&ft[i].x,&ft[i].y);

			if(ft[i].x<P1.x||ft[i].y<P1.y||ft[i].x>P2.x||ft[i].y>P2.y)

			{

				i--,N--;

				continue;

			}

		}

		sort(ft+1,ft+1+N,cmp1);

	}

	else if(P1.y>=P2.y)

	{

		scanf("%d",&N);

		for(int i=1;i<=N;i++)

		{

			scanf("%d %d",&ft[i].x,&ft[i].y);

			if(ft[i].x<P1.x||ft[i].y>P1.y||ft[i].x>P2.x||ft[i].y<P2.y)

			{

				i--,N--;

				continue;

			}

		}

		sort(ft+1,ft+1+N,cmp2);

	}

	if(N==0)

		ans=(1.0*abs(P1.x-P2.x)+1.0*abs(P1.y-P2.y))*100.0;

	else

	{

		int maxl=1;

		B[1]=ft[1].y;

		for(int i=1;i<=N;i++)

		{

			int p=lower_bound(B+1,B+1+maxl,ft[i].y)-B;

			B[p]=ft[i].y;

			maxl=max(maxl,p);

		}

		int lim=min(abs(P1.x-P2.x),abs(P1.y-P2.y));

		int rl=min(maxl,lim);

		double del=-4.2920367320510338;

		double add=11.41592653589793238;

		ans=(1.0*abs(P1.x-P2.x)+1.0*abs(P1.y-P2.y))*100.0+1.0*rl*del;

		if(maxl>lim)

			ans+=(1.0*maxl-1.0*lim)*add;

 	}

	printf("%.15f\n",ans);

	return 0;

}

// Fastest known solution for this problem: