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

public class move_mb {
    static final Random random = new Random(231);

    static class Point {
        public final double x, y;
        public Point(double x, double y) {
            this.x = x;
            this.y = y;
        }
        public Point sub(Point arg) {
            return new Point(x - arg.x, y - arg.y);
        }
        public double vmul(Point arg) {
            return x * arg.y - y * arg.x;
        }
        public double length() {
            return Math.sqrt(x * x + y * y);
        }
        public double distTo(Point t) {
            double dx = x - t.x;
            double dy = y - t.y;
            return Math.sqrt(dx * dx + dy * dy);
        }
    }

    public static Point interpolate(Point l, Point r, double t) {
        return new Point(l.x + (r.x - l.x) * t, l.y + (r.y - l.y) * t);
    }

    public static void main(String[] args) throws IOException {
        Scanner in = new Scanner(new File("move.in"));
        Point s = new Point(in.nextInt(), in.nextInt());
        Point l = new Point(in.nextInt(), in.nextInt());
        Point r = new Point(in.nextInt(), in.nextInt());
        Point t = new Point(in.nextInt(), in.nextInt());
        int v1 = in.nextInt();
        int v2 = in.nextInt();
        in.close();

        double answer;

        if (l.sub(s).vmul(r.sub(s)) == 0) {
            //Triangle is degenerate
            answer = s.sub(t).length() / v1;
        } else {
            if (r.sub(s).vmul(l.sub(s)) < 0) {
                Point tmp = r;
                r = l;
                l = tmp;
            }
            if (r.sub(s).vmul(t.sub(s)) > 0 && l.sub(s).vmul(t.sub(s)) < 0) {
                if (t.sub(r).vmul(l.sub(r)) >= 0) {
                    //Target is invisible from source and is outside the swamp
                    answer = new GraphBuilder(s, l, r, t, v1, v2) {
                        protected void fillImpl(Point sl, Point sr, Point lr) {
                            g[6][0] = g[0][6] = Double.POSITIVE_INFINITY;
                            g[6][1] = g[1][6] = Double.POSITIVE_INFINITY;
                            g[6][2] = g[2][6] = t.distTo(r) / v1;
                            g[6][3] = g[3][6] = t.distTo(lr) / v1;
                            g[6][4] = g[4][6] = t.distTo(l) / v1;
                            g[6][5] = g[5][6] = Double.POSITIVE_INFINITY;
                        }
                    }.get(100, 500);
                } else {
                    //Target is inside the swamp
                    answer = new GraphBuilder(s, l, r, t, v1, v2) {
                        protected void fillImpl(Point sl, Point sr, Point lr) {
                            g[6][0] = g[0][6] = t.distTo(s) / v2;
                            g[6][1] = g[1][6] = t.distTo(sr) / v2;
                            g[6][2] = g[2][6] = t.distTo(r) / v2;
                            g[6][3] = g[3][6] = t.distTo(lr) / v2;
                            g[6][4] = g[4][6] = t.distTo(l) / v2;
                            g[6][5] = g[5][6] = t.distTo(sl) / v2;
                        }
                    }.get(100, 500);
                }
            } else {
                //Target is visible from source.
                answer = s.sub(t).length() / v1;
            }
        }

        PrintWriter out = new PrintWriter("move.out");
        out.println(answer);
        out.close();
    }

    static abstract class GraphBuilder {
        final Point s, l, r, t;
        final double v1, v2;
        public GraphBuilder(Point s, Point l, Point r, Point t, double v1, double v2) {
            this.s = s;
            this.l = l;
            this.r = r;
            this.t = t;
            this.v1 = v1;
            this.v2 = v2;
        }
        protected double[][] g = new double[7][7];
        protected void fill(double aSL, double aSR, double aLR) {
            Point sl = interpolate(s, l, aSL);
            Point sr = interpolate(s, r, aSR);
            Point lr = interpolate(l, r, aLR);
            for (int i = 0; i < 7; ++i) {
                g[i][i] = 0;
            }
            g[0][1] = g[1][0] = s.distTo(sr) / v1;
            g[0][2] = g[2][0] = s.distTo(r) / v1;
            g[0][3] = g[3][0] = s.distTo(lr) / v2;
            g[0][4] = g[4][0] = s.distTo(l) / v1;
            g[0][5] = g[5][0] = s.distTo(sl) / v1;
            g[1][2] = g[2][1] = sr.distTo(r) / v1;
            g[1][3] = g[3][1] = sr.distTo(lr) / v2;
            g[1][4] = g[4][1] = sr.distTo(l) / v2;
            g[1][5] = g[5][1] = sr.distTo(sl) / v2;
            g[2][3] = g[3][2] = r.distTo(lr) / v1;
            g[2][4] = g[4][2] = r.distTo(l) / v1;
            g[2][5] = g[5][2] = r.distTo(sl) / v2;
            g[3][4] = g[4][3] = lr.distTo(l) / v1;
            g[3][5] = g[5][3] = lr.distTo(sl) / v2;
            g[4][5] = g[5][4] = l.distTo(sl) / v1;
            fillImpl(sl, sr, lr);
        }
        protected abstract void fillImpl(Point sl, Point sr, Point lr);
        private double get(double x, double y, double z) {
            fill(x, y, z);
            for (int k = 0; k < 7; ++k) {
                for (int i = 0; i < 7; ++i) {
                    for (int j = 0; j < 7; ++j) {
                        g[i][j] = Math.min(g[i][j], g[i][k] + g[k][j]);
                    }
                }
            }
            return g[0][6];
        }
        public double get(int nOuter, int nInner) {
            double rv = Double.POSITIVE_INFINITY;
            for (int it = 0; it < nOuter; ++it) {
                double x = random.nextDouble();
                double y = random.nextDouble();
                double z = random.nextDouble();
                double opt = get(x, y, z);
                for (int it2 = 0; it2 < nInner; ++it2) {
                    double amp = (double) (nInner - it2) / nInner;
                    amp *= amp;
                    double nx = Math.max(0, Math.min(1, x + amp * random.nextGaussian()));
                    double ny = Math.max(0, Math.min(1, y + amp * random.nextGaussian()));
                    double nz = Math.max(0, Math.min(1, z + amp * random.nextGaussian()));
                    double nv = get(nx, ny, nz);
                    if (nv < opt) {
                        opt = nv;
                        x = nx;
                        y = ny;
                        z = nz;
                    }
                }
                rv = Math.min(rv, opt);
            }
            return rv;
        }
    }
}
