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
import java.util.List;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.util.ArrayList;
import java.util.Comparator;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Random;
import java.io.Writer;
import java.math.BigInteger;
import java.util.Collections;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Crash
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		Task solver = new Task();
		solver.solve(1, in, out);
		out.close();
	}
}

class Task {
	private static final double eps = 1e-12;
	private double calc(DoublePoint2D a, DoublePoint2D b, Circle c) {
		if (! c.isIntersectedByLineSegment(new LineSegment(a, b), eps)) {
			return a.dist(b);
		} else {
			Pair<Double, Double> p = c.getTangentPointRadians(a);
			Pair<Double, Double> q = c.getTangentPointRadians(b);
			double res = 1e10;
			res = Math.min(res, Circle.mirrorArc(p.first, q.first));
			res = Math.min(res, Circle.mirrorArc(p.first, q.second));
			res = Math.min(res, Circle.mirrorArc(p.second, q.first));
			res = Math.min(res, Circle.mirrorArc(p.second, q.second));
			return res * c.r + c.getTangentLineLength(a) + c.getTangentLineLength(b);
		}
	}
	public void solve(int testNumber, InputReader in, OutputWriter out) {
		double x0 = in.readDouble();
		double y0 = in.readDouble();
		double v0 = in.readDouble();
		double R = Math.sqrt(x0 * x0 + y0 * y0);
		double x = in.readDouble();
		double y = in.readDouble();
		double v = in.readDouble();
		double r = in.readDouble();
		double head = 0, tail = 1e10;
		while (head + 1e-10 < tail) {
			double mid = (head + tail) / 2;
			DoublePoint2D t = DoublePoint2D.ZERO.add((new DoubleVector2D(x0, y0)).rotate(v0 / R * mid));
			if (Geometry.sign(calc(new DoublePoint2D(x, y), t, new Circle(0, 0, r)) / v - mid, eps) < 0) {
				tail = mid;
			} else {
				head = mid;
			}
		}
		out.printLineDouble(head, 9);
	}
}

class DoublePoint2D implements Comparable<DoublePoint2D> {
	public double x, y;
	public static final DoublePoint2D ZERO = new DoublePoint2D(0, 0);
	public DoublePoint2D() {
		this.x = 0;
		this.y = 0;
	}
	public DoublePoint2D(double x, double y) {
		this.x = x;
		this.y = y;
	}
	public int compareTo(DoublePoint2D o) {
		if (x < o.x) return -1;
		if (x > o.x) return 1;
		if (y < o.y) return -1;
		if (y > o.y) return 1;
		return 0;
	}
	public DoublePoint2D add(DoubleVector2D o) {
		return new DoublePoint2D(x + o.x, y + o.y);
	}
	public double dist(DoublePoint2D o) {
		return Math.sqrt((x - o.x) * (x - o.x) + (y - o.y) * (y - o.y));
	}
	}

class Circle {
	public DoublePoint2D o;
	public double r;
	public Circle(double x, double y, double r) {
		this.o = new DoublePoint2D(x, y);
		this.r = r;
	}
	public Circle(DoublePoint2D o, double r) {
		this.o = o;
		this.r = r;
	}
	public boolean isIntersectedByLineSegment(LineSegment lineSegment, double eps) {
		int s1 = Geometry.sign(o.dist(lineSegment.o) - r, eps);
		int s2 = Geometry.sign(o.dist(lineSegment.o.add(lineSegment.v)) - r, eps);
		if (s1 < 0 && s2 < 0) return false;
		if (s1 >= 0 && s2 < 0) return true;
		if (s1 < 0 && s2 >= 0) return true;
		if (Geometry.sign(lineSegment.v.length(), eps) == 0) return s1 == 0;
		double lambda = -lineSegment.v.scalar(new DoubleVector2D(DoublePoint2D.ZERO, lineSegment.o));
		lambda /= lineSegment.v.scalar(lineSegment.v);
		DoublePoint2D p = lineSegment.o.add(lineSegment.v.multiply(lambda));
		if (Geometry.sign(p.dist(o) - r, eps) <= 0)
			if (Geometry.sign(lambda, eps) >= 0 && Geometry.sign(lambda - 1, eps) <= 0) return true;
		return false;
	}
	public Pair<Double, Double> getTangentPointRadians(DoublePoint2D o) {
		double theta = Math.atan2(o.y - this.o.y, o.x - this.o.x);
		double alpha = Math.acos(this.r / o.dist(this.o));
		return new Pair<Double, Double>(theta - alpha, theta + alpha);
	}
	public double getTangentLineLength(DoublePoint2D o) {
		return Math.sqrt((o.x - this.o.x) * (o.x - this.o.x) + (o.y - this.o.y) * (o.y - this.o.y) - r * r);
	}
	public static double mirrorArc(double alpha, double beta) {
		double tmp = Math.abs(alpha - beta);
		while (tmp > Math.PI * 2) tmp -= Math.PI * 2;
		return Math.min(tmp, 2 * Math.PI - tmp);
	}
	}

class LineSegment {
	public DoublePoint2D o;
	public DoubleVector2D v;
	public LineSegment(DoublePoint2D o, DoubleVector2D v) {
		this.o = o;
		this.v = v;
	}
	public LineSegment(DoublePoint2D a, DoublePoint2D b) {
		this.o = a;
		this.v = new DoubleVector2D(a, b);
	}
}

class Pair<T1 extends Comparable<T1>, T2 extends Comparable<T2>> implements Comparable<Pair<T1, T2>> {
	public T1 first;
	public T2 second;

	public boolean equals(Object o) {
		if (this == o) return true;
		if (o == null || getClass() != o.getClass()) return false;

		Pair pair = (Pair) o;

		if (!first.equals(pair.first)) return false;
		if (!second.equals(pair.second)) return false;

		return true;
	}

	public int hashCode() {
		int result = first.hashCode();
		result = 31 * result + second.hashCode();
		return result;
	}

	public Pair(T1 first, T2 second) {
		this.first = first;
		this.second = second;
	}

	public int compareTo(Pair<T1, T2> o) {
		if (first.compareTo(o.first) != 0) return first.compareTo(o.first);
		return second.compareTo(o.second);
	}
}

class InputReader {
	private InputStream stream;
	private byte[] buf = new byte[1000];
	private int curChar;
	private int numChars;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	private int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public double readDouble() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		double res = 0;
		while (!isSpaceChar(c) && c != '.') {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		}
		if (c == '.') {
			c = read();
			double m = 1;
			while (!isSpaceChar(c)) {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				m /= 10;
				res += (c - '0') * m;
				c = read();
			}
		}
		return res * sgn;
	}

	private boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}
}

class OutputWriter {
	private final PrintWriter writer;

	public OutputWriter(OutputStream outputStream) {
		writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
	}

	public OutputWriter(Writer writer) {
		this.writer = new PrintWriter(writer);
	}

	public void print(Object...objects) {
		for (int i = 0; i < objects.length; i++) {
			if (i != 0)
				writer.print(' ');
			writer.print(objects[i]);
		}
	}

	public void printDouble(double x, int precision) {
		writer.printf("%." + precision + "f", x);
	}

	public void printLineDouble(double x, int precision) {
		printDouble(x, precision);
		printLine();
	}

	public void printLine(Object...objects) {
		print(objects);
		writer.println();
	}

	public void close() {
		writer.close();
	}
}

class DoubleVector2D {
	public double x, y;
	public DoubleVector2D(double x, double y) {
		this.x = x;
		this.y = y;
	}
	public DoubleVector2D(DoublePoint2D a, DoublePoint2D b) {
		this.x = b.x - a.x;
		this.y = b.y - a.y;
	}
	public DoubleVector2D multiply(double lambda) {
		return new DoubleVector2D(this.x * lambda, this.y * lambda);
	}
	public double scalar(DoubleVector2D o) {
		return this.x * o.x + this.y * o.y;
	}
	public double length() {
		return Math.sqrt(this.scalar(this));
	}
	public DoubleVector2D rotate(double theta) {
		double vx = Math.cos(theta), vy = Math.sin(theta);
		return new DoubleVector2D(x * vx - y * vy, x * vy + y * vx);
	}
}

class Geometry {
	public static int sign(double x, double eps) {
		if (Math.abs(x) < eps) return 0;
		return (x > 0) ? 1 : -1;
	}

	}

