#include <bits/stdc++.h>
using namespace std;
const int INF = 1.01e9;
struct pt {
  long long x, y;
  pt() {}
  pt(long long xx, long long yy) : x(xx), y(yy) {}
  pt operator+(pt A) const { return pt(x + A.x, y + A.y); }
  pt operator-(pt A) const { return pt(x - A.x, y - A.y); }
  pt operator*(long long k) const { return pt(x * k, y * k); }
  pt operator/(long long k) const {
    assert(x % k == 0 && y % k == 0);
    return pt(x / k, y / k);
  }
  long long operator*(pt A) const { return x * A.y - y * A.x; }
  long long operator%(pt A) { return x * A.x + y * A.y; }
  bool operator==(pt A) const { return x == A.x && y == A.y; }
  bool operator!=(pt A) { return x != A.x && y != A.y; }
  pt rotate() { return pt(-y, x); }
  long long len2() { return x * x + y * y; }
  double len() { return sqrt(x * x + y * y); }
  void read() { scanf("%lld%lld", &x, &y); }
};
bool checkOrd(pt v, pt A, pt B) {
  bool partA = v * A < 0 || (v * A == 0 && v % A < 0);
  bool partB = v * B < 0 || (v * B == 0 && v % B < 0);
  if (partA != partB) {
    return partA < partB;
  }
  return A * B > 0;
}
int main() {
  int n;
  scanf("%d", &n);
  vector<pt> p(n);
  for (int i = 0; i < n; i++) {
    p[i].read();
  }
  int st, fn;
  scanf("%d%d", &st, &fn);
  st--;
  fn--;
  vector<vector<pair<int, double>>> e;
  vector<pair<double, int>> event;
  vector<double> pref;
  pref.push_back(0);
  for (int i = 0; i < n; i++) {
    pref.push_back(pref.back() + (p[i] - p[(i + 1) % n]).len());
  }
  e.resize(2);
  event.push_back({pref[st], 0});
  event.push_back({pref[fn], 1});
  struct Event {
    int type;
    pt A, B;
    double la, lb;
  };
  vector<Event> ee;
  for (int i = 0; i < n; i++) {
    pt A = p[i];
    pt B = p[(i + 1) % n];
    if (A.x == B.x) continue;
    double la = pref[i];
    double lb = pref[i + 1];
    if (A.x > B.x) {
      swap(A, B);
      swap(la, lb);
    }
    ee.push_back({1, A, B, la, lb});
    ee.push_back({4, B, A, -1, -1});
  }
  for (int i = 0; i < n; i++) {
    pt A = p[(i - 1 + n) % n];
    pt B = p[i];
    pt C = p[(i + 1) % n];
    if (checkOrd(pt(0, 1), A - B, C - B)) {
      ee.push_back({2, B, pt(-1, -1), pref[i], -1});
    }
    if (checkOrd(pt(0, -1), A - B, C - B)) {
      ee.push_back({3, B, pt(-1, -1), pref[i], -1});
    }
  }
  sort((ee).begin(), ee.end(), [](Event E1, Event E2) {
    return E1.A.x < E2.A.x || (E1.A.x == E2.A.x && E1.type < E2.type);
  });
  struct Seg {
    pt A, B;
    double la, lb;
    pair<double, double> getProj(long long x) const {
      assert(A.x <= x && x <= B.x);
      double y = (A.y * (B.x - x) + B.y * (x - A.x)) * 1.0 / (B.x - A.x);
      double p = (la * (B.x - x) + lb * (x - A.x)) * 1.0 / (B.x - A.x);
      return {p, y};
    }
    bool operator<(Seg other) const {
      if (A.x == B.x) {
        return (other.A - other.B) * (A - other.B) > 0;
      }
      if (other.A.x == other.B.x) {
        return (other.A - B) * (A - B) > 0;
      }
      if (A.x < other.A.x) {
        if (other.A.x < B.x) {
          return (other.A - B) * (A - B) > 0;
        }
        assert(other.A.x == B.x);
        if (other.A.y != B.y) {
          return B.y < other.A.y;
        }
        return true;
      }
      if (other.A.x < A.x) {
        if (A.x < other.B.x) {
          return (other.A - other.B) * (A - other.B) > 0;
        }
        if (other.B.y != A.y) {
          return A.y < other.B.y;
        }
        return false;
      }
      assert(other.A.x == A.x);
      if (other.A.y != A.y) {
        return A.y < other.A.y;
      }
      assert(A == other.A);
      return (B - A) * (other.B - other.A) > 0;
    }
  };
  set<Seg> q;
  for (auto E : ee) {
    if (E.type == 1) {
      assert(q.insert({E.A, E.B, E.la, E.lb}).second);
    } else if (E.type == 4) {
      assert(q.erase({E.B, E.A, -1, -1}));
    } else if (E.type == 2) {
      auto it = q.upper_bound({E.A, E.A, -1, -1});
      assert(it != q.end());
      auto res = it->getProj(E.A.x);
      assert(E.A.y + 1e-9 < res.second);
      int vert1 = e.size();
      int vert2 = e.size() + 1;
      e.emplace_back();
      e.emplace_back();
      event.push_back({res.first, vert1});
      event.push_back({E.la, vert2});
      e[vert1].push_back({vert2, res.second - E.A.y});
    } else if (E.type == 3) {
      auto it = q.lower_bound({E.A, E.A, -1, -1});
      assert(it != q.begin());
      it--;
      auto res = it->getProj(E.A.x);
      assert(res.second + 1e-9 < E.A.y);
      int vert1 = e.size();
      int vert2 = e.size() + 1;
      e.emplace_back();
      e.emplace_back();
      event.push_back({E.la, vert1});
      event.push_back({res.first, vert2});
      e[vert1].push_back({vert2, E.A.y - res.second});
    }
  }
  sort((event).begin(), event.end());
  for (int i = 0; i < (int)(event).size(); i++) {
    double d = event[(i + 1) % (int)(event).size()].first - event[i].first;
    if (d < 0) {
      assert(d < 1e-9);
      d += pref.back();
    }
    int v = event[(i + 1) % (int)(event).size()].second;
    int u = event[i].second;
    e[v].push_back({u, d});
    e[u].push_back({v, d});
  }
  vector<double> dist(e.size(), INF);
  dist[0] = 0;
  set<pair<double, int>> w;
  w.insert({0, 0});
  while (!w.empty()) {
    int v = w.begin()->second;
    w.erase(w.begin());
    for (auto x : e[v]) {
      int u = x.first;
      if (dist[u] > dist[v] + x.second + 1e-9) {
        w.erase({dist[u], u});
        dist[u] = dist[v] + x.second;
        w.insert({dist[u], u});
      }
    }
  }
  printf("%.17f\n", dist[1]);
}
