#include <bits/stdc++.h>
using namespace std;
double INF = 1e100;
double EPS = 1e-12;
struct PT {
  double x, y;
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y) {}
  PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
  PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
  PT operator*(double c) const { return PT(x * c, y * c); }
  PT operator/(double c) const { return PT(x / c, y / c); }
};
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
ostream &operator<<(ostream &os, const PT &p) {
  os << "(" << p.x << "," << p.y << ")";
}
PT RotateCCW(PT p, double t) {
  return PT(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));
}
bool LinesParallel(PT a, PT b, PT c, PT d) {
  return fabs(cross(b - a, c - d)) < EPS;
}
bool LinesCollinear(PT a, PT b, PT c, PT d) {
  return LinesParallel(a, b, c, d) && fabs(cross(a - b, a - c)) < EPS &&
         fabs(cross(c - d, c - a)) < EPS;
}
bool SegmentsIntersect(PT a, PT b, PT c, PT d) {
  if (LinesCollinear(a, b, c, d)) {
    if (dist2(a, c) < EPS || dist2(a, d) < EPS || dist2(b, c) < EPS ||
        dist2(b, d) < EPS)
      return true;
    if (dot(c - a, c - b) > 0 && dot(d - a, d - b) > 0 && dot(c - b, d - b) > 0)
      return false;
    return true;
  }
  if (cross(d - a, b - a) * cross(c - a, b - a) > 0) return false;
  if (cross(a - c, d - c) * cross(b - c, d - c) > 0) return false;
  return true;
}
PT ComputeLineIntersection(PT a, PT b, PT c, PT d) {
  b = b - a;
  d = c - d;
  c = c - a;
  assert(dot(b, b) > EPS && dot(d, d) > EPS);
  return a + b * cross(c, d) / cross(b, d);
}
double ComputeSignedArea(const vector<PT> &p) {
  double area = 0;
  for (int i = 0; i < p.size(); i++) {
    int j = (i + 1) % p.size();
    area += p[i].x * p[j].y - p[j].x * p[i].y;
  }
  return area / 2.0;
}
double ComputeArea(const vector<PT> &p) { return fabs(ComputeSignedArea(p)); }
bool func(PT n1, PT n2) {
  double s1 = n1.y / n1.x;
  s1 = atan(s1);
  if (n1.x < 0 && n1.y < 0) s1 = s1 - M_PI;
  if (n1.x < 0 && n1.y > 0) s1 = M_PI + s1;
  double s2 = n2.y / n2.x;
  s2 = atan(s2);
  if (n2.x < 0 && n2.y < 0) s2 = s2 - M_PI;
  if (n2.x < 0 && n2.y > 0) s2 = M_PI + s2;
  if (s1 > s2) return true;
  return false;
}
int main() {
  double l, b, alpha;
  cin >> l >> b >> alpha;
  if (alpha == 0 || alpha == 180) {
    printf("%.7lf", l * b);
    return 0;
  }
  alpha = (alpha / 180);
  PT p[5];
  p[0].x = -l / 2;
  p[0].y = b / 2;
  p[1].x = l / 2;
  p[1].y = b / 2;
  p[2].x = l / 2;
  p[2].y = -b / 2;
  p[3].x = -l / 2;
  p[3].y = -b / 2;
  p[4] = p[0];
  PT res[5];
  res[0] = RotateCCW(p[0], M_PI * alpha);
  res[1] = RotateCCW(p[1], M_PI * alpha);
  res[2] = RotateCCW(p[2], M_PI * alpha);
  res[3] = RotateCCW(p[3], M_PI * alpha);
  res[4] = res[0];
  vector<PT> inter;
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 4; j++) {
      if (SegmentsIntersect(res[i], res[i + 1], p[j], p[j + 1])) {
        inter.push_back(
            ComputeLineIntersection(res[i], res[i + 1], p[j], p[j + 1]));
      }
    }
  sort(inter.begin(), inter.end(), func);
  double ans = ComputeArea(inter);
  printf("%.7lf", ans);
  return 0;
}
