Problem: A very unusual citizen lives in a far away kingdom — Dwarf Gracula. However, his unusual name is not the weirdest thing (besides, everyone long ago got used to calling him simply Dwarf Greg). What is special about Dwarf Greg — he's been living for over 200 years; besides, he lives in a crypt on an abandoned cemetery and nobody has ever seen him out in daytime. Moreover, nobody has ever seen Greg buy himself any food. That's why nobody got particularly surprised when after the infernal dragon's tragic death cattle continued to disappear from fields. The people in the neighborhood were long sure that the harmless dragon was never responsible for disappearing cattle (considering that the dragon used to be sincere about his vegetarian views). But even that's not the worst part of the whole story.

The worst part is that merely several minutes ago Dwarf Greg in some unintelligible way got inside your house and asked you to help him solve a problem. The point is that a short time ago Greg decided to order a new coffin (knowing his peculiar character, you are not surprised at all). But the problem is: a very long in both directions L-shaped corridor leads to Greg's crypt, and you can't drag just any coffin through that corridor. That's why he asked you to help.

<image>

You've formalized the task on a plane like this: let the corridor's width before and after the turn be equal to a and b correspondingly (see the picture). The corridor turns directly at a right angle, the coffin is a rectangle whose length and width are equal to l and w (l ≥ w) correspondingly. Dwarf Greg has already determined the coffin's length (l), which is based on his height; your task is to determine the coffin's maximally possible width (w), at which it can be brought to the crypt. Besides, due to its large mass (pure marble!) the coffin is equipped with rotating wheels; therefore it is impossible to lift it off the ground, however, arbitrary moves and rotations of the coffin in the plane become possible. The coffin may be rotated arbitrarily just before you drag it into crypt and move through the corridor.

Greg promised that if you help him, he will grant you immortality (I wonder how?). And if you don't, well... trust me, you don't want to know what happens if you don't help him...

Input

The first line contains three space-separated integers a, b and l from the problem's statement (1 ≤ a, b, l ≤ 104).

Output

Print the maximally possible width of a coffin with absolute or relative error no more than 10 - 7. If a coffin with the given length and positive width (the coffin that would meet the conditions from the problem's statement) does not exist, print "My poor head =(" (without quotes).

It is guaranteed that if the answer is positive, it will be not less than 10 - 7. All the hacks will also be checked to meet that condition.

Examples

Input

2 2 1


Output

1.0000000


Input

2 2 2


Output

2.0000000

Input

2 2 3


Output

1.3284271


Input

2 2 6


Output

My poor head =(

Note

In the first example the answer is restricted by the coffin's length (remember — coffin's widths should not be larger than it's length).

In the second example it is possible to drag the coffin through the corridor thanks to rotating wheels: firstly, drag it forward by one side while it will not be hampered by the wall, then move it forward by adjacent side perpendicularly to the initial movement direction (remember — arbitrary moves and rotations of the coffin are possible).

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;

public class Coffin implements Runnable {
    private void solve() throws IOException {
        int a = nextInt();
        int b = nextInt();
        int l = nextInt();
        if (l <= a || l <= b) {
            writer.println(Math.min(l, Math.min(a, b)));
            return;
        }
        double[] koef = new double[5];
        koef[4] = -a - l;
        koef[3] = -2 * b;
        koef[2] = 6 * l;
        koef[1] = -2 * b;
        koef[0] = a - l;
        List<Double> zeroes = findZeroes(koef);
        zeroes.add(0.0);
        zeroes.add(1.0);
        double res = l;
        for (double u : zeroes) {
            double cur = b * (1 - u * u) / (1 + u * u) + a * 2 * u / (1 + u * u) - l * 2 * u * (1 - u * u) / (1 + u * u) / (1 + u * u);
            res = Math.min(res, cur);
        }
        if (res < 0.5e-7) {
            writer.println("My poor head =(");
        } else {
            writer.println(res);
        }
    }

    private double eval(double[] koef, double x) {
        double res = 0.0;
        for (int i = koef.length - 1; i >= 0; --i) {
            res = res * x + koef[i];
        }
        return res;
    }

    private List<Double> findZeroes(double[] koef) {
        List<Double> res = new ArrayList<Double>();
        if (koef.length == 3) {
            double a = koef[2];
            double b = koef[1];
            double c = koef[0];
            double d = b * b - 4 * a * c;
            if (d < 0) {
                return res;
            }
            d = Math.sqrt(d);
            double sol = (-b + d) / (2 * a);
            if (sol > 0.0 && sol < 1.0) res.add(sol);
            sol = (-b - d) / (2 * a);
            if (sol > 0.0 && sol < 1.0) res.add(sol);
            Collections.sort(res);
            return res;
        }
        double[] deriv = new double[koef.length - 1];
        for (int i = 1; i < koef.length; ++i)
            deriv[i - 1] = i * koef[i];
        List<Double> derivZeroes = findZeroes(deriv);
        derivZeroes.add(0.0);
        derivZeroes.add(1.0);
        Collections.sort(derivZeroes);
        double[] val = new double[derivZeroes.size()];
        for (int i = 0; i < derivZeroes.size(); ++i) {
            double x = derivZeroes.get(i);
            val[i] = eval(koef, x);
            if (val[i] == 0) res.add(x);
        }
        for (int i = 0; i + 1 < val.length; ++i) {
            if (val[i] * val[i + 1] < 0) {
                double left = derivZeroes.get(i);
                double right = derivZeroes.get(i + 1);
                int j;
                for (j = 0; j < 200; ++j) {
                    double middle = (left + right) / 2;
                    double v = eval(koef, middle);
                    if (v == 0) {
                        res.add(middle);
                        break;
                    }
                    if (v * val[i] < 0)
                        right = middle;
                    else
                        left = middle;
                }
                if (j == 200) {
                    res.add((left + right) / 2);
                }
            }
        }
        Collections.sort(res);
        return res;
    }

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

    BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter writer;

    public void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            writer = new PrintWriter(System.out);
            solve();
            reader.close();
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

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

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }
}