A team of furry rescue rangers was sitting idle in their hollow tree when suddenly they received a signal of distress. In a few moments they were ready, and the dirigible of the rescue chipmunks hit the road.

We assume that the action takes place on a Cartesian plane. The headquarters of the rescuers is located at point (x1, y1), and the distress signal came from the point (x2, y2).

Due to Gadget's engineering talent, the rescuers' dirigible can instantly change its current velocity and direction of movement at any moment and as many times as needed. The only limitation is: the speed of the aircraft relative to the air can not exceed <image> meters per second.

Of course, Gadget is a true rescuer and wants to reach the destination as soon as possible. The matter is complicated by the fact that the wind is blowing in the air and it affects the movement of the dirigible. According to the weather forecast, the wind will be defined by the vector (vx, vy) for the nearest t seconds, and then will change to (wx, wy). These vectors give both the direction and velocity of the wind. Formally, if a dirigible is located at the point (x, y), while its own velocity relative to the air is equal to zero and the wind (ux, uy) is blowing, then after <image> seconds the new position of the dirigible will be <image>.

Gadget is busy piloting the aircraft, so she asked Chip to calculate how long will it take them to reach the destination if they fly optimally. He coped with the task easily, but Dale is convinced that Chip has given the random value, aiming only not to lose the face in front of Gadget. Dale has asked you to find the right answer.

It is guaranteed that the speed of the wind at any moment of time is strictly less than the maximum possible speed of the airship relative to the air.

Input

The first line of the input contains four integers x1, y1, x2, y2 (|x1|, |y1|, |x2|, |y2| ≤ 10 000) — the coordinates of the rescuers' headquarters and the point, where signal of the distress came from, respectively. 

The second line contains two integers <image> and t (0 < v, t ≤ 1000), which are denoting the maximum speed of the chipmunk dirigible relative to the air and the moment of time when the wind changes according to the weather forecast, respectively. 

Next follow one per line two pairs of integer (vx, vy) and (wx, wy), describing the wind for the first t seconds and the wind that will blow at all the remaining time, respectively. It is guaranteed that <image> and <image>.

Output

Print a single real value — the minimum time the rescuers need to get to point (x2, y2). You answer will be considered correct if its absolute or relative error does not exceed 10 - 6. 

Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.

Examples

Input

0 0 5 5
3 2
-1 -1
-1 0


Output

3.729935587093555327


Input

0 0 0 1000
100 1000
-50 0
50 0


Output

