Problem: You are given two rectangles on a plane. The centers of both rectangles are located in the origin of coordinates (meaning the center of the rectangle's symmetry). The first rectangle's sides are parallel to the coordinate axes: the length of the side that is parallel to the Ox axis, equals w, the length of the side that is parallel to the Oy axis, equals h. The second rectangle can be obtained by rotating the first rectangle relative to the origin of coordinates by angle α.

<image>

Your task is to find the area of the region which belongs to both given rectangles. This region is shaded in the picture.

Input

The first line contains three integers w, h, α (1 ≤ w, h ≤ 106; 0 ≤ α ≤ 180). Angle α is given in degrees.

Output

In a single line print a real number — the area of the region which belongs to both given rectangles.

The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.

Examples

Input

1 1 45


Output

0.828427125


Input

6 4 30


Output

19.668384925

Note

The second sample has been drawn on the picture above.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
struct line {
  double A, B, C;
  line(const complex<double> &a, const complex<double> &b) {
    A = b.imag() - a.imag();
    B = a.real() - b.real();
    C = A * a.real() + B * a.imag();
  }
};
bool point_on_line(const complex<double> &a, const complex<double> &b,
                   const complex<double> &x) {
  return fabs(((conj(((a) - (x))) * (((b) - (x)))).imag())) < 1e-7;
}
bool point_on_ray(const complex<double> &a, const complex<double> &b,
                  const complex<double> &x) {
  return point_on_line(a, b, x) &&
         ((conj(((x) - (a))) * (((b) - (a)))).real()) > -1e-7;
}
bool point_on_segment(const complex<double> &a, const complex<double> &b,
                      const complex<double> &x) {
  if ((((((b) - (a))) * (conj(((b) - (a))))).real()) < 1e-7)
    return (((((x) - (a))) * (conj(((x) - (a))))).real()) < 1e-7;
  return point_on_ray(a, b, x) && point_on_ray(b, a, x);
}
double point_line_distance(const complex<double> &a, const complex<double> &b,
                           const complex<double> &x) {
  return ((conj(((b) - (a))) * (((x) - (a)))).imag()) /
         (sqrt(((((((b) - (a)))) * (conj((((b) - (a)))))).real())));
}
complex<double> point_on_line_parametric(const complex<double> &a,
                                         const complex<double> &b, double t) {
  return a + ((b) - (a)) * t;
}
complex<double> point_line_perpendicular(const complex<double> &a,
                                         const complex<double> &b,
                                         const complex<double> &x) {
  return point_on_line_parametric(
      a, b,
      ((conj(((b) - (a))) * (((x) - (a)))).real()) /
          (((((b) - (a))) * (conj(((b) - (a))))).real()));
}
double triangle_area(const complex<double> &a, const complex<double> &b,
                     const complex<double> &c) {
  return fabs(((conj(((b) - (a))) * (((c) - (a)))).imag())) / 2;
}
pair<bool, double> area_from_medians(double m1, double m2, double m3) {
  double s = (m1 + m2 + m3) / 2.0;
  double area = (4.0) * sqrt(s * (s - m1) * (s - m2) * (s - m3)) / 3.0;
  if (s * (s - m1) * (s - m2) * (s - m3) > 0)
    return make_pair(true, area);
  else
    return make_pair(false, -1);
}
double triangle_area(double a, double b, double c) {
  double s = (a + b + c) / 2;
  return sqrt(s * (s - a) * (s - b) * (s - c));
}
bool line_line_intersection(const complex<double> &a, const complex<double> &b,
                            const complex<double> &p, const complex<double> &q,
                            complex<double> &ret) {
  double d1 = ((conj(((p) - (a))) * (((b) - (a)))).imag());
  double d2 = ((conj(((q) - (a))) * (((b) - (a)))).imag());
  ret = (d1 * q - d2 * p) / (d1 - d2);
  return fabs(d1 - d2) > 1e-7;
}
bool line_line_intersection_det(const complex<double> &a,
                                const complex<double> &b,
                                const complex<double> &p,
                                const complex<double> &q,
                                complex<double> &ret) {
  line l1(a, b), l2(p, q);
  double det = l1.A * l2.B - l1.B * l2.A;
  if (fabs(det) < 1e-7) return false;
  ret = complex<double>((l1.C * l2.B - l1.B * l2.C) / det,
                        (l1.A * l2.C - l2.A * l1.C) / det);
  return true;
}
bool segment_segment_intersect(const complex<double> &a,
                               const complex<double> &b,
                               const complex<double> &p,
                               const complex<double> &q, complex<double> &ret) {
  if (line_line_intersection(a, b, p, q, ret))
    return point_on_segment(a, b, ret) && point_on_segment(p, q, ret);
  return false;
}
bool point_in_rect(const complex<double> &bl, const complex<double> &tr,
                   const complex<double> &p) {
  return p.real() >= bl.real() && p.imag() >= bl.imag() &&
         p.real() <= tr.real() && p.imag() <= tr.imag();
}
bool segment_terminal_intersect(const complex<double> &a,
                                const complex<double> &b,
                                const complex<double> &p,
                                const complex<double> &q) {
  return point_on_segment(a, b, p) || point_on_segment(a, b, q) ||
         point_on_segment(p, q, a) || point_on_segment(p, q, b);
}
bool circle_intersect(const complex<double> &c1, double r1,
                      const complex<double> &c2, double r2) {
  return (((((c2) - (c1))) * (conj(((c2) - (c1))))).real()) >=
             (r1 - r2) * (r1 - r2) &&
         (((((c2) - (c1))) * (conj(((c2) - (c1))))).real()) <=
             (r1 + r2) * (r1 + r2);
}
void circle_circle_intersection(const complex<double> &c1, double r1,
                                const complex<double> &c2, double r2,
                                vector<complex<double> > &ret) {
  if (fabs(r1 - r2) < 1e-7 &&
      (sqrt(((((((c2) - (c1)))) * (conj((((c2) - (c1)))))).real()))) < 1e-7) {
    ret.push_back(complex<double>(0, 0));
    ret.push_back(complex<double>(0, 0));
    ret.push_back(complex<double>(0, 0));
  } else if (fabs((((((c2) - (c1))) * (conj(((c2) - (c1))))).real()) -
                  (r1 - r2) * (r1 - r2)) < 1e-7 ||
             fabs((((((c2) - (c1))) * (conj(((c2) - (c1))))).real()) -
                  (r1 + r2) * (r1 + r2)) < 1e-7) {
    if (r1 > r2)
      ret.push_back(point_on_line_parametric(
          c1, c2,
          r1 / (sqrt(((((((c2) - (c1)))) * (conj((((c2) - (c1)))))).real())))));
    else
      ret.push_back(point_on_line_parametric(
          c2, c1,
          r2 / (sqrt(((((((c2) - (c1)))) * (conj((((c2) - (c1)))))).real())))));
  } else if ((((((c2) - (c1))) * (conj(((c2) - (c1))))).real()) <
                 (r1 + r2) * (r1 + r2) &&
             (((((c2) - (c1))) * (conj(((c2) - (c1))))).real()) >
                 (r1 - r2) * (r1 - r2)) {
    double t = acos(
        ((((sqrt(((((((c2) - (c1)))) * (conj((((c2) - (c1)))))).real())))) *
              ((sqrt(((((((c2) - (c1)))) * (conj((((c2) - (c1)))))).real())))) +
          (r1) * (r1) - (r2) * (r2)) /
         (2 * ((sqrt(((((((c2) - (c1)))) * (conj((((c2) - (c1)))))).real())))) *
          (r1))));
    complex<double> p = point_on_line_parametric(
        c1, c2,
        r1 / (sqrt(((((((c2) - (c1)))) * (conj((((c2) - (c1)))))).real()))));
    ret.push_back(
        ((((((p) - (c1))) * (exp(complex<double>(0, ((t))))))) + (c1)));
    ret.push_back(
        ((((((p) - (c1))) * (exp(complex<double>(0, ((-t))))))) + (c1)));
  }
}
int circle_point_tangent(const complex<double> &c, double r,
                         const complex<double> &p,
                         vector<complex<double> > &ret) {
  if (fabs((((((p) - (c))) * (conj(((p) - (c))))).real()) - r * r) < 1e-7) {
    ret.push_back(p);
    return 1;
  } else if ((((((p) - (c))) * (conj(((p) - (c))))).real()) > r * r) {
    double d = (sqrt(((((((p) - (c)))) * (conj((((p) - (c)))))).real())));
    double t = acos(r / d);
    complex<double> x = point_on_line_parametric(c, p, r / d);
    ret.push_back(((((((x) - (c))) * (exp(complex<double>(0, ((t))))))) + (c)));
    ret.push_back(
        ((((((x) - (c))) * (exp(complex<double>(0, ((-t))))))) + (c)));
    return 2;
  } else
    return 0;
}
int circle_line_intersection(const complex<double> &c, double r,
                             const complex<double> &a, const complex<double> &b,
                             vector<complex<double> > &ret) {
  complex<double> p = point_line_perpendicular(a, b, c);
  if (fabs((((((p) - (c))) * (conj(((p) - (c))))).real()) - r * r) < 1e-7) {
    ret.push_back(p);
    return 1;
  } else if ((((((p) - (c))) * (conj(((p) - (c))))).real()) < r * r) {
    if ((((((p) - (c))) * (conj(((p) - (c))))).real()) < 1e-7) {
      complex<double> q = a;
      if ((((((q) - (c))) * (conj(((q) - (c))))).real()) < 1e-7) q = b;
      complex<double> p1 = point_on_line_parametric(
          c, q, r / (sqrt(((((((q) - (c)))) * (conj((((q) - (c)))))).real()))));
      complex<double> p2 = point_on_line_parametric(
          c, q,
          -r / (sqrt(((((((q) - (c)))) * (conj((((q) - (c)))))).real()))));
      ret.push_back(p1);
      ret.push_back(p2);
    } else {
      double t =
          acos((sqrt(((((((p) - (c)))) * (conj((((p) - (c)))))).real()))) / r);
      complex<double> q = point_on_line_parametric(
          c, p, r / (sqrt(((((((p) - (c)))) * (conj((((p) - (c)))))).real()))));
      ret.push_back(
          ((((((q) - (c))) * (exp(complex<double>(0, ((t))))))) + (c)));
      ret.push_back(
          ((((((q) - (c))) * (exp(complex<double>(0, ((-t))))))) + (c)));
    }
    return 2;
  } else
    return 0;
}
int circle_circle_open_belt(const complex<double> &c1, double r1,
                            const complex<double> &c2, double r2,
                            vector<complex<double> > &ret) {
  if (fabs(r1 - r2) < 1e-7) {
    if ((((((c2) - (c1))) * (conj(((c2) - (c1))))).real()) < 1e-7) return 0;
    complex<double> p1 = point_on_line_parametric(
        c1, c2,
        r1 / (sqrt(((((((c2) - (c1)))) * (conj((((c2) - (c1)))))).real()))));
    complex<double> p2 = point_on_line_parametric(
        c2, c1,
        r2 / (sqrt(((((((c2) - (c1)))) * (conj((((c2) - (c1)))))).real()))));
    double t = acos(0);
    ret.push_back(
        ((((((p1) - (c1))) * (exp(complex<double>(0, ((t))))))) + (c1)));
    ret.push_back(
        ((((((p1) - (c1))) * (exp(complex<double>(0, ((-t))))))) + (c1)));
    ret.push_back(
        ((((((p2) - (c2))) * (exp(complex<double>(0, ((t))))))) + (c2)));
    ret.push_back(
        ((((((p2) - (c2))) * (exp(complex<double>(0, ((-t))))))) + (c2)));
    return 4;
  } else {
    complex<double> a = c1;
    complex<double> b = c2;
    double ra = r1;
    double rb = r2;
    if (rb > ra) {
      a = c2;
      b = c1;
      ra = r2;
      rb = r1;
    }
    double rc = ra - rb;
    vector<complex<double> > cret;
    if (!circle_point_tangent(a, rc, b, cret)) return 0;
    complex<double> p1 = cret[0];
    complex<double> p2 = cret[1];
    ret.push_back(point_on_line_parametric(a, p1, ra / rc));
    ret.push_back(point_on_line_parametric(a, p2, ra / rc));
    ret.push_back(point_on_line_parametric(b, b + ((p1) - (a)), rb / rc));
    ret.push_back(point_on_line_parametric(b, b + ((p2) - (a)), rb / rc));
    return 4;
  }
}
int circ_circ_crossed_tangents(const complex<double> &c1, double r1,
                               const complex<double> &c2, double r2,
                               vector<complex<double> > &ret) {
  if (r2 > r1) circ_circ_crossed_tangents(c2, r2, c1, r1, ret);
  double r3 = r1 + r2;
  vector<complex<double> > v1;
  circle_point_tangent(c1, r3, c2, v1);
  complex<double> p1, p2, p3, p4;
  p1 = point_on_line_parametric(c1, v1[0], r1 / r3);
  p2 = point_on_line_parametric(c1, v1[1], r1 / r3);
  complex<double> unit1, unit2;
  unit1 = ((c1) - (p1)) / (r1);
  unit2 = ((c1) - (p2)) / (r1);
  p3 = unit1 * r2 + c2;
  p4 = unit2 * r2 + c2;
  ret.push_back(p1);
  ret.push_back(p2);
  ret.push_back(p3);
  ret.push_back(p4);
  return 4;
}
bool point_in_circ(const complex<double> &p, const complex<double> &c,
                   double r) {
  return (((((c) - (p))) * (conj(((c) - (p))))).real()) <= r * r;
}
pair<complex<double>, double> circle2(const complex<double> &p1,
                                      const complex<double> &p2) {
  complex<double> cen = (((p1) + (p2)) / complex<double>(2, 0));
  double r = hypot((((p2) - (p1))).real(), (((p2) - (p1))).imag()) / 2;
  return make_pair(cen, r);
}
pair<complex<double>, double> circle3(const complex<double> &p1,
                                      const complex<double> &p2,
                                      const complex<double> &p3) {
  complex<double> m1 = (((p1) + (p2)) / complex<double>(2, 0));
  complex<double> m2 = (((p2) + (p3)) / complex<double>(2, 0));
  complex<double> perp1 =
      (complex<double>(-(((p2) - (p1))).imag(), (((p2) - (p1))).real()));
  complex<double> perp2 =
      (complex<double>(-(((p3) - (p2))).imag(), (((p3) - (p2))).real()));
  complex<double> cen;
  line_line_intersection(m1, m1 + perp1, m2, m2 + perp2, cen);
  double r = hypot((((p1) - (cen))).real(), (((p1) - (cen))).imag());
  return make_pair(cen, r);
}
complex<double> P[110];
int psz;
complex<double> a[3];
int asz;
pair<complex<double>, double> min() {
  if (asz == 3) {
    return circle3(a[0], a[1], a[2]);
  }
  if (asz == 2 && psz == 0) {
    return circle2(a[0], a[1]);
  }
  if (psz == 0) return make_pair(a[0], 0);
  psz--;
  pair<complex<double>, double> ret = min();
  if (!point_in_circ(P[psz], ret.first, ret.second)) {
    a[asz++] = P[psz];
    ret = min();
    asz--;
  }
  psz++;
  return ret;
}
double MIN(double a, double b) { return (a > b) ? a : b; }
double point_to_segment(const complex<double> &a, const complex<double> &b,
                        const complex<double> &p) {
  complex<double> m = point_line_perpendicular(a, b, p);
  if (point_on_segment(a, b, m))
    return fabs(point_line_distance(a, b, p));
  else
    return MIN(hypot((((p) - (a))).real(), (((p) - (a))).imag()),
               hypot((((p) - (b))).real(), (((p) - (b))).imag()));
}
bool is_valid_triangle(double A, double B, double C) {
  return A < B + C && B < A + C && C < A + B;
}
bool is_equil_triangle(double A, double B, double C) {
  return fabs(A - B) < 1e-7 && fabs(A - C) < 1e-7;
}
bool is_isoc_triangle(double A, double B, double C) {
  return fabs(A - B) < 1e-7 || fabs(A - C) < 1e-7 || fabs(B - C) < 1e-7;
}
pair<complex<double>, double> circle_inscribed_in_triangle(double a, double b,
                                                           double c) {
  if (a < 1e-7 || b < 1e-7 || c < 1e-7) {
    return make_pair(complex<double>(0, 0), 0);
  }
  complex<double> unit(1, 0);
  complex<double> p1(0, 0);
  complex<double> p2;
  p2 = complex<double>(1, 0) * b;
  double angleP1 =
      acos((((a) * (a) + (b) * (b) - (c) * (c)) / (2 * (a) * (b))));
  complex<double> p3;
  p3 = ((unit) * (exp(complex<double>(0, (angleP1))))) * a;
  complex<double> p4 = ((p2) * (exp(complex<double>(0, (angleP1 / 2)))));
  double angleP2 =
      acos((((c) * (c) + (b) * (b) - (a) * (a)) / (2 * (c) * (b))));
  complex<double> p5 =
      ((((((p3) - (p2))) * (exp(complex<double>(0, ((angleP2 / 2))))))) + (p2));
  complex<double> m;
  line_line_intersection(p1, p4, p2, p5, m);
  double r = point_line_distance(p1, p2, m);
  pair<complex<double>, double> ret = make_pair(m, r);
  return ret;
}
double polygon_area(vector<complex<double> > &poly) {
  double area = 0;
  int n = (int)poly.size();
  for (int i = 0; i < n; i++)
    area += ((conj(poly[i]) * (poly[(i + 1) % n])).imag());
  area = fabs(area / 2);
  return area;
}
bool inPolygon(complex<double> &a, vector<complex<double> > P) {
  int n = (int)P.size();
  if (n == 0) return false;
  for (int i = 0; i < n - 1; i++)
    if (point_on_segment(P[i], P[i + 1], a)) return true;
  double sum = 0;
  for (int i = 0; i < n - 1; i++) {
    int j = (i + 1) % n;
    double angle =
        acos(((conj(((P[i]) - (a))) * (((P[j]) - (a)))).real()) /
             (hypot((((P[i]) - (a))).real(), (((P[i]) - (a))).imag()) *
              hypot((((P[j]) - (a))).real(), (((P[j]) - (a))).imag())));
    ;
    if (((conj(((P[i]) - (a))) * (((P[i + 1]) - (a)))).imag()) <= 0)
      sum -= angle;
    else
      sum += angle;
  }
  return fabs(sum - 2 * 2 * acos(0)) < 1e-7 ||
         fabs(sum + 2 * 2 * acos(0)) < 1e-7;
}
void polygon_cut(const vector<complex<double> > &P, const complex<double> &a,
                 const complex<double> &b, vector<complex<double> > &res) {
  int n = (int)P.size();
  for (int i = 0; i < n; i++) {
    int j = (i + 1) % n;
    bool in1 = (((conj((((b)) - ((a)))) * ((((P[i])) - ((a))))).imag()) > 1e-7);
    bool in2 = (((conj((((b)) - ((a)))) * ((((P[j])) - ((a))))).imag()) > 1e-7);
    if (in1) res.push_back(P[i]);
    if (in1 ^ in2) {
      complex<double> r;
      line_line_intersection(a, b, P[i], P[j], r);
      res.push_back(r);
    }
  }
}
void convex_polygon_intersect(const vector<complex<double> > &p,
                              const vector<complex<double> > &q,
                              vector<complex<double> > &res) {
  res = q;
  int n = (int)p.size();
  for (int i = 0; i < n; i++) {
    int j = (i + 1) % n;
    vector<complex<double> > temp;
    polygon_cut(res, p[i], p[j], temp);
    res = temp;
    if (res.empty()) {
      return;
    }
  }
}
complex<double> pivot(0, 0);
bool angleCmp(complex<double> a, complex<double> b) {
  if ((fabs(((conj((((a)) - ((pivot)))) * ((((b)) - ((pivot))))).imag())) <
       1e-7)) {
    return (((((a) - (pivot))) * (conj(((a) - (pivot))))).real()) <
           (((((b) - (pivot))) * (conj(((b) - (pivot))))).real());
  }
  return (((conj((((a)) - ((pivot)))) * ((((b)) - ((pivot))))).imag()) > 1e-7);
}
vector<complex<double> > CH(vector<complex<double> > P) {
  int i, N = (int)P.size();
  int po = 0;
  for (i = 0; i < N - 1; i++)
    if (P[i].imag() < P[po].imag() ||
        (P[i].imag() == P[po].imag() && P[i].real() < P[po].real()))
      po = i;
  pivot = P[po];
  sort(P.begin(), P.end(), angleCmp);
  complex<double> prev(0, 0), now(0, 0);
  stack<complex<double> > S;
  S.push(pivot);
  i = 1;
  while (i < N) {
    if (S.size() < 2) {
      S.push(P[i++]);
    } else {
      now = S.top();
      S.pop();
      prev = S.top();
      S.push(now);
      if ((((conj((((now)) - ((prev)))) * ((((P[i])) - ((prev))))).imag()) >
           1e-7))
        S.push(P[i++]);
      else
        S.pop();
    }
  }
  vector<complex<double> > ConvexHull;
  ConvexHull.push_back(pivot);
  while (!S.empty()) {
    ConvexHull.push_back(S.top());
    S.pop();
  }
  return ConvexHull;
}
void voroni(const vector<complex<double> > &pts,
            const vector<complex<double> > &rect,
            vector<vector<complex<double> > > &res) {
  res.clear();
  int n = ((int)(pts.size()));
  for (int i = 0; i < n; i++) {
    res.push_back(rect);
    for (int j = 0; j < n; j++)
      if (i != j) {
        complex<double> p = (complex<double>(-(((pts[j]) - (pts[i]))).imag(),
                                             (((pts[j]) - (pts[i]))).real()));
        complex<double> m = (((pts[i]) + (pts[j])) / complex<double>(2, 0));
        vector<complex<double> > temp;
        p += m;
        polygon_cut(res.back(), m, p, temp);
        res.back() = temp;
      }
  }
}
vector<complex<double> > sort_polygon(vector<complex<double> > P) {
  int i, N = (int)P.size();
  int po = 0;
  for (i = 0; i < N - 1; i++)
    if (P[i].imag() < P[po].imag() ||
        (P[i].imag() == P[po].imag() && P[i].real() < P[po].real()))
      po = i;
  pivot = P[po];
  sort(P.begin(), P.end(), angleCmp);
  return P;
}
int main() {
  double h, w, alpha;
  scanf("%lf %lf %lf", &w, &h, &alpha);
  if (alpha == 0 || alpha == 180)
    printf("%.9f\n", w * h);
  else {
    alpha = (alpha * 2 * acos(0)) / 180;
    complex<double> p1, p2, p3, p4, pp1, pp2, pp3, pp4;
    vector<complex<double> > p;
    vector<complex<double> > pp;
    p.push_back(complex<double>(w / 2, h / 2));
    p.push_back(complex<double>(-w / 2, h / 2));
    p.push_back(complex<double>(-w / 2, -h / 2));
    p.push_back(complex<double>(w / 2, -h / 2));
    pp.push_back(((p[0]) * (exp(complex<double>(0, (alpha))))));
    pp.push_back(((p[1]) * (exp(complex<double>(0, (alpha))))));
    pp.push_back(((p[2]) * (exp(complex<double>(0, (alpha))))));
    pp.push_back(((p[3]) * (exp(complex<double>(0, (alpha))))));
    vector<complex<double> > v;
    convex_polygon_intersect(p, pp, v);
    sort_polygon(v);
    v = CH(v);
    double area = polygon_area(v);
    printf("%.9f\n", area);
  }
  return 0;
}