#include <bits/stdc++.h>
using namespace std;
using DD = double;
const DD INF = 1LL << 60;
const DD EPS = 1e-10;
const DD PI = acos(-1.0);
DD torad(int deg) { return (DD)(deg)*PI / 180; }
DD todeg(DD ang) { return ang * 180 / PI; }
struct Point {
  DD x, y;
  Point(DD x = 0.0, DD y = 0.0) : x(x), y(y) {}
  friend ostream &operator<<(ostream &s, const Point &p) {
    return s << '(' << p.x << ", " << p.y << ')';
  }
};
inline Point operator+(const Point &p, const Point &q) {
  return Point(p.x + q.x, p.y + q.y);
}
inline Point operator-(const Point &p, const Point &q) {
  return Point(p.x - q.x, p.y - q.y);
}
inline Point operator*(const Point &p, DD a) { return Point(p.x * a, p.y * a); }
inline Point operator*(DD a, const Point &p) { return Point(a * p.x, a * p.y); }
inline Point operator*(const Point &p, const Point &q) {
  return Point(p.x * q.x - p.y * q.y, p.x * q.y + p.y * q.x);
}
inline Point operator/(const Point &p, DD a) { return Point(p.x / a, p.y / a); }
inline Point conj(const Point &p) { return Point(p.x, -p.y); }
inline Point rot(const Point &p, DD ang) {
  return Point(cos(ang) * p.x - sin(ang) * p.y,
               sin(ang) * p.x + cos(ang) * p.y);
}
inline Point rot90(const Point &p) { return Point(-p.y, p.x); }
inline DD cross(const Point &p, const Point &q) {
  return p.x * q.y - p.y * q.x;
}
inline DD dot(const Point &p, const Point &q) { return p.x * q.x + p.y * q.y; }
inline DD norm(const Point &p) { return dot(p, p); }
inline DD abs(const Point &p) { return sqrt(dot(p, p)); }
inline DD amp(const Point &p) {
  DD res = atan2(p.y, p.x);
  if (res < 0) res += PI * 2;
  return res;
}
inline bool eq(const Point &p, const Point &q) { return abs(p - q) < EPS; }
inline bool operator<(const Point &p, const Point &q) {
  return (abs(p.x - q.x) > EPS ? p.x < q.x : p.y < q.y);
}
inline bool operator>(const Point &p, const Point &q) {
  return (abs(p.x - q.x) > EPS ? p.x > q.x : p.y > q.y);
}
inline Point operator/(const Point &p, const Point &q) {
  return p * conj(q) / norm(q);
}
struct Line : vector<Point> {
  Line(Point a = Point(0.0, 0.0), Point b = Point(0.0, 0.0)) {
    this->push_back(a);
    this->push_back(b);
  }
  friend ostream &operator<<(ostream &s, const Line &l) {
    return s << '{' << l[0] << ", " << l[1] << '}';
  }
};
int ccw_for_dis(const Point &a, const Point &b, const Point &c) {
  if (cross(b - a, c - a) > EPS) return 1;
  if (cross(b - a, c - a) < -EPS) return -1;
  if (dot(b - a, c - a) < -EPS) return 2;
  if (norm(b - a) < norm(c - a) - EPS) return -2;
  return 0;
}
Point proj(const Point &p, const Line &l) {
  DD t = dot(p - l[0], l[1] - l[0]) / norm(l[1] - l[0]);
  return l[0] + (l[1] - l[0]) * t;
}
Point refl(const Point &p, const Line &l) { return p + (proj(p, l) - p) * 2; }
bool isinterPL(const Point &p, const Line &l) {
  return (abs(p - proj(p, l)) < EPS);
}
bool isinterPS(const Point &p, const Line &s) {
  return (ccw_for_dis(s[0], s[1], p) == 0);
}
bool isinterLL(const Line &l, const Line &m) {
  return (abs(cross(l[1] - l[0], m[1] - m[0])) > EPS ||
          abs(cross(l[1] - l[0], m[0] - l[0])) < EPS);
}
bool isinterSS(const Line &s, const Line &t) {
  if (eq(s[0], s[1])) return isinterPS(s[0], t);
  if (eq(t[0], t[1])) return isinterPS(t[0], s);
  return (ccw_for_dis(s[0], s[1], t[0]) * ccw_for_dis(s[0], s[1], t[1]) <= 0 &&
          ccw_for_dis(t[0], t[1], s[0]) * ccw_for_dis(t[0], t[1], s[1]) <= 0);
}
DD distancePL(const Point &p, const Line &l) { return abs(p - proj(p, l)); }
DD distancePS(const Point &p, const Line &s) {
  Point h = proj(p, s);
  if (isinterPS(h, s)) return abs(p - h);
  return min(abs(p - s[0]), abs(p - s[1]));
}
DD distanceLL(const Line &l, const Line &m) {
  if (isinterLL(l, m))
    return 0;
  else
    return distancePL(m[0], l);
}
DD distanceSS(const Line &s, const Line &t) {
  if (isinterSS(s, t))
    return 0;
  else
    return min(min(distancePS(s[0], t), distancePS(s[1], t)),
               min(distancePS(t[0], s), distancePS(t[1], s)));
}
DD dp[110][110] = {0};
int main() {
  int N, s, t;
  while (cin >> N >> s >> t, N) {
    --s, --t;
    vector<vector<Point> > stars(N, vector<Point>(5));
    for (int i = 0; i < N; ++i) {
      double x, y, a, r;
      cin >> x >> y >> a >> r;
      for (int dir = 0; dir < 5; ++dir) {
        double ang = torad(a + 90 + dir * 72);
        stars[i][dir] = Point(x + r * cos(ang), y + r * sin(ang));
      }
    }
    for (int i = 0; i < N; ++i) {
      for (int j = 0; j < N; ++j) {
        double dist = INF;
        for (int di = 0; di < 5; ++di) {
          for (int dj = 0; dj < 5; ++dj) {
            Line si(stars[i][di], stars[i][(di + 2) % 5]);
            Line sj(stars[j][dj], stars[j][(dj + 2) % 5]);
            double tmp = distanceSS(si, sj);
            dist = min(dist, tmp);
          }
        }
        dp[i][j] = dist;
      }
    }
    for (int k = 0; k < N; ++k)
      for (int i = 0; i < N; ++i)
        for (int j = 0; j < N; ++j)
          dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
    cout << fixed << setprecision(10) << dp[s][t] << endl;
  }
}