11.547005383792516398
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
template <class T>
using vec = vector<T>;
template <class T>
using vvec = vector<vector<T>>;
constexpr char ln = '\n';
template <class Container>
inline int SZ(const Container& v) {
  return int(v.size());
}
template <class T>
inline void UNIQUE(vector<T>& v) {
  v.erase(unique(v.begin(), v.end()), v.end());
}
template <class T1, class T2>
inline bool chmax(T1& a, T2 b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class T1, class T2>
inline bool chmin(T1& a, T2 b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
inline int topbit(ull x) { return x == 0 ? -1 : 63 - __builtin_clzll(x); }
inline int botbit(ull x) { return x == 0 ? 64 : __builtin_ctzll(x); }
inline int popcount(ull x) { return __builtin_popcountll(x); }
inline int kthbit(ull x, int k) { return (x >> k) & 1; }
inline constexpr long long TEN(int x) { return x == 0 ? 1 : TEN(x - 1) * 10; }
const string YESNO[2] = {"NO", "YES"};
const string YesNo[2] = {"No", "Yes"};
inline void YES(bool t = true) { cout << YESNO[t] << "\n"; }
inline void Yes(bool t = true) { cout << YesNo[t] << "\n"; }
template <class T>
inline void drop(T x) {
  cout << x << "\n";
  exit(0);
}
inline void print() { cout << "\n"; }
template <class T>
inline void print(const vector<T>& v) {
  for (auto it = v.begin(); it != v.end(); ++it) {
    if (it != v.begin()) {
      cout << " ";
    }
    cout << *it;
  }
  print();
}
template <class T, class... Args>
inline void print(const T& x, const Args&... args) {
  cout << x << " ";
  print(args...);
}
struct fast_ios {
  fast_ios() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(20);
    cerr << fixed << setprecision(7);
  };
} fast_ios_;
using DD = long double;
constexpr DD EPS = 1e-10;
const DD PI = acos(DD(-1));
inline int sgn(DD a) { return (a < -EPS) ? -1 : (a > EPS) ? 1 : 0; }
inline int sgn(DD a, DD b) { return sgn(a - b); }
struct Point {
  DD x, y;
  Point(DD x_ = DD(), DD y_ = DD()) : x(x_), y(y_) {}
  Point& operator+=(const Point& p) {
    x += p.x;
    y += p.y;
    return *this;
  }
  Point& operator-=(const Point& p) {
    x -= p.x;
    y -= p.y;
    return *this;
  }
  Point& operator*=(const Point& p) {
    DD u = x * p.x - y * p.y;
    DD v = x * p.y + y * p.x;
    x = u;
    y = v;
    return *this;
  }
  Point& operator*=(DD a) {
    x *= a;
    y *= a;
    return *this;
  }
  Point& operator/=(DD a) {
    x /= a;
    y /= a;
    return *this;
  }
  Point operator+(const Point& p) const { return Point(*this) += p; }
  Point operator-(const Point& p) const { return Point(*this) -= p; }
  Point operator*(const Point& p) const { return Point(*this) *= p; }
  Point operator*(DD a) const { return Point(*this) *= a; }
  Point operator/(DD a) const { return Point(*this) /= a; }
  bool operator==(const Point& p) const {
    return !sgn(x - p.x) && !sgn(y - p.y);
  }
  bool operator!=(const Point& p) const { return sgn(x - p.x) || sgn(y - p.y); }
  bool operator<(const Point& p) const {
    if (sgn(x - p.x)) return sgn(x - p.x) < 0;
    return sgn(y - p.y) < 0;
  }
  friend istream& operator>>(istream& is, Point& p) {
    is >> p.x >> p.y;
    return is;
  }
  friend ostream& operator<<(ostream& os, const Point& p) {
    os << p.x << " " << p.y;
    return os;
  }
  DD norm() { return x * x + y * y; }
  DD abs() { return sqrt(norm()); }
  DD arg() { return atan2(y, x); }
};
using Vector = Point;
inline DD norm(const Vector& a) { return a.x * a.x + a.y * a.y; }
inline DD abs(const Vector& a) { return sqrt(norm(a)); }
inline DD dot(const Vector& a, const Vector& b) {
  return a.x * b.x + a.y * b.y;
}
inline DD cross(const Vector& a, const Vector& b) {
  return a.x * b.y - a.y * b.x;
}
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 arg(const Vector& p) { return atan2(p.y, p.x); }
inline Vector polar(DD a, DD r) { return Point(cos(r) * a, sin(r) * a); }
int ort(const Point& a) {
  if (sgn(norm(a))) {
    if (sgn(a.y) > 0) return sgn(a.x) > 0 ? 1 : 2;
    return sgn(a.x) > 0 ? 4 : 3;
  }
  return 0;
}
bool xsort(const Point& a, const Point& b) {
  if (sgn(a.x - b.x)) return sgn(a.x - b.x) < 0;
  return sgn(a.y - b.y) < 0;
}
bool ysort(const Point& a, const Point& b) {
  if (sgn(a.y - b.y)) return sgn(a.y - b.y) < 0;
  return sgn(a.x - b.x) < 0;
}
bool argsortcross(const Point& a, const Point& b) {
  int ao = ort(a), bo = ort(b);
  if (ao != bo) return ao < bo;
  return sgn(cross(a, b)) > 0;
}
bool argsortatan2(const Point& a, const Point& b) {
  return sgn(atan2(b.y, b.x) - atan2(a.y, a.x)) > 0;
}
struct Segment {
  Point p1, p2;
  Segment() {}
  Segment(const Point& p1_, const Point& p2_) : p1(p1_), p2(p2_) {}
};
using Line = Segment;
struct Circle {
  Point c;
  DD r;
  Circle() {}
  Circle(const Point& c_, DD r_) : c(c_), r(r_) {}
  friend istream& operator>>(istream& is, Circle& C) {
    is >> C.c >> C.r;
    return is;
  }
  friend ostream& operator<<(ostream& os, const Circle& C) {
    os << C.c << " " << C.r;
    return os;
  }
};
using Polygon = vector<Point>;
int ccw(const Point& p0, const Point& p1, const Point& p2) {
  Vector a = p1 - p0;
  Vector b = p2 - p0;
  if (sgn(cross(a, b)) > 0) return 1;
  if (sgn(cross(a, b)) < 0) return -1;
  if (sgn(dot(a, b)) < 0) return 2;
  if (sgn(norm(b) - norm(a)) > 0) return -2;
  return 0;
}
int intersectLP(const Vector& a, const Vector& b) {
  if (sgn(cross(a, b))) return 1;
  if (sgn(dot(a, b))) return 0;
  return -1;
}
int intersectLP(const Point& p1, const Point& p2, const Point& p3,
                const Point& p4) {
  return intersectLP(p2 - p1, p4 - p3);
}
int intersectLP(const Line& l1, const Line& l2) {
  return intersectLP(l1.p1, l1.p2, l2.p1, l2.p2);
}
bool isParallel(const Vector& a, Vector& b) { return intersectLP(a, b) <= 0; }
bool isParallel(const Point& p1, const Point& p2, const Point& p3,
                const Point& p4) {
  return intersectLP(p1, p2, p3, p4) <= 0;
}
bool isParallel(const Line& l1, const Line& l2) {
  return intersectLP(l1, l2) <= 0;
}
bool isOrthogonal(const Vector& a, const Vector& b) { return !sgn(dot(a, b)); }
bool isOrthogonal(const Point& p1, const Point& p2, const Point& p3,
                  const Point& p4) {
  return isOrthogonal(p2 - p1, p4 - p3);
}
bool isOrthogonal(const Line& l1, const Line& l2) {
  return isOrthogonal(l1.p1, l1.p2, l2.p1, l2.p2);
}
bool intersectSP(const Point& p1, const Point& p2, const Point& p3,
                 const Point& p4) {
  return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
          ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);
}
bool intersectSP(const Segment& s1, const Segment& s2) {
  return intersectSP(s1.p1, s1.p2, s2.p1, s2.p2);
}
bool intersectLSP(const Line& l, const Segment& s) {
  return ccw(l.p1, l.p2, s.p1) * ccw(l.p1, l.p2, s.p2) <= 0;
}
Point getCrossPointLP(const Line& l1, const Line& l2) {
  assert(intersectLP(l1, l2) == 1);
  return l1.p1 + (l1.p2 - l1.p1) * cross(l2.p1 - l1.p1, l2.p2 - l2.p1) /
                     cross(l1.p2 - l1.p1, l2.p2 - l2.p1);
}
Point getCrossPointSP(const Segment& s1, const Segment& s2) {
  assert(intersectSP(s1, s2));
  return getCrossPointLP(s1, s2);
}
Point project(const Segment& s, const Point& p) {
  Vector base = s.p2 - s.p1;
  DD r = dot(p - s.p1, base) / norm(base);
  return s.p1 + base * r;
}
Point reflect(const Segment& s, const Point& p) {
  return p + (project(s, p) - p) * 2;
}
DD getDistanceLP(const Line& l, const Point& p) {
  return abs(cross(l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}
DD getDistanceSP(const Segment& s, const Point& p) {
  if (sgn(dot(s.p2 - s.p1, p - s.p1)) < 0) return abs(p - s.p1);
  if (sgn(dot(s.p1 - s.p2, p - s.p2)) < 0) return abs(p - s.p2);
  return getDistanceLP(s, p);
}
DD getDistanceLP(const Line& l1, const Line& l2) {
  if (intersectLP(l1, l2)) return 0;
  return getDistanceLP(l1, l2.p1);
}
DD getDistanceLSP(const Line& l, const Segment& s) {
  if (intersectLSP(l, s)) return 0;
  return min(getDistanceLP(l, s.p1), getDistanceLP(l, s.p2));
}
DD getDistanceSP(const Segment& s1, const Segment& s2) {
  if (intersectSP(s1, s2)) return 0;
  return min({getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2),
              getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)});
}
bool intersectLP(const Circle& c, const Line& l) {
  return sgn(getDistanceLP(l, c.c) - c.r) <= 0;
}
bool intersectSP(const Circle& c, const Segment& s) {
  return sgn(getDistanceSP(s, c.c) - c.r) <= 0 &&
         sgn(max(abs(s.p1 - c.c), abs(s.p2 - c.c)) - c.r) >= 0;
}
int intersect(const Circle& c1, const Circle& c2) {
  if (sgn(abs(c1.c - c2.c) - (c1.r + c2.r)) > 0) return 4;
  if (!sgn(abs(c1.c - c2.c) - (c1.r + c2.r))) return 3;
  if (sgn(fabs(c1.r - c2.r) - abs(c1.c - c2.c)) > 0) return 0;
  if (!sgn(fabs(c1.r - c2.r) - abs(c1.c - c2.c))) return 1;
  return 2;
}
pair<Point, Point> getCrossPoints(const Circle& c, const Line& l) {
  assert(intersectLP(c, l));
  Vector pr = project(l, c.c);
  Vector e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
  DD base = sqrt(c.r * c.r - norm(pr - c.c));
  return make_pair(pr + e * base, pr - e * base);
}
pair<Point, Point> getCrossPoints(const Circle& c1, const Circle& c2) {
  assert(intersect(c1, c2));
  DD d = abs(c1.c - c2.c);
  DD a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (c1.r * d * 2));
  DD t = arg(c2.c - c1.c);
  return make_pair(c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a));
}
pair<Line, Line> tangent(const Circle& c, const Point& p) {
  assert(sgn(abs(c.c - p) - c.r) >= 0);
  if (!sgn(abs(c.c - p) - c.r)) {
    Point q = rot90(c.c - p);
    return pair<Line, Line>(Line(p, p + q), Line(p, p + q));
  }
  Circle c2 = Circle(p, sqrt(norm(c.c - p) - c.r * c.r));
  auto q = getCrossPoints(c, c2);
  return pair<Line, Line>(Line(p, q.first), Line(p, q.second));
}
DD area(const Polygon& g) {
  const int N = g.size();
  DD ret = 0;
  for (int i = 0; i < N; ++i) {
    ret += cross(g[i], g[(i + 1) % N]);
  }
  return fabs(ret) / 2;
}
bool isConvex(const Polygon& g) {
  const int N = g.size();
  for (int i = 0; i < N; ++i) {
    if (ccw(g[i], g[(i + 1) % N], g[(i + 2) % N]) == -1) return 0;
  }
  return 1;
}
int containment(const Polygon& g, const Point& p) {
  const int N = g.size();
  DD ang = 0;
  for (int i = 0; i < N; i++) {
    if (!ccw(g[i], g[(i + 1) % N], p)) return 1;
    ang += atan2(cross(g[(i + 1) % N] - p, g[i] - p),
                 dot(g[(i + 1) % N] - p, g[i] - p));
  }
  if (sgn(ang)) return 2;
  return 0;
}
Polygon andrewScan(Polygon s) {
  Polygon u, l;
  const int N = s.size();
  if (N < 3) return s;
  sort(s.begin(), s.end(), xsort);
  u.emplace_back(s[0]);
  u.emplace_back(s[1]);
  l.emplace_back(s[N - 1]);
  l.emplace_back(s[N - 2]);
  for (int i = 2; i < N; ++i) {
    for (int n = u.size(); n >= 2 && ccw(u[n - 2], u[n - 1], s[i]) != -1; --n) {
      u.pop_back();
    }
    u.emplace_back(s[i]);
  }
  for (int i = N - 3; i >= 0; --i) {
    for (int n = l.size(); n >= 2 && ccw(l[n - 2], l[n - 1], s[i]) != -1; --n) {
      l.pop_back();
    }
    l.emplace_back(s[i]);
  }
  reverse(l.begin(), l.end());
  for (int i = int(u.size()) - 2; i >= 1; --i) l.emplace_back(u[i]);
  return l;
}
DD farthestpointpair(const Polygon& g) {
  const int N = g.size();
  if (N == 2) return abs(g[1] - g[0]);
  int i = 0, j = 0;
  for (int k = 0; k < N; ++k) {
    if (g[k].y > g[i].y) i = k;
    if (g[k].y < g[j].y) j = k;
  }
  DD ret = 0;
  int si = i, sj = j;
  while (i != sj || j != si) {
    ret = max(ret, abs(g[i] - g[j]));
    if (sgn(cross(g[(i + 1) % N] - g[i], g[(j + 1) % N] - g[j])) < 0) {
      ++i;
      if (i == N) i = 0;
    } else {
      ++j;
      if (j == N) j = 0;
    }
  }
  return ret;
}
int main() {
  int X, Y;
  {
    int x1, x2, y1, y2;
    cin >> x1 >> y1 >> x2 >> y2;
    X = x2 - x1;
    Y = y2 - y1;
  }
  int V, T;
  cin >> V >> T;
  int vx, vy, wx, wy;
  cin >> vx >> vy >> wx >> wy;
  auto check = [&](DD mid) {
    if (sgn(mid, T) <= 0) {
      Point P(mid * vx, mid * vy), Q(X, Y);
      if (sgn(abs(P - Q), mid * V) <= 0) return true;
      return false;
    } else {
      Circle C(Point(vx * T, vy * T), T * V);
      Circle D(Point((mid - T) * wx * (-1) + X, (mid - T) * wy * (-1) + Y),
               (mid - T) * V);
      if (intersect(C, D) != 4) return true;
      return false;
    }
  };
  DD ok = 1e9;
  DD ng = 0;
  for (int _ = 0; _ < (50); _++) {
    DD mid = (ok + ng) / 2;
    (check(mid) ? ok : ng) = mid;
  }
  cout << ok << ln;
}
