Problem: You know, it's hard to conduct a show with lots of participants and spectators at the same place nowadays. Still, you are not giving up on your dream to make a car crash showcase! You decided to replace the real cars with remote controlled ones, call the event "Remote Control Kaboom Show" and stream everything online.

For the preparation you arranged an arena — an infinite 2D-field. You also bought n remote controlled cars and set them up on the arena. Unfortunately, the cars you bought can only go forward without turning left, right or around. So you additionally put the cars in the direction you want them to go.

To be formal, for each car i (1 ≤ i ≤ n) you chose its initial position (x_i, y_i) and a direction vector (dx_i, dy_i). Moreover, each car has a constant speed s_i units per second. So after car i is launched, it stars moving from (x_i, y_i) in the direction (dx_i, dy_i) with constant speed s_i.

The goal of the show is to create a car collision as fast as possible! You noted that launching every car at the beginning of the show often fails to produce any collisions at all. Thus, you plan to launch the i-th car at some moment t_i. You haven't chosen t_i, that's yet to be decided. Note that it's not necessary for t_i to be integer and t_i is allowed to be equal to t_j for any i, j.

The show starts at time 0. The show ends when two cars i and j (i ≠ j) collide (i. e. come to the same coordinate at the same time). The duration of the show is the time between the start and the end.

What's the fastest crash you can arrange by choosing all t_i? If it's possible to arrange a crash then print the shortest possible duration of the show. Otherwise, report that it's impossible.

Input

The first line contains a single integer n (1 ≤ n ≤ 25000) — the number of cars.

Each of the next n lines contains five integers x_i, y_i, dx_i, dy_i, s_i (-10^3 ≤ x_i, y_i ≤ 10^3; 1 ≤ |dx_i| ≤ 10^3; 1 ≤ |dy_i| ≤ 10^3; 1 ≤ s_i ≤ 10^3) — the initial position of the i-th car, its direction vector and its speed, respectively.

It's guaranteed that all cars start at distinct positions (i. e. (x_i, y_i) ≠ (x_j, y_j) for i ≠ j).

Output

Print the shortest possible duration of the show if it's possible to arrange a crash by choosing all t_i. Otherwise, print "No show :(".

Your answer is considered correct if its absolute or relative error does not exceed 10^{-6}.

Formally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.

Examples

Input


4
3 -1 -1 1 2
2 3 -3 -2 10
-4 2 1 -2 1
-2 -2 -1 2 4


Output


0.585902082262898


Input


2
-1 1 -1 1 200
1 1 1 5 200


Output


