#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const long long INF = 1e18;
struct point {
  double x, y;
  point(double a = 0, double b = 0) : x(a), y(b) {}
};
bool operator==(point a, point b) {
  return fabs(a.x - b.x) < EPS && fabs(a.y - b.y) < EPS;
}
point operator-(point a, point b) { return point(a.x - b.x, a.y - b.y); }
double operator*(point a, point b) { return a.x * b.y - b.x * a.y; }
double operator^(point a, point b) { return a.x * b.x + a.y * b.y; }
double sqr(double a) { return a * a; }
double dist(point a, point b) { return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y)); }
struct line {
  double A, B, C;
  line(point a, point b) {
    A = a.y - b.y;
    B = b.x - a.x;
    C = a * b;
  }
};
bool cross(line a, line b, point &c) {
  double zn = point(a.A, a.B) * point(b.A, b.B);
  if (abs(zn) < EPS) {
    return 0;
  }
  c.x = -(point(a.C, a.B) * point(b.C, b.B)) / zn;
  c.y = -(point(a.A, a.C) * point(b.A, b.C)) / zn;
  return 1;
}
int n;
void out(double x) {
  cout << fixed << setprecision(10) << x;
  exit(0);
}
bool lay(point a, point b, point c) {
  if (c == a || c == b) {
    return 1;
  }
  return (abs((c - a) * (b - a)) < EPS && ((a - c) ^ (b - c)) < 0);
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  point A, B;
  cin >> A.x >> A.y >> B.x >> B.y >> n;
  vector<point> beta(n);
  for (int i = 0; i < n; ++i) {
    cin >> beta[i].x >> beta[i].y;
  }
  line base(A, B);
  vector<point> points;
  double P = 0;
  for (int i = 0; i < n; ++i) {
    int nxt = (i + 1) % n;
    P += dist(beta[i], beta[nxt]);
    line cur(beta[i], beta[nxt]);
    point src;
    bool t = cross(base, cur, src);
    if (t && lay(beta[i], beta[nxt], src) && min(A.x, B.x) <= src.x &&
        src.x <= max(A.x, B.x) && min(A.y, B.y) <= src.y &&
        src.y <= max(A.y, B.y)) {
      points.push_back(src);
    }
  }
  sort(points.begin(), points.end(),
       [](point a, point b) { return a.x < b.x; });
  points.erase(unique(points.begin(), points.end()), points.end());
  if (points.size() < 2) out(dist(A, B));
  for (int i = 0; i < n; ++i) {
    int nxt = (i + 1) % n;
    if (lay(beta[i], beta[nxt], points[0]) &&
        lay(beta[i], beta[nxt], points[1]))
      out(dist(A, B));
  }
  if (dist(A, points[0]) > dist(A, points[1])) swap(points[0], points[1]);
  double res =
      dist(A, points[0]) + 2 * dist(points[0], points[1]) + dist(points[1], B);
  double v = INF;
  for (int i = 0; i < n; ++i) {
    int nxt = (i + 1) % n;
    if (lay(beta[i], beta[nxt], points[0])) {
      double cur = 0;
      cur += dist(points[0], beta[nxt]);
      bool found = 0;
      for (int v = i + 1; v < n; ++v) {
        int nx = (v + 1) % n;
        if (lay(beta[v], beta[nx], points[1])) {
          found = 1;
          cur += dist(beta[v], points[1]);
          break;
        }
        cur += dist(beta[v], beta[nx]);
      }
      if (found) {
        v = cur;
      }
    }
  }
  if (v == INF) {
    swap(points[0], points[1]);
    for (int i = 0; i < n; ++i) {
      int nxt = (i + 1) % n;
      if (lay(beta[i], beta[nxt], points[0])) {
        double cur = 0;
        cur += dist(points[0], beta[nxt]);
        bool found = 0;
        for (int v = i + 1; v < n; ++v) {
          int nx = (v + 1) % n;
          if (lay(beta[v], beta[nx], points[1])) {
            found = 1;
            cur += dist(beta[v], points[1]);
            break;
          }
          cur += dist(beta[v], beta[nx]);
        }
        if (found) {
          v = cur;
        }
      }
    }
    swap(points[0], points[1]);
  }
  v = min(v, P - v);
  res = min(res, dist(A, points[0]) + v + dist(points[1], B));
  out(res);
  return 0;
}
