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 CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
double a, b, l, w;
const double EPS = 1e-8;
inline int sign(double a) { return a < -EPS ? -1 : a > EPS; }
struct Point {
  double x, y;
  Point() {}
  Point(double _x, double _y) : x(_x), y(_y) {}
  Point operator+(const Point& p) const { return Point(x + p.x, y + p.y); }
  Point operator-(const Point& p) const { return Point(x - p.x, y - p.y); }
  Point operator*(double d) const { return Point(x * d, y * d); }
  Point operator/(double d) const { return Point(x / d, y / d); }
  bool operator<(const Point& p) const {
    int c = sign(x - p.x);
    if (c) return c == -1;
    return sign(y - p.y) == -1;
  }
  double dot(const Point& p) const { return x * p.x + y * p.y; }
  double det(const Point& p) const { return x * p.y - y * p.x; }
  double alpha() const { return atan2(y, x); }
  double distTo(const Point& p) const {
    double dx = x - p.x, dy = y - p.y;
    return hypot(dx, dy);
  }
  double alphaTo(const Point& p) const {
    double dx = x - p.x, dy = y - p.y;
    return atan2(dy, dx);
  }
  void read() { scanf("%lf%lf", &x, &y); }
  double abs() { return hypot(x, y); }
  double abs2() { return x * x + y * y; }
  void write() { cout << "(" << x << "," << y << ")" << endl; }
};
Point isSS(Point p1, Point p2, Point q1, Point q2) {
  double a1 = ((q2.x - q1.x) * (p1.y - q1.y) - (p1.x - q1.x) * (q2.y - q1.y)),
         a2 = -((q2.x - q1.x) * (p2.y - q1.y) - (p2.x - q1.x) * (q2.y - q1.y));
  return (p1 * a2 + p2 * a1) / (a1 + a2);
}
bool inMid(Point a, Point m, Point b, bool inc = false) {
  return sign(((m.x - a.x) * (b.y - a.y) - (b.x - a.x) * (m.y - a.y))) == 0 &&
         sign((m - a).dot(m - b)) < (inc ? 1 : 0);
}
bool crsSS(Point p1, Point p2, Point q1, Point q2) {
  return sign(((p2.x - p1.x) * (q1.y - p1.y) - (q1.x - p1.x) * (p2.y - p1.y))) *
                 sign(((p2.x - p1.x) * (q2.y - p1.y) -
                       (q2.x - p1.x) * (p2.y - p1.y))) <
             0 &&
         sign(((q2.x - q1.x) * (p1.y - q1.y) - (p1.x - q1.x) * (q2.y - q1.y))) *
                 sign(((q2.x - q1.x) * (p2.y - q1.y) -
                       (p2.x - q1.x) * (q2.y - q1.y))) <
             0;
}
bool crsII(double l, double r, double L, double R) {
  if (l > r) swap(l, r);
  if (L > R) swap(L, R);
  return r + EPS > L && R + EPS > l;
}
bool crsTSS(Point p1, Point p2, Point q1, Point q2) {
  return sign(((p2.x - p1.x) * (q1.y - p1.y) - (q1.x - p1.x) * (p2.y - p1.y))) *
                 sign(((p2.x - p1.x) * (q2.y - p1.y) -
                       (q2.x - p1.x) * (p2.y - p1.y))) <=
             0 &&
         sign(((q2.x - q1.x) * (p1.y - q1.y) - (p1.x - q1.x) * (q2.y - q1.y))) *
                 sign(((q2.x - q1.x) * (p2.y - q1.y) -
                       (p2.x - q1.x) * (q2.y - q1.y))) <=
             0 &&
         crsII(p1.x, p2.x, q1.x, q2.x) && crsII(p1.y, p2.y, q1.y, q2.y);
}
Point proj(Point p1, Point p2, Point q) {
  return p1 + (p2 - p1) * (p2 - p1).dot(q - p1) / (p2 - p1).abs2();
}
double calc(double t) {
  double x = cos(t) * l, y = sin(t) * l;
  Point p1(x, 0), p2(0, y);
  Point q(b, a);
  return (q - p1).det(p2 - p1) / (p1 - p2).abs();
}
int main() {
  cin >> a >> b >> l;
  if (a > b) swap(a, b);
  double L = 0, R = M_PI / 2;
  while (L + 1e-12 < R) {
    double M1 = (L * 2 + R) / 3, M2 = (L + R * 2) / 3;
    if (calc(M1) < calc(M2))
      R = M2;
    else
      L = M1;
  }
  w = calc((L + R) / 2);
  w = min(w, l);
  if (l <= a)
    w = l;
  else if (l <= b)
    w = a;
  if (w < 0)
    puts("My poor head =(");
  else
    printf("%0.10lf\n", w);
  return 0;
}