import java.io.*;
import java.util.*;
import java.math.*;

public class move_aa_pops {

	public static void main(String[] args) throws Throwable {
		new move_aa_pops().run();
	}

	BufferedReader br;
	StringTokenizer st;
	PrintWriter out;
	boolean eof = false;
	Random rand = new Random(this.hashCode());

	public void run() throws Throwable {
		Locale.setDefault(Locale.US);
		br = new BufferedReader(new FileReader(FNAME + ".in"));
		out = new PrintWriter(FNAME + ".out");
		solve();
		out.close();
	}

	String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (Exception e) {
				eof = true;
				return "0";
			}
		}
		return st.nextToken();
	}

	int nextInt() {
		return Integer.parseInt(nextToken());
	}

	void myAssert(boolean u, String message) {
		if (!u) {
			throw new Error("Assertion failed!!! " + message);
		}
	}

	int inBounds(int x, int l, int r, String name) {
		myAssert(l <= x && x <= r, name + " not in bounds: " + x + " not in ["
				+ l + ".." + r + "]");
		return x;
	}

	String FNAME = "move";

	int step = 100;

	int x1, y1, x2, y2, x3, y3, xd, yd, v1, v2;

	private void solve() throws IOException {
		x1 = inBounds(nextInt(), -1000, 1000, "x1");
		y1 = inBounds(nextInt(), -1000, 1000, "y1");
		x2 = inBounds(nextInt(), -1000, 1000, "x2");
		y2 = inBounds(nextInt(), -1000, 1000, "y2");
		x3 = inBounds(nextInt(), -1000, 1000, "x3");
		y3 = inBounds(nextInt(), -1000, 1000, "y3");
		xd = inBounds(nextInt(), -1000, 1000, "xd");
		yd = inBounds(nextInt(), -1000, 1000, "yd");
		v1 = inBounds(nextInt(), 1, 1000, "v1");
		v2 = inBounds(nextInt(), 1, v1 - 1, "v1");
		if (inside(x1, y1, x2, y2, x3, y3, xd, yd)) {
			double ans = Double.POSITIVE_INFINITY;
			ans = Math.min(ans, search(new Path1_12_T(x1, y1, x2, y2)));
			ans = Math.min(ans, search(new Path1_12_T(x1, y1, x3, y3)));
			ans = Math.min(ans, dist(x1, y1, x2, y2) / v1 + search(new Path1_12_T(x2, y2, x3, y3)));
			ans = Math.min(ans, dist(x1, y1, x3, y3) / v1 + search(new Path1_12_T(x3, y3, x2, y2)));
			out.println(ans);
			return;
		}
		{
			long a1 = y2 - y1;
			long b1 = x1 - x2;
			long c1 = -a1 * x1 - b1 * y1;
			long a2 = y3 - y1;
			long b2 = x1 - x3;
			long c2 = -a2 * x1 - b2 * y1;
			long a3 = y3 - y2;
			long b3 = x2 - x3;
			long c3 = -a3 * x2 - b3 * y2;
			long s1 = a1 * xd + b1 * yd + c1;
			long s2 = a2 * xd + b2 * yd + c2;
			long s3 = a3 * xd + b3 * yd + c3;
			long s4 = a3 * x1 + b3 * y1 + c3;
			if (s3 * s4 > 0 || s1 * s2 >= 0) {
				out.println(dist(x1, y1, xd, yd) / v1);
				return;
			}
		}
		double ans = Double.POSITIVE_INFINITY;
		ans = Math.min(ans, search(new Path1_23_T(x1, y1)));
		ans = Math.min(ans, search(new Path1_12_23_T(x2, y2)));
		ans = Math.min(ans, search(new Path1_12_23_T(x3, y3)));
		ans = Math.min(ans, (dist(x1, y1, x2, y2) + dist(x2, y2, xd, yd)) / v1);
		ans = Math.min(ans, (dist(x1, y1, x3, y3) + dist(x3, y3, xd, yd)) / v1);
		out.println(ans);

	}

	double search(Function f) {
		double l = 0;
		double r = 1;
		for (int i = 0; i < step; i++) {
			double ml = (2 * l + r) / 3;
			double mr = (l + 2 * r) / 3;
			double dl = f.call(ml);
			double dr = f.call(mr);
			if (dl > dr) {
				l = ml;
			} else {
				r = mr;
			}
		}
		return f.call(l);
	}

	interface Function {
		public double call(double a);
	}

	class Path1_23_T implements Function {

		public Path1_23_T(double x, double y) {
			x0 = x;
			y0 = y;
		}

		@Override
		public double call(double a) {
			double x = x2 + a * (x3 - x2);
			double y = y2 + a * (y3 - y2);
			return dist(x0, y0, x, y) / v2 + dist(x, y, xd, yd) / v1;
		}

		double x0, y0;
	}

	class Path1_12_23_T implements Function {

		public Path1_12_23_T(int x22, int y22) {
			x2 = x22;
			y2 = y22;
		}

		@Override
		public double call(double a) {
			double x = x1 + a * (x2 - x1);
			double y = y1 + a * (y2 - y1);
			return dist(x1, y1, x, y) / v1 + search(new Path1_23_T(x, y));
		}

		double x2, y2;
	}

	class Path1_12_T implements Function {

		public Path1_12_T(int x22, int y22, int x23, int y23) {
			x1 = x22;
			y1 = y22;
			x2 = x23;
			y2 = y23;
		}

		@Override
		public double call(double a) {
			double x = x1 + a * (x2 - x1);
			double y = y1 + a * (y2 - y1);
			return dist(x1, y1, x, y) / v1 + dist(x, y, xd, yd) / v2;
		}

		double x2, y2, x1, y1;

	}

	private double dist(double x1, double y1, double x2, double y2) {
		return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
	}

	private boolean inside(int x1, int y1, int x2, int y2, int x3, int y3,
			int xd, int yd) {
		return Math.abs(x1 * y2 - x1 * y3 + x2 * y3 - x2 * y1 + x3 * y1 - x3
				* y2) == Math.abs(xd * y2 - xd * y3 + x2 * y3 - x2 * yd + x3
				* yd - x3 * y2)
				+ Math.abs(x1 * yd - x1 * y3 + xd * y3 - xd * y1 + x3 * y1 - x3
						* yd)
				+ Math.abs(x1 * y2 - x1 * yd + x2 * yd - x2 * y1 + xd * y1 - xd
						* y2);
	}

}
