Problem: Qwerty the Ranger arrived to the Diatar system with a very important task. He should deliver a special carcinogen for scientific research to planet Persephone. This is urgent, so Qwerty has to get to the planet as soon as possible. A lost day may fail negotiations as nobody is going to pay for an overdue carcinogen.

You can consider Qwerty's ship, the planet Persephone and the star Diatar points on a plane. Diatar is located in the origin of coordinate axes — at point (0, 0). Persephone goes round Diatar along a circular orbit with radius R in the counter-clockwise direction at constant linear speed vp (thus, for instance, a full circle around the star takes <image> of time). At the initial moment of time Persephone is located at point (xp, yp).

At the initial moment of time Qwerty's ship is at point (x, y). Qwerty can move in any direction at speed of at most v (v > vp). The star Diatar is hot (as all stars), so Qwerty can't get too close to it. The ship's metal sheathing melts at distance r (r < R) from the star.

Find the minimum time Qwerty needs to get the carcinogen to planet Persephone.

Input

The first line contains space-separated integers xp, yp and vp ( - 104 ≤ xp, yp ≤ 104, 1 ≤ vp < 104) — Persephone's initial position and the speed at which it goes round Diatar.

The second line contains space-separated integers x, y, v and r ( - 104 ≤ x, y ≤ 104, 1 < v ≤ 104, 1 ≤ r ≤ 104) — The intial position of Qwerty's ship, its maximum speed and the minimum safe distance to star Diatar.

It is guaranteed that r2 < x2 + y2, r2 < xp2 + yp2 and vp < v.

Output

Print a single real number — the minimum possible delivery time. The answer will be considered valid if its absolute or relative error does not exceed 10 - 6.

Examples

Input

10 0 1
-10 0 2 8


Output

9.584544103

Input

50 60 10
50 60 20 40


Output

0.000000000

Solution (in CPP):

Solution:
#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;
}