import std.algorithm;
import std.array;
import std.math;
import std.random;
import std.range;
import std.stdio;
import std.typecons;

immutable int nil = 0;

alias Point = Tuple !(int, q{x}, int, q{y});

struct Node
{
	int coord;
	int value;
	int best;
	int num;
	int left;
	int right;

	this (int coord_)
	{
		coord = coord_;
		value = 1;
		best = value;
		num = 1;
		left = nil;
		right = nil;
	}
}

Node [] t;
int nodes;
int root;

void tRecalc (int v)
{
	t[v].best = max (t[v].value, t[t[v].left].best, t[t[v].right].best);
	t[v].num = 1 + t[t[v].left].num + t[t[v].right].num;
}

int [2] tSplit (int v, int x)
{
	if (v == nil)
	{
		return [nil, nil];
	}
	if (t[v].coord < x)
	{
		auto temp = tSplit (t[v].right, x);
		t[v].right = temp[0];
		tRecalc (v);
		return [v, temp[1]];
	}
	else
	{
		auto temp = tSplit (t[v].left, x);
		t[v].left = temp[1];
		tRecalc (v);
		return [temp[0], v];
	}
}

int tMerge (int u, int v)
{
	if (u == nil)
	{
		return v;
	}
	if (v == nil)
	{
		return u;
	}
	if (uniform (0, t[u].num + t[v].num) < t[u].num)
	{
		t[u].right = tMerge (t[u].right, v);
		tRecalc (u);
		return u;
	}
	else
	{
		t[v].left = tMerge (u, t[v].left);
		tRecalc (v);
		return v;
	}
}

void main ()
{
	rndGen.seed (12125);

	int x1, y1, x2, y2;
	while (readf (" %s %s %s %s", &x1, &y1, &x2, &y2) > 0)
	{
		int n;
		readf (" %s", &n);
		auto p = new Point [n];
		foreach (i; 0..n)
		{
			readf (" %s %s", &p[i].x, &p[i].y);
		}
		if (x1 > x2)
		{
			x1 = -x1;
			x2 = -x2;
			foreach (ref c; p)
			{
				c.x = -c.x;
			}
		}
		if (y1 > y2)
		{
			y1 = -y1;
			y2 = -y2;
			foreach (ref c; p)
			{
				c.y = -c.y;
			}
		}
		if (x2 - x1 < y2 - y1)
		{
			swap (x1, y1);
			swap (x2, y2);
			foreach (ref c; p)
			{
				swap (c.x, c.y);
			}
		}
		auto q = p.filter !(c => x1 <= c.x && c.x <= x2 &&
		    y1 <= c.y && c.y <= y2).array;
		sort (q);
		real res = ((x2 - x1) + (y2 - y1)) * 100.0;
		t = new Node [q.length + 1];
		nodes = 1;
		root = nil;
		foreach (ref c; q)
		{
			debug {writeln (c.x, " ", c.y);}
			t[nodes] = Node (c.y);
			auto temp = tSplit (root, c.y);
			debug {writeln (temp[0], " : ", temp[1]);}
			t[nodes].value = t[temp[0]].best + 1;
			tRecalc (nodes);
			temp[0] = tMerge (temp[0], nodes);
			root = tMerge (temp[0], temp[1]);
			nodes += 1;
		}
		debug
		{
			foreach (i; 0..nodes)
			{
				writeln (t[i]);
			}
                }
		int best = t[root].best;
		debug {writeln ("best = ", best, ", diff = ", y2 - y1);}
		if (best > y2 - y1)
		{
			res += PI * 10.0 - 20.0;
			best -= 1;
		}
		res += best * (PI * 5.0 - 20.0);
		writefln ("%.20f", res);
	}
}
