#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double MAXD = 1000000000;
struct xy {
  double x, y;
  xy(double xi, double yi) : x(xi), y(yi) {}
  xy() : x(0), y(0) {}
  double norm() const { return x * x + y * y; }
};
inline xy operator+(const xy &a, const xy &b) {
  return xy(a.x + b.x, a.y + b.y);
}
inline xy operator-(const xy &a, const xy &b) {
  return xy(a.x - b.x, a.y - b.y);
}
inline xy operator*(const xy &a, double f) { return xy(a.x * f, a.y * f); }
inline xy operator/(const xy &a, double f) { return xy(a.x / f, a.y / f); }
inline xy cross(const xy &a) { return xy(-a.y, a.x); }
inline double operator*(const xy &a, const xy &b) {
  return a.x * b.x + a.y * b.y;
}
inline double det(const xy &a, const xy &b) { return a.x * b.y - b.x * a.y; }
double angle(const xy &a, const xy &b) { return atan2(det(a, b), a * b); }
xy rot(const xy &a, double phi) { return a * cos(phi) + cross(a) * sin(phi); }
double dist(const xy &a, const xy &b) { return sqrt((b - a).norm()); }
struct circle {
  xy c;
  double r;
  circle(const xy &ci, double ri = 0) : c(ci), r(ri) {}
  circle() : c(xy(0, 0)), r(0) {}
  double length() const { return 2 * M_PI * r; }
  double area() const { return M_PI * r * r; }
};
struct line {
  xy n;
  double c;
  line(const xy &ni, double ci) : n(ni), c(ci) {}
  line() : n(xy(0, 0)), c(0) {}
};
bool on_line(const xy &a, const line &p) { return fabs(p.n * a - p.c) < EPS; }
line span(const xy &a, const xy &b) { return line(cross(b - a), det(b, a)); }
line median(const xy &a, const xy &b) {
  return line(b - a, (b - a) * (b + a) * 0.5);
}
xy intersection(const line &p, const line &q) {
  double d = det(p.n, q.n);
  if (fabs(d) < EPS) throw "rownolegle";
  return cross(p.n * q.c - q.n * p.c) / d;
}
line parallel(const xy &a, const line &p) { return line(p.n, p.n * a); }
line perp(const xy &a, const line &p) { return line(cross(p.n), det(p.n, a)); }
double dist(const xy &a, const line &p) {
  return fabs(p.n * a - p.c) / sqrt(p.n.norm());
}
bool on_circle(const xy &a, const circle &c) {
  return fabs((a - c.c).norm() - c.r * c.r) < EPS;
}
bool operator<(const circle &a, const circle &b) {
  return b.r + EPS > a.r &&
         (a.c - b.c).norm() < (b.r - a.r) * (b.r - a.r) + EPS;
}
circle circumcircle(xy a, xy b, xy c) {
  if ((a - b).norm() > (c - b).norm()) swap(a, c);
  if ((b - c).norm() > (a - c).norm()) swap(a, b);
  if (fabs(det(b - a, c - b)) < EPS) throw "zdegenerowany";
  xy v = intersection(median(a, b), median(b, c));
  return circle(v, sqrt((a - v).norm()));
}
int intersection(const circle &c, const line &p, xy I[]) {
  double d = p.n.norm(), a = (p.n * c.c - p.c) / d;
  xy u = c.c - p.n * a;
  a *= a;
  double r = c.r * c.r / d;
  if (a >= r + EPS) return 0;
  if (a > r - EPS) {
    I[0] = u;
    return 1;
  }
  double h = sqrt(r - a);
  I[0] = u + cross(p.n) * h;
  I[1] = u - cross(p.n) * h;
  return 2;
}
struct segment {
  xy a, b;
  segment() : a(), b() {}
  segment(xy ai, xy bi) : a(ai), b(bi) {}
};
bool on_segment(const xy &p, const segment &s) {
  return min(s.a.x, s.b.x) < p.x + EPS && p.x < max(s.a.x, s.b.x) + EPS &&
         min(s.a.y, s.b.y) < p.y + EPS && p.y < max(s.a.y, s.b.y) + EPS;
}
bool intersect(const segment &s1, const segment &s2) {
  double d1 = det(s2.b - s2.a, s1.a - s2.a), d2 = det(s2.b - s2.a, s1.b - s2.a),
         d3 = det(s1.b - s1.a, s2.a - s1.a), d4 = det(s1.b - s1.a, s2.b - s1.a);
  return (((d1 >= EPS && d2 <= -EPS) || (d1 <= -EPS && d2 >= EPS)) &&
          ((d3 >= EPS && d4 <= -EPS) || (d3 <= -EPS && d4 >= EPS))) ||
         (fabs(d1) < EPS && on_segment(s1.a, s2)) ||
         (fabs(d2) < EPS && on_segment(s1.b, s2)) ||
         (fabs(d3) < EPS && on_segment(s2.a, s1)) ||
         (fabs(d4) < EPS && on_segment(s2.b, s1));
}
xy p, s;
double sv, pv, r, R = 1;
pair<double, double> styczne(xy p) {
  double a = angle(xy(1, 0), p);
  double da = M_PI / 2 - asin(r / dist(p, xy(0, 0)));
  return pair<double, double>(a - da, a + da);
}
double mod(double a, double b) {
  int div = static_cast<int>(a / b);
  return a - static_cast<double>(div) * b;
}
double getDa(double a1, double a2) {
  if (a1 < 0) a1 += 2 * M_PI;
  if (a2 < 0) a2 += 2 * M_PI;
  return mod((a1 + 2 * M_PI - a2), 2 * M_PI);
}
double getDist(xy f, double a1, double a2, xy t) {
  xy cp = xy(r, 0);
  double da = min(getDa(a1, a2), getDa(a2, a1));
  return dist(f, rot(cp, a1)) + r * da + dist(rot(cp, a2), t);
}
bool check(double t) {
  double omega = pv / R;
  xy pt = rot(p, omega * t);
  double d;
  xy pts[3];
  int cnt = intersection(circle(xy(0, 0), r), span(s, pt), pts);
  bool close = true;
  for (int i = 0; i < (cnt); ++i)
    if (on_segment(pts[i], segment(s, pt))) close = false;
  if (close) {
    d = dist(s, pt);
  } else {
    pair<double, double> pa = styczne(pt);
    pair<double, double> sa = styczne(s);
    d = min(min(getDist(s, sa.first, pa.first, pt),
                getDist(s, sa.first, pa.second, pt)),
            min(getDist(s, sa.second, pa.first, pt),
                getDist(s, sa.second, pa.second, pt)));
  }
  return d <= t * sv;
}
int main() {
  cin >> p.x >> p.y >> pv;
  cin >> s.x >> s.y >> sv >> r;
  R = dist(p, xy(0, 0));
  double low = 0, high = MAXD;
  while (high - low > EPS) {
    double mid = (low + high) / 2;
    if (check(mid))
      high = mid;
    else
      low = mid;
  }
  cout.precision(6);
  cout << fixed << high << endl;
  return 0;
}
