#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;
}
