#include <bits/stdc++.h>
using namespace std;
inline long long labs(long long a) { return a < 0 ? (-a) : a; }
template <typename T>
inline T sqr(T x) {
  return x * x;
}
template <typename T>
struct Point {
  T x, y;
  Point() {}
  Point(T xx, T yy) : x(xx), y(yy) {}
  friend istream &operator>>(istream &is, Point &p) { return is >> p.x >> p.y; }
};
template <typename T>
bool operator<(const Point<T> &p1, const Point<T> &p2) {
  return p1.x < p2.x || p1.x == p2.x && p1.y < p2.y;
}
template <typename T>
Point<T> operator-(const Point<T> &p1, const Point<T> &p2) {
  return Point<T>(p1.x - p2.x, p1.y - p2.y);
}
template <typename T>
Point<T> operator+(const Point<T> &p1, const Point<T> &p2) {
  return Point<T>(p1.x + p2.x, p1.y + p2.y);
}
template <typename T>
T operator^(const Point<T> &p1, const Point<T> &p2) {
  return p1.x * p2.y - p2.x * p1.y;
}
template <typename T>
T operator*(const Point<T> &p1, const Point<T> &p2) {
  return p1.x * p2.x + p1.y * p2.y;
}
template <typename T>
Point<T> operator*(const T &k, const Point<T> &p) {
  return Point<T>(k * p.x, k * p.y);
}
template <typename T>
double abs(const Point<T> &p) {
  return sqrt((double)p.x * p.x + (double)p.y * p.y);
}
Point<double> turnCW(const Point<double> &p, double sina, double cosa) {
  return Point<double>(p.x * cosa + p.y * sina, -p.x * sina + p.y * cosa);
}
Point<double> turnCCW(const Point<double> &p, double sina, double cosa) {
  return Point<double>(p.x * cosa - p.y * sina, p.x * sina + p.y * cosa);
}
template <typename T>
Point<double> norm(const Point<T> &p) {
  return (1.0 / abs(p)) * Point<double>(p);
}
template <typename T>
struct Circle {
  T r;
  Point<T> c;
  Circle() {}
  Circle(Point<T> cc, T rr) : c(cc), r(rr) {}
};
const double EPS = 1e-9;
void GetIntersection(const Point<double> &p, const Point<double> &v,
                     const Circle<double> &c, vector<Point<double> > &res) {
  res.clear();
  double A = v * v;
  double B = v * (p - c.c);
  double C = (p - c.c) * (p - c.c) - c.r * c.r;
  double D = B * B - A * C;
  if (D < 0) {
    return;
  }
  double k1 = (-B - sqrt(D)) / A;
  double k2 = (-B + sqrt(D)) / A;
  res.push_back(p + k1 * v);
  if (fabs(k1 - k2) > EPS) {
    res.push_back(p + k2 * v);
  }
}
Point<double> p;
double omg, alpha, rp;
double v, r;
vector<Point<double> > tv;
Circle<double> ccc;
bool F(double t) {
  double a = alpha + omg * t;
  Point<double> g(cos(a) * rp, sin(a) * rp);
  GetIntersection(p, g - p, ccc, tv);
  double d;
  if (tv.size() > 1 && abs(p - g) > abs(tv[0] - p)) {
    double d0 = abs(p - g);
    double d1 = abs(g);
    double d2 = abs(p);
    double a1 = acos(r / d1);
    double a2 = acos(r / d2);
    double a = acos((sqr(d1) + sqr(d2) - sqr(d0)) / (2 * d1 * d2));
    d = sqrt(sqr(d1) - sqr(r)) + sqrt(sqr(d2) - sqr(r)) + r * (a - a1 - a2);
  } else {
    d = abs(g - p);
  }
  return t * v >= d;
}
double BinarySearch(double l, double r, double eps) {
  while (r - l > eps) {
    double m = (l + r) / 2;
    if (!F(m)) {
      l = m;
    } else {
      r = m;
    }
  }
  return (l + r) / 2;
}
int main() {
  double vp;
  Point<double> pp;
  cin >> pp.x >> pp.y >> vp;
  cin >> p.x >> p.y >> v >> r;
  rp = abs(pp);
  alpha = atan2(pp.y, pp.x);
  omg = vp / rp;
  ccc = Circle<double>(Point<double>(0, 0), r);
  printf("%.9f\n", BinarySearch(0, 1e9, 1e-9));
  return 0;
}
