#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
enum STATE { IN, OUT, BOUNDRY };
complex<long double> operator*(long double r, complex<long double> p1) {
  return complex<long double>(p1.real() * r, p1.imag() * r);
}
bool intersect(const complex<long double>& a, const complex<long double>& b,
               const complex<long double>& p, const complex<long double>& q,
               complex<long double>& ret) {
  long double d1 = ((conj(p - a) * (b - a)).imag());
  long double d2 = ((conj(q - a) * (b - a)).imag());
  ret = (d1 * q - d2 * p) / (d1 - d2);
  if (fabs(d1 - d2) > 1e-8) return 1;
  return 0;
}
bool pointOnLine(const complex<long double>& a, const complex<long double>& b,
                 const complex<long double>& p) {
  return fabs(((conj(((b) - (a))) * (((p) - (a)))).imag())) < 1e-8;
}
bool pointOnRay(const complex<long double>& a, const complex<long double>& b,
                const complex<long double>& p) {
  return ((conj(((p) - (a))) * (((b) - (a)))).real()) > -1e-8;
}
bool pointOnSegment(const complex<long double>& a,
                    const complex<long double>& b,
                    const complex<long double>& p) {
  if (!pointOnLine(a, b, p)) return 0;
  return pointOnRay(a, b, p) && pointOnRay(b, a, p);
}
long double pointLineDist(const complex<long double>& a,
                          const complex<long double>& b,
                          const complex<long double>& p) {
  return fabs(((conj(((b) - (a))) * (((p) - (a)))).imag()) /
              ((long double)hypot((((b) - (a))).imag(), (((b) - (a))).real())));
}
long double pointSegmentDist(const complex<long double>& a,
                             const complex<long double>& b,
                             const complex<long double>& p) {
  if (((conj(((b) - (a))) * (((p) - (a)))).real()) < 1e-8)
    return ((long double)hypot((((p) - (a))).imag(), (((p) - (a))).real()));
  if (((conj(((a) - (b))) * (((p) - (b)))).real()) < 1e-8)
    return ((long double)hypot((((p) - (b))).imag(), (((p) - (b))).real()));
  return pointLineDist(a, b, p);
}
long double triangleAreaBH(long double b, long double h) { return b * h / 2; }
long double triangleArea2sidesAngle(long double a, long double b,
                                    long double t) {
  return fabs(a * b * sin(t) / 2);
}
long double triangleArea2anglesSide(long double t1, long double t2,
                                    long double s) {
  return fabs(s * s * sin(t1) * sin(t2) / (2 * sin(t1 + t2)));
}
long double triangleArea3sides(long double a, long double b, long double c) {
  long double s((a + b + c) / 2);
  return sqrt(s * (s - a) * (s - b) * (s - c));
}
long double triangleArea3points(const complex<long double>& a,
                                const complex<long double>& b,
                                const complex<long double>& c) {
  return fabs(((conj(a) * (b)).imag()) + ((conj(b) * (c)).imag()) +
              ((conj(c) * (a)).imag())) /
         2;
}
int picksTheorm(int a, int b) { return a - b / 2 + 1; }
long double cosRule(long double a, long double b, long double c) {
  long double res = (b * b + c * c - a * a) / (2 * b * c);
  if (fabs(res - 1) < 1e-8) res = 1;
  if (fabs(res + 1) < 1e-8) res = -1;
  return acos(res);
}
long double sinRuleAngle(long double s1, long double s2, long double a1) {
  long double res = s2 * sin(a1) / s1;
  if (fabs(res - 1) < 1e-8) res = 1;
  if (fabs(res + 1) < 1e-8) res = -1;
  return asin(res);
}
long double sinRuleSide(long double s1, long double a1, long double a2) {
  long double res = s1 * sin(a2) / sin(a1);
  return fabs(res);
}
int circleLineIntersection(const complex<long double>& p0,
                           const complex<long double>& p1,
                           const complex<long double>& cen, long double rad,
                           complex<long double>& r1, complex<long double>& r2) {
  long double a, b, c, t1, t2;
  a = ((conj(p1 - p0) * (p1 - p0)).real());
  b = 2 * ((conj(p1 - p0) * (p0 - cen)).real());
  c = ((conj(p0 - cen) * (p0 - cen)).real()) - rad * rad;
  double det = b * b - 4 * a * c;
  int res;
  if (fabs(det) < 1e-8)
    det = 0, res = 1;
  else if (det < 0)
    res = 0;
  else
    res = 2;
  det = sqrt(det);
  t1 = (-b + det) / (2 * a);
  t2 = (-b - det) / (2 * a);
  r1 = p0 + t1 * (p1 - p0);
  r2 = p0 + t2 * (p1 - p0);
  return res;
}
int circleCircleIntersection(const complex<long double>& c1,
                             const long double& r1,
                             const complex<long double>& c2,
                             const long double& r2, complex<long double>& res1,
                             complex<long double>& res2) {
  if (((((conj(((c2) - (c1))) * (((c2) - (c1)))).real())) < 1e-8) &&
      fabs(r1 - r2) < 1e-8) {
    res1 = res2 = c1;
    return fabs(r1) < 1e-8 ? 1 : 1e9;
  }
  long double len =
      ((long double)hypot((((c2) - (c1))).imag(), (((c2) - (c1))).real()));
  if (fabs(len - (r1 + r2)) < 1e-8 || fabs(fabs(r1 - r2) - len) < 1e-8) {
    complex<long double> d, c;
    long double r;
    if (r1 > r2)
      d = ((c2) - (c1)), c = c1, r = r1;
    else
      d = ((c1) - (c2)), c = c2, r = r2;
    res1 = res2 = ((d) / ((long double)hypot((d).imag(), (d).real()))) * r + c;
    return 1;
  }
  if (len > r1 + r2 || len < fabs(r1 - r2)) return 0;
  double a = cosRule(r2, r1, len);
  complex<long double> c1c2 =
      ((((c2) - (c1))) /
       ((long double)hypot((((c2) - (c1))).imag(), (((c2) - (c1))).real()))) *
      r1;
  res1 = (((c1c2)*exp(complex<long double>(0, (a))))) + c1;
  res2 = (((c1c2)*exp(complex<long double>(0, (-a))))) + c1;
  return 2;
}
void circle2(const complex<long double>& p1, const complex<long double>& p2,
             complex<long double>& cen, long double& r) {
  cen = (((p1) + (p2)) / complex<long double>(2, 0));
  r = ((long double)hypot((((p2) - (p1))).imag(), (((p2) - (p1))).real())) / 2;
}
bool circle3(const complex<long double>& p1, const complex<long double>& p2,
             const complex<long double>& p3, complex<long double>& cen,
             long double& r) {
  complex<long double> m1 = (((p1) + (p2)) / complex<long double>(2, 0));
  complex<long double> m2 = (((p2) + (p3)) / complex<long double>(2, 0));
  complex<long double> perp1 =
      (complex<long double>(-(((p2) - (p1))).imag(), (((p2) - (p1))).real()));
  complex<long double> perp2 =
      (complex<long double>(-(((p3) - (p2))).imag(), (((p3) - (p2))).real()));
  bool res = intersect(m1, m1 + perp1, m2, m2 + perp2, cen);
  r = ((long double)hypot((((p1) - (cen))).imag(), (((p1) - (cen))).real()));
  return res;
}
STATE circlePoint(const complex<long double>& cen, const long double& r,
                  const complex<long double>& p) {
  long double lensqr = (((conj(((p) - (cen))) * (((p) - (cen)))).real()));
  if (fabs(lensqr - r * r) < 1e-8) return BOUNDRY;
  if (lensqr < r * r) return IN;
  return OUT;
}
int tangentPoints(const complex<long double>& cen, const long double& r,
                  const complex<long double>& p, complex<long double>& r1,
                  complex<long double>& r2) {
  STATE s = circlePoint(cen, r, p);
  if (s != OUT) {
    r1 = r2 = p;
    return s == BOUNDRY;
  }
  complex<long double> cp = ((p) - (cen));
  long double h = ((long double)hypot((cp).imag(), (cp).real()));
  long double a = acos(r / h);
  cp = r * ((cp) / ((long double)hypot((cp).imag(), (cp).real())));
  r1 = (((cp)*exp(complex<long double>(0, (a))))) + cen;
  r2 = (((cp)*exp(complex<long double>(0, (-a))))) + cen;
  return 2;
}
void getCommonTangents(
    complex<long double> c1, long double r1, complex<long double> c2,
    long double r2,
    vector<pair<complex<long double>, complex<long double> > >& res) {
  if (r1 < r2) swap(r1, r2), swap(c1, c2);
  long double d = ((long double)hypot((c1 - c2).imag(), (c1 - c2).real()));
  long double theta = acos((r1 - r2) / d);
  complex<long double> v = c2 - c1;
  v = v / (long double)hypot(v.imag(), v.real());
  complex<long double> v1 = v * exp(complex<long double>(0, theta));
  complex<long double> v2 = v * exp(complex<long double>(0, -theta));
  res.clear();
  res.push_back(pair<complex<long double>, complex<long double> >(
      c1 + v1 * r1, c2 + v1 * r2));
  res.push_back(pair<complex<long double>, complex<long double> >(
      c1 + v2 * r1, c2 + v2 * r2));
  theta = acos((r1 + r2) / d);
  v1 = v * exp(complex<long double>(0, theta));
  v2 = v * exp(complex<long double>(0, -theta));
  res.push_back(pair<complex<long double>, complex<long double> >(
      c1 + v1 * r1, c2 - v1 * r2));
  res.push_back(pair<complex<long double>, complex<long double> >(
      c1 + v2 * r1, c2 - v2 * r2));
}
complex<long double> p[100000], r[3], cen;
int ps, rs;
long double rad;
void mec() {
  if (rs == 3) {
    circle3(r[0], r[1], r[2], cen, rad);
    return;
  }
  if (rs == 2 && ps == 0) {
    circle2(r[0], r[1], cen, rad);
    return;
  }
  if (!ps) {
    cen = r[0];
    rad = 0;
    return;
  }
  ps--;
  mec();
  if (circlePoint(cen, rad, p[ps]) == OUT) {
    r[rs++] = p[ps];
    mec();
    rs--;
  }
  ps++;
}
long double polygonArea(const vector<complex<long double> >& p) {
  long double res = 0;
  for (int i = 0; i < ((int)(p).size()); i++) {
    int j = (i + 1) % ((int)(p).size());
    res += ((conj(p[i]) * (p[j])).imag());
  }
  return fabs(res) / 2;
}
complex<long double> polyginCentroid(vector<complex<long double> >& polygon) {
  long double a = 0;
  long double x = 0.0, y = 0.0;
  for (int i = 0; i < (int)polygon.size(); i++) {
    int j = (i + 1) % polygon.size();
    x += (polygon[i].real() + polygon[j].real()) *
         (polygon[i].real() * polygon[j].imag() -
          polygon[j].real() * polygon[i].imag());
    y += (polygon[i].imag() + polygon[j].imag()) *
         (polygon[i].real() * polygon[j].imag() -
          polygon[j].real() * polygon[i].imag());
    a += polygon[i].real() * polygon[j].imag() -
         polygon[i].imag() * polygon[j].real();
  }
  a *= 0.5;
  x /= 6 * a;
  y /= 6 * a;
  return complex<long double>(x, y);
}
STATE pointInPolygon(const vector<complex<long double> >& p,
                     const complex<long double>& pnt) {
  complex<long double> p2 = pnt + complex<long double>(1, 0);
  int cnt = 0;
  for (int i = 0; i < ((int)(p).size()); i++) {
    int j = (i + 1) % ((int)(p).size());
    if (pointOnSegment(p[i], p[j], pnt)) return BOUNDRY;
    complex<long double> r;
    if (!intersect(pnt, p2, p[i], p[j], r)) continue;
    if (!pointOnRay(pnt, p2, r)) continue;
    if (((((conj(((p[i]) - (r))) * (((p[i]) - (r)))).real())) < 1e-8) ||
        ((((conj(((p[j]) - (r))) * (((p[j]) - (r)))).real())) < 1e-8))
      if (fabs(r.imag() - min(p[i].imag(), p[j].imag())) < 1e-8) continue;
    if (!pointOnSegment(p[i], p[j], r)) continue;
    cnt++;
  }
  return cnt & 1 ? IN : OUT;
}
struct cmp {
  complex<long double> about;
  cmp(complex<long double> c) { about = c; }
  bool operator()(const complex<long double>& p,
                  const complex<long double>& q) const {
    double cr = ((conj(((p) - (about))) * (((q) - (about)))).imag());
    if (fabs(cr) < 1e-8)
      return make_pair(p.imag(), p.real()) < make_pair(q.imag(), q.real());
    return cr > 0;
  }
};
long double arclength(const complex<long double>& p1,
                      const complex<long double>& p2,
                      const complex<long double>& cen, double rad) {
  long double an = fabs((atan2((p1 - cen).imag(), (p1 - cen).real())) -
                        (atan2((p2 - cen).imag(), (p2 - cen).real())));
  an = min(an, pi + pi - an);
  return an * rad;
}
int main() {
  double x, y, r1, r2, v1, v2;
  cin >> x >> y;
  complex<long double> p1(x, y);
  r1 = ((long double)hypot((p1).imag(), (p1).real()));
  cin >> v1;
  cin >> x >> y;
  complex<long double> p2(x, y);
  cin >> v2;
  cin >> r2;
  long double l = 0, r = 1e9 + 9, mid;
  for (int i = 0; i < 100; ++i) {
    mid = (l + r) / 2;
    bool is = true;
    complex<long double> rotated =
        (((p1)*exp(complex<long double>(0, (v1 / r1 * mid)))));
    complex<long double> t1, t2;
    int inter = circleLineIntersection(rotated, p2, complex<long double>(0, 0),
                                       r2, t1, t2);
    if (inter == 2 && !pointOnSegment(p2, rotated, t2)) --inter;
    if (inter >= 1 && !pointOnSegment(p2, rotated, t1)) --inter;
    if (inter < 2) {
      double dis =
          ((long double)hypot((rotated - p2).imag(), (rotated - p2).real()));
      if (dis / v2 - 1e-8 > mid) is = false;
    } else {
      complex<long double> tanf1, tans1, tanf2, tans2;
      tangentPoints(complex<long double>(0, 0), r2, p2, tanf1, tans1);
      tangentPoints(complex<long double>(0, 0), r2, rotated, tanf2, tans2);
      long double dis =
          min(((long double)hypot((tanf1 - p2).imag(), (tanf1 - p2).real())) +
                  ((long double)hypot((tanf2 - rotated).imag(),
                                      (tanf2 - rotated).real())) +
                  arclength(tanf1, tanf2, complex<long double>(0, 0), r2),
              ((long double)hypot((tanf1 - p2).imag(), (tanf1 - p2).real())) +
                  ((long double)hypot((tans2 - rotated).imag(),
                                      (tans2 - rotated).real())) +
                  arclength(tanf1, tans2, complex<long double>(0, 0), r2));
      dis = min(dis,
                ((long double)hypot((tans1 - p2).imag(), (tans1 - p2).real())) +
                    ((long double)hypot((tanf2 - rotated).imag(),
                                        (tanf2 - rotated).real())) +
                    arclength(tans1, tanf2, complex<long double>(0, 0), r2));
      dis = min(dis,
                ((long double)hypot((tans1 - p2).imag(), (tans1 - p2).real())) +
                    ((long double)hypot((tans2 - rotated).imag(),
                                        (tans2 - rotated).real())) +
                    arclength(tans1, tans2, complex<long double>(0, 0), r2));
      if (dis / v2 - 1e-8 > mid) is = false;
    }
    if (is)
      r = mid;
    else
      l = mid;
  }
  cout << fixed << setprecision(6) << mid << endl;
}
