#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
unsigned seed = chrono::system_clock::now().time_since_epoch().count();
mt19937 eng(seed);
long long random2() { return (1ll << 31ll) * eng() + eng(); }
long long n, m, k, q, T;
const long long big = 1000000007;
const long long big2 = 1000000009;
const long long mod = 998244353;
template <class T>
int sgn(T x) {
  return (x > 0) - (x < 0);
}
template <class T>
struct Point {
  T x, y;
  explicit Point(T x = 0, T y = 0) : x(x), y(y) {}
  bool operator<(Point p) const { return tie(x, y) < tie(p.x, p.y); }
  bool operator==(Point p) const { return tie(x, y) == tie(p.x, p.y); }
  Point operator+(Point p) const { return Point(x + p.x, y + p.y); }
  Point operator-(Point p) const { return Point(x - p.x, y - p.y); }
  Point operator*(T d) const { return Point(x * d, y * d); }
  Point operator/(T d) const { return Point(x / d, y / d); }
  T dot(Point p) const { return x * p.x + y * p.y; }
  T cross(Point p) const { return x * p.y - y * p.x; }
  T cross(Point a, Point b) const { return (a - *this).cross(b - *this); }
  T dist2() const { return x * x + y * y; }
  double dist() const { return sqrt((double)dist2()); }
  double angle() const { return atan2(y, x); }
  Point unit() const { return *this / dist(); }
  Point perp() const { return Point(-y, x); }
  Point normal() const { return perp().unit(); }
  Point rotate(double a) const {
    return Point(x * cos(a) - y * sin(a), x * sin(a) + y * cos(a));
  }
  friend ostream& operator<<(ostream& os, Point p) {
    return os << "(" << p.x << "," << p.y << ")";
  }
};
template <class Point>
int sideOf(Point s, Point e, Point p) {
  return sgn(s.cross(e, p));
}
template <class Point>
int sideOf(const Point& s, const Point& e, const Point& p, double eps) {
  auto a = (e - s).cross(p - s);
  double l = (e - s).dist() * eps;
  return (a > l) - (a < -l);
}
template <class Point>
pair<int, Point> lineInter(Point s1, Point e1, Point s2, Point e2) {
  auto d = (e1 - s1).cross(e2 - s2);
  if (d == 0) return {-(s1.cross(e1, s2) == 0), Point(0, 0)};
  auto p = s2.cross(e1, e2), q = s2.cross(e2, s1);
  return {1, (s1 * p + e1 * q) / d};
}
int angDiff(array<Point<double>, 2> a, array<Point<double>, 2> b) {
  return sgn((a[1] - a[0]).angle() - (b[1] - b[0]).angle());
}
bool cmp(array<Point<double>, 2> a, array<Point<double>, 2> b) {
  int s = angDiff(a, b);
  return (s ? s : sideOf(a[0], a[1], b[0])) < 0;
}
vector<Point<double>> halfPlaneIntersection(
    vector<array<Point<double>, 2>> vs) {
  const double EPS = sqrt(2) * 1e-8;
  sort(vs.begin(), vs.end(), cmp);
  vector<array<Point<double>, 2>> deq((int)(vs).size() + 5);
  vector<Point<double>> ans((int)(vs).size() + 5);
  deq[0] = vs[0];
  int ah = 0, at = 0, n = (int)(vs).size();
  for (int i = 1; i < (n + 1); ++i) {
    if (i == n) vs.push_back(deq[ah]);
    if (angDiff(vs[i], vs[i - 1]) == 0) continue;
    while (ah < at && sideOf(vs[i][0], vs[i][1], ans[at - 1], EPS) < 0) at--;
    while (i != n && ah < at && sideOf(vs[i][0], vs[i][1], ans[ah], EPS) < 0)
      ah++;
    auto res = lineInter(vs[i][0], vs[i][1], deq[at][0], deq[at][1]);
    if (res.first != 1) continue;
    ans[at++] = res.second, deq[at] = vs[i];
  }
  if (at - ah <= 2) return {};
  return {ans.begin() + ah, ans.begin() + at};
}
const int MAXN = 300001;
template <class T>
T polygonArea2(vector<Point<T>>& v) {
  T a = v.back().cross(v[0]);
  for (int i = 0; i < ((int)(v).size() - 1); ++i) a += v[i].cross(v[i + 1]);
  return a;
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  long long a, b, c, d;
  long double w, h, ang;
  cin >> w >> h >> ang;
  ang *= 2 * acos(-1);
  ang /= 360.0;
  vector<array<Point<double>, 2>> lines;
  lines.push_back(
      {Point<double>(w / 2.0, h / 2.0), Point<double>(-w / 2.0, h / 2.0)});
  lines.push_back(
      {Point<double>(w / 2.0, -h / 2.0), Point<double>(w / 2.0, h / 2.0)});
  lines.push_back(
      {Point<double>(-w / 2.0, -h / 2.0), Point<double>(w / 2.0, -h / 2.0)});
  lines.push_back(
      {Point<double>(-w / 2.0, h / 2.0), Point<double>(-w / 2.0, -h / 2.0)});
  lines.push_back({Point<double>(w / 2.0, h / 2.0).rotate(ang),
                   Point<double>(-w / 2.0, h / 2.0).rotate(ang)});
  lines.push_back({Point<double>(w / 2.0, -h / 2.0).rotate(ang),
                   Point<double>(w / 2.0, h / 2.0).rotate(ang)});
  lines.push_back({Point<double>(-w / 2.0, -h / 2.0).rotate(ang),
                   Point<double>(w / 2.0, -h / 2.0).rotate(ang)});
  lines.push_back({Point<double>(-w / 2.0, h / 2.0).rotate(ang),
                   Point<double>(-w / 2.0, -h / 2.0).rotate(ang)});
  vector<Point<double>> hull = halfPlaneIntersection(lines);
  long double ans = polygonArea2<double>(hull) / 2.0;
  cout << setprecision(18) << abs(ans) << "\n";
  return 0;
}