No show :(

Note

Here is the picture for the first example: 

<image>

The fastest cars to crash are cars 2 and 4. Let's launch car 2 at 0, car 4 at about 0.096762 and cars 1 and 3 at arbitrary time. That way cars 2 and 4 will crash into each other at about 0.585902. So here's what it looks like at the moment of the collision:

<image>

Here's the picture for the second example:

<image>

Solution (in JAVA):

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

public class F {
    static final boolean RUN_TIMING = false;
    static PushbackReader in = new PushbackReader(new BufferedReader(new InputStreamReader(System.in)), 1024);
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    double xPos;

    public void go() throws IOException {
        // in = new PushbackReader(new BufferedReader(new FileReader(new File("test.txt"))), 1024);
        // out = new PrintWriter(new FileWriter(new File("output.txt")));
        int n = ipar();
        int[][] cars = new int[n][];
        for (int i = 0; i < n; i++) {
            cars[i] = iapar(5);
        }
        Line[] lines = new Line[n];
        for (int i = 0; i < n; i++) {
            lines[i] = new Line(new Vector(0, 0), new Vector(0, 0));
            lines[i].p1.lineIndex = i;
            lines[i].p2.lineIndex = i;
            double len = Math.hypot(cars[i][2], cars[i][3]);
            lines[i].dir = new Vector(cars[i][2]/len, cars[i][3]/len);
        }
        Vector[] order = new Vector[n*2];
        double l = 0;
        double r = 1e10;
        Vector dir = new Vector(0, 0);
        xPos = 0;
        TreeSet<Line> set = new TreeSet<>();
        int count = 0;
        while (r - l > 0.000001 && count < 60) {
            count++;
            // out.println(l + " " + r);
            double t = (r+l)/2;
            for (int i = 0; i < n; i++) {
                double x1 = cars[i][0];
                double y1 = cars[i][1];
                double x2 = x1 + lines[i].dir.x * t * cars[i][4];
                double y2 = y1 + lines[i].dir.y * t * cars[i][4];
                lines[i].p1.x = x1;
                lines[i].p1.y = y1;
                lines[i].p2.x = x2;
                lines[i].p2.y = y2;
                if (lines[i].p1.x > lines[i].p2.x) {
                    Vector temp = lines[i].p1;
                    lines[i].p1 = lines[i].p2;
                    lines[i].p2 = temp;
                }
                lines[i].p1.start = true;
                lines[i].p2.start = false;
                order[i*2] = lines[i].p1;
                order[i*2+1] = lines[i].p2;
            }
            Arrays.sort(order, (a, b) -> {
                if (Math.abs(a.x - b.x) > 1e-12) {
                    return Double.compare(a.x, b.x);
                }
                return -Boolean.compare(a.start, b.start);
            });
            // out.println(Arrays.toString(lines));
            // out.println(Arrays.toString(order));

            set.clear();
            boolean intersection = false;
            for (Vector curr : order) {
                xPos = curr.x;
                Line line = lines[curr.lineIndex];
                if (curr.start) {
                    Line lower = set.lower(line);
                    if (lower != null && line.intersect(lower)) {
                        // out.printf("LOWER INTERSECTION: %s %s%n", line, lower);
                        intersection = true;
                        break;
                    }
                    lower = set.floor(line);
                    if (lower != null && line.intersect(lower)) {
                        // out.printf("FLOOR INTERSECTION: %s %s%n", line, lower);
                        intersection = true;
                        break;
                    }
                    Line upper = set.higher(line);
                    if (upper != null && line.intersect(upper)) {
                        // out.printf("UPPER INTERSECTION: %s %s%n", line, upper);
                        intersection = true;
                        break;
                    }
                    set.add(line);
                } else {
                    set.remove(line);
                    Line lower = set.floor(line);
                    Line upper = set.ceiling(line);
                    if (lower != null && upper != null && lower.intersect(upper)) {
                        // out.printf("REMOVE INTERSECTION: %s %s%n", lower, upper);
                        intersection = true;
                        break;
                    }
                }
            }
            if (intersection) {
                r = t;
            } else {
                l = t;
            }
        }
        if (r > 9.99e9) {
            out.println("No show :(");
        } else {
            out.println(r);
        }
    }

    public double cross(double x1, double y1, double x2, double y2) {
        return x1 * y2 - y1 * x2;
    }

    public int turn(Vector p1, Vector p2, Vector p3) {
        double c = cross(p2.x-p1.x, p2.y-p1.y, p3.x-p2.x, p3.y-p2.y);
        if (c < -1e-12) {
            return -1;
        } else if (c > 1e-12) {
            return 1;
        } else {
            return 0;
        }
    }

    public boolean intersect1d(double l1, double r1, double l2, double r2) {
        if (l1 > r1) {
            double temp = l1;
            l1 = r1;
            r1 = temp;
        }
        if (l2 > r2) {
            double temp = l2;
            l2 = r2;
            r2 = temp;
        }
        return Math.max(l1, l2) <= Math.min(r1, r2) + 1e-12;
    }

    private class Line implements Comparable<Line> {
        Vector p1, p2;
        Vector dir;

        public Line(Vector p1, Vector p2) {
            if (p1.x <= p2.x) {
                this.p1 = p1;
                this.p2 = p2;
            } else {
                this.p1 = p2;
                this.p2 = p1;
            }
        }

        public int compareTo(Line other) {
            return Double.compare(getY(xPos), other.getY(xPos));
        }

        public double getY(double x) {
            if (p1.x == p2.x) {
                return p1.y;
            }
            if (x < p1.x) {
                return p1.y;
            } else if (x > p2.x) {
                return p2.y;
            } else {
                return p1.y + (x - p1.x) / (p2.x - p1.x) * (p2.y - p1.y);
            }
        }

        public boolean intersect(Line other) {
            // out.println(turn(p1, p2, other.p1) + turn(p1, p2, other.p2));
            // out.println(turn(other.p1, other.p2, p1) + turn(other.p1, other.p2, p2));
            return intersect1d(p1.x, p2.x, other.p1.x, other.p2.x)
                    && intersect1d(p1.y, p2.y, other.p1.y, other.p2.y)
                    && turn(p1, p2, other.p1) * turn(p1, p2, other.p2) <= 0
                    && turn(other.p1, other.p2, p1) * turn(other.p1, other.p2, p2) <= 0;
        }

        public String toString() {
            return String.format("%s -- %s : %s", p1, p2, dir);
        }
    }

    private class Vector {
        double x, y;
        boolean start;
        int lineIndex;

        public Vector(double x, double y) {
            this.x = x;
            this.y = y;
        }

        public void normalize() {
            double len = Math.hypot(x, y);
            x /= len;
            y /= len;
        }

        public String toString() {
            return String.format("(%.8f,%.8f)", x, y);
        }
    }

    public int ipar() throws IOException {
        return Integer.parseInt(spar());
    }

    public int[] iapar(int n) throws IOException {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = ipar();
        }
        return arr;
    }

    public long lpar() throws IOException {
        return Long.parseLong(spar());
    }

    public long[] lapar(int n) throws IOException {
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = lpar();
        }
        return arr;
    }

    public double dpar() throws IOException {
        return Double.parseDouble(spar());
    }

    public String spar() throws IOException {
        StringBuilder sb = new StringBuilder(1024);
        int c;
        do {
            c = in.read();
        } while (Character.isWhitespace(c) && c != -1);
        if (c == -1) {
            throw new NoSuchElementException("Reached EOF");
        }
        do {
            sb.append((char)c);
            c = in.read();
        } while (!Character.isWhitespace(c) && c != -1);
        while (c != '\n' && Character.isWhitespace(c) && c != -1) {
            c = in.read();
        }
        if (c != -1 && c != '\n') {
            in.unread(c);
        }
        return sb.toString();
    }

    public String linepar() throws IOException {
        StringBuilder sb = new StringBuilder(1024);
        int c;
        while ((c = in.read()) != '\n' && c != -1) {
            if (c == '\r') {
                continue;
            }
            sb.append((char)c);
        }
        return sb.toString();
    }

    public boolean haspar() throws IOException {
        String line = linepar();
        if (line.isEmpty()) {
            return false;
        }
        in.unread('\n');
        in.unread(line.toCharArray());
        return true;
    }

    public static void main(String[] args) throws IOException {
        long time = 0;
        time -= System.nanoTime();
        new F().go();
        time += System.nanoTime();
        if (RUN_TIMING) {
            System.out.printf("%.3f ms%n", time/1000000.0);
        }
        out.flush();
        in.close();
    }
}