#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void prn(Arg1&& arg1) {
  cout << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void prn(Arg1&& arg1, Args&&... args) {
  cout << arg1 << " ";
  prn(args...);
}
template <typename Arg1>
void prs(Arg1&& arg1) {
  cout << arg1 << " ";
}
template <typename Arg1, typename... Args>
void prs(Arg1&& arg1, Args&&... args) {
  cout << arg1 << " ";
  prs(args...);
}
template <typename Arg1>
void read(Arg1&& arg1) {
  cin >> arg1;
}
template <typename Arg1, typename... Args>
void read(Arg1&& arg1, Args&&... args) {
  cin >> arg1;
  read(args...);
}
namespace geometry {
struct pt {
  double x, y;
};
const double pi = 2. * acos(0);
double radian(double dgre) { return (pi * dgre) / 180; }
double degree(double rad) { return (180 * rad) / pi; }
double dist2(pt p) { return p.x * p.x + p.y * p.y; }
double dist(pt p) { return sqrtl(dist2(p)); }
pt operator-(pt p1, pt p2) { return {p1.x - p2.x, p1.y - p2.y}; }
pt operator+(pt p1, pt p2) { return {p1.x + p2.x, p1.y + p2.y}; }
pt operator*(pt p, double d) { return {p.x * d, p.y * d}; }
pt operator*(double d, pt p) { return {p.x * d, p.y * d}; }
pt operator/(pt p, double d) { return {p.x / d, p.y / d}; }
pt operator/(double d, pt p) { return {p.x / d, p.y / d}; }
pt perp(pt p) { return {-p.y, p.x}; }
double cross(pt p1, pt p2) { return p1.x * p2.y - p1.y * p2.x; }
double dot(pt p1, pt p2) { return p1.x * p2.x + p1.y * p2.y; }
pt rotl(pt p) { return {-p.y, p.x}; }
pt rotr(pt p) { return {p.y, -p.x}; }
pt rotate(pt p, double ang) {
  return {p.x * cos(ang) - p.y * sin(ang), p.x * sin(ang) + p.y * cos(ang)};
}
pt unit(pt p) { return p / dist(p); }
pt normal(pt p) { return unit(perp(p)); }
bool isParallel(pt a, pt b, pt c, pt d) { return cross(b - a, d - c) == 0; }
bool isColinear(pt a, pt b, pt c) { return cross(a - b, a - c) == 0; }
bool isColinear(pt a, pt b, pt c, pt d) {
  return isColinear(a, b, c) && isColinear(b, c, d);
}
bool isLeft(pt front, pt back, pt p) {
  return cross(front - back, p - back) > 0;
}
bool oppositeSides(pt a, pt b, pt c, pt d) {
  return isLeft(a, b, c) != isLeft(a, b, d);
}
bool isBetween(pt a, pt b, pt c) {
  if (!isColinear(a, b, c)) return 0;
  return min(a.x, b.x) <= c.x && c.x <= max(a.x, b.x) && min(a.y, b.y) <= c.y &&
         c.y <= max(a.y, b.y);
}
int lineIntersection(pt a, pt b, pt c, pt d, pt& res) {
  if (cross(b - a, d - c)) {
    res = c - (d - c) * cross(b - a, c - a) / cross(b - a, d - c);
    return 1;
  }
  return -isColinear(a, b, c, d);
}
double lineDist(pt a, pt b, pt p) {
  return abs(cross(b - a, p - a) / dist(b - a));
}
bool segmentIntersect(pt a, pt b, pt c, pt d) {
  if (isBetween(a, b, c) || isBetween(a, b, d) || isBetween(c, d, a) ||
      isBetween(c, d, b))
    return 1;
  return oppositeSides(a, b, c, d) && oppositeSides(c, d, a, b);
}
double segmentDistance(pt v, pt w, pt p) {
  double l2 = dist2(v - w);
  if (l2 == 0.0) return dist(p - v);
  double t = max(double(0), min(double(1), dot(p - v, w - v) / l2));
  pt projection = v + t * (w - v);
  return dist2(p - projection);
}
}  // namespace geometry
using namespace geometry;
double polygonArea(vector<pt>& vertices) {
  double ans = 0;
  for (int i = 1; i + 1 < vertices.size(); ++i)
    ans += cross(vertices[i] - vertices[0], vertices[i + 1] - vertices[0]);
  return abs(ans / 2.0);
}
inline void solve();
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  int t = 1;
  for (int tc = 1; tc <= t; ++tc) {
    solve();
  }
  return 0;
}
bool cmp(pt a, pt b) { return a.x < b.x || (a.x == b.x && a.y < b.y); }
bool cw(pt a, pt b, pt c) {
  return a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y) < 0;
}
bool ccw(pt a, pt b, pt c) {
  return a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y) > 0;
}
void convex_hull(vector<pt>& a) {
  if (a.size() == 1) return;
  sort(a.begin(), a.end(), &cmp);
  pt p1 = a[0], p2 = a.back();
  vector<pt> up, down;
  up.push_back(p1);
  down.push_back(p1);
  for (int i = 1; i < (int)a.size(); i++) {
    if (i == a.size() - 1 || cw(p1, a[i], p2)) {
      while (up.size() >= 2 && !cw(up[up.size() - 2], up[up.size() - 1], a[i]))
        up.pop_back();
      up.push_back(a[i]);
    }
    if (i == a.size() - 1 || ccw(p1, a[i], p2)) {
      while (down.size() >= 2 &&
             !ccw(down[down.size() - 2], down[down.size() - 1], a[i]))
        down.pop_back();
      down.push_back(a[i]);
    }
  }
  a.clear();
  for (int i = 0; i < (int)up.size(); i++) a.push_back(up[i]);
  for (int i = down.size() - 2; i > 0; i--) a.push_back(down[i]);
}
inline void solve() {
  long long w, h, alfa;
  read(w, h, alfa);
  if (alfa % 180 == 0 || (w == h && alfa % 90 == 0)) {
    prn(w * h);
    return;
  }
  double theta = radian(alfa);
  vector<pt> v1;
  v1.push_back({w / 2., h / 2.});
  v1.push_back({-w / 2., h / 2.});
  v1.push_back({-w / 2., -h / 2.});
  v1.push_back({w / 2., -h / 2.});
  vector<pt> v2 = v1;
  for (auto& i : v2) {
    i = rotate(i, theta);
  }
  vector<pt> intersects;
  for (int i = 0; i < 4; ++i) {
    pt p1 = v1[i], p2 = v1[(i + 1) % 4];
    for (int j = 0; j < 4; ++j) {
      pt q1 = v2[j], q2 = v2[(j + 1) % 4];
      if (!segmentIntersect(p1, p2, q1, q2)) continue;
      pt res;
      int ret = lineIntersection(p1, p2, q1, q2, res);
      if (ret == -1) {
        prn(w * h);
        return;
      }
      assert(ret);
      intersects.push_back(res);
    }
  }
  convex_hull(intersects);
  cout << fixed << setprecision(10);
  prn(polygonArea(intersects));
}
