#include <iostream>
#include <iomanip>
#include <climits>
#include <algorithm>
#include <vector>
#include <deque>
#include <queue>
#include <list>
#include <stack>
#include <string>
#include <functional>
#include <numeric>
#include <map>
#include <set>
#include <cstdlib>
#include <bitset>
#include <unordered_map>
#include <random>
#define _USE_MATH_DEFINES
#include <math.h>
#include <complex>

using namespace std;

#define INF (int)1e8
#define _INF (int)-1e8
#define INFLL (long long)1e15
#define _INFLL (long long)-1e15
#define Loop(i, n) for(int i = 0; i < (int)n; i++)
#define Loop1(i, n) for(int i = 1; i <= (int)n; i++)
#define Loopr(i, n) for(int i = (int)n - 1; i >= 0; i--)
#define Loopr1(i, n) for(int i = (int)n; i >= 1; i--)
#define bitmanip(m,val) static_cast<bitset<(int)m>>(val)
typedef long long int ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef pair<int, int> P;

/*******************************************************/

//Longest Increasing Subsequence
class LIS {
  vll result;
  int n;
public:
  LIS(vll a) {
    result = {};
    Loop(i, a.size()) {
      auto itr = lower_bound(result.begin(), result.end(), a[i]);
      if (itr == result.end()) {
        result.push_back(a[i]);
      }
      else *itr = a[i];
    }
    n = result.size();
    result = {};
    Loop(i, a.size()) {
      auto itr = lower_bound(result.begin(), result.end(), a[i]);
      if (itr == result.end()) {
        result.push_back(a[i]);
        if (result.size() == n) break;
      }
      else *itr = a[i];
    }
  }
  vll get_lis() {
    return result;
  }
  int get_lisn() {
    return n;
  }
};

typedef ll coordinate_t;
struct coordinate {
  coordinate_t x, y;
};

/*
if s != t, after trimming, s.y != t.y
e.g. s = (0,0), t = (2,0) -> (0,2)
*/
class Board_Trimming {
private:
  int rot_angle;
  coordinate move;
public:
  Board_Trimming(coordinate s, coordinate t) {
    move = { s.x * -1, s.y * -1 };
    if (s.x == t.x && s.y == t.y) rot_angle = 0;
    else if (s.x <= t.x && s.y < t.y) rot_angle = 0;
    else if (s.x < t.x && s.y >= t.y) rot_angle = 90;
    else if (s.x >= t.x && s.y > t.y) rot_angle = 180;
    else rot_angle = 270;
  }
  coordinate trans(coordinate a) {
    coordinate ret;
    a.x += move.x;
    a.y += move.y;
    if (rot_angle == 0) ret = { a.x, a.y };
    else if (rot_angle == 90) ret = { a.y * -1, a.x };
    else if (rot_angle == 180) ret = { a.x * -1, a.y * -1 };
    else ret = { a.y, a.x * -1 };
    return ret;
  }
  coordinate invtrans(coordinate a) {
    coordinate ret;
    if (rot_angle == 0) ret = { a.x, a.y };
    else if (rot_angle == 90) ret = { a.y, a.x * -1 };
    else if (rot_angle == 180) ret = { a.x * -1, a.y * -1 };
    else ret = { a.y * -1, a.x };
    ret.x -= move.x;
    ret.y -= move.y;
    return ret;
  }
};

int main() {
  coordinate s, t;
  cin >> s.x >> s.y >> t.x >> t.y;
  Board_Trimming trim(s, t);
  s = trim.trans(s);
  t = trim.trans(t);
  int n; cin >> n;
  vector<coordinate> a(n);
  Loop(i, n) {
    cin >> a[i].x >> a[i].y;
    a[i] = trim.trans(a[i]);
  }
  double quarter = M_PI * 5;
  double ans = 0;
  if (s.x == t.x) {
    int flag = 0;
    Loop(i, n) {
      if (a[i].x == s.x && s.y < a[i].y && a[i].y < t.y) {
        flag = 1;
      }
    }
    ans = (t.y - s.y) * 100 + flag * (quarter - 10) * 2;
  }
  else {
    map<ll, ll> mp;
    Loop(i, n) {
      if (s.x <= a[i].x && a[i].x <= t.x && s.y <= a[i].y && a[i].y <= t.y) {
        mp[a[i].x] = a[i].y;
      }
    }
    vll b;
    for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
      b.push_back(itr->second);
    }
    LIS lis(b);
    vll result = lis.get_lis();
    if (lis.get_lisn() == t.x - s.x + 1 || lis.get_lisn() == t.y - s.y + 1) {
      ans = (t.x - s.x + t.y - s.y) * 100 + (quarter - 20)*(lis.get_lisn() - 1) + (quarter - 10) * 2;
    }
    else {
      ans = (t.x - s.x + t.y - s.y) * 100 + (quarter - 20)*lis.get_lisn();
    }
  }
  cout << setprecision(18) << ans << endl;
  return 0;
}

Measured memory_bytes: 22128