#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
const double PI = acos(-1);
const double EPS = 1e-8;
namespace std {
bool operator<(const complex<double> &a, const complex<double> &b) {
  return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
}  // namespace std
double cross(const complex<double> &a, const complex<double> &b) {
  return imag(conj(a) * b);
}
double dot(const complex<double> &a, const complex<double> &b) {
  return real(conj(a) * b);
}
struct L : public vector<complex<double> > {
  L(const complex<double> &a, const complex<double> &b) {
    push_back(a);
    push_back(b);
  }
  L() {}
};
struct C {
  complex<double> p;
  double r;
  C(const complex<double> &p, double r) : p(p), r(r) {}
};
int ccw(complex<double> a, complex<double> b, complex<double> c) {
  b -= a;
  c -= a;
  if (cross(b, c) > 0) return +1;
  if (cross(b, c) < 0) return -1;
  if (dot(b, c) < 0) return +2;
  if (norm(b) < norm(c)) return -2;
  return 0;
}
bool intersectLL(const L &l, const L &m) {
  return abs(cross(l[1] - l[0], m[1] - m[0])) > EPS ||
         abs(cross(l[1] - l[0], m[0] - l[0])) < EPS;
}
bool intersectLS(const L &l, const L &s) {
  return cross(l[1] - l[0], s[0] - l[0]) * cross(l[1] - l[0], s[1] - l[0]) <
         EPS;
}
bool intersectLP(const L &l, const complex<double> &p) {
  return abs(cross(l[1] - p, l[0] - p)) < EPS;
}
bool intersectSS(const L &s, const L &t) {
  return ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) <= 0 &&
         ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) <= 0;
}
bool intersectSS2(const L &s, const L &t) {
  for (int i = 0; i < (int)2; ++i) {
    if (ccw(s[0], s[1], t[i]) == 0) {
      int c = ccw(s[0], s[1], t[!i]);
      if (s[0] == t[i]) {
        if (c != -2 && c) return 0;
      } else if (s[1] == t[i]) {
        if (c != 2 && c) return 0;
      } else if (abs(c) == 1)
        return 0;
    }
  }
  return ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) <= 0 &&
         ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) <= 0;
}
bool intersectSP(const L &s, const complex<double> &p) {
  return abs(s[0] - p) + abs(s[1] - p) - abs(s[1] - s[0]) < EPS;
}
complex<double> projection(const L &l, const complex<double> &p) {
  double t = dot(p - l[0], l[0] - l[1]) / norm(l[0] - l[1]);
  return l[0] + t * (l[0] - l[1]);
}
complex<double> reflection(const L &l, const complex<double> &p) {
  return p + complex<double>(2, 0) * (projection(l, p) - p);
}
double distanceLP(const L &l, const complex<double> &p) {
  return abs(p - projection(l, p));
}
double distanceLL(const L &l, const L &m) {
  return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
double istanceLS(const L &l, const L &s) {
  if (intersectLS(l, s)) return 0;
  return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
double distanceSP(const L &s, const complex<double> &p) {
  const complex<double> r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(const L &s, const L &t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
             min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
complex<double> crosspoint(const L &l, const L &m) {
  double A = cross(l[1] - l[0], m[1] - m[0]);
  double B = cross(l[1] - l[0], l[1] - m[0]);
  if (abs(A) < EPS && abs(B) < EPS) return m[0];
  if (abs(A) < EPS) assert(false);
  return m[0] + B / A * (m[1] - m[0]);
}
double area(const vector<complex<double> > &g) {
  double A = 0;
  for (int i = 0; i < g.size(); ++i) {
    A += cross(g[i], g[(i + 1) % g.size()]);
  }
  return abs(A / 2);
}
vector<complex<double> > convex_cut(const vector<complex<double> > &g,
                                    const L &l) {
  vector<complex<double> > Q;
  for (int i = 0; i < (int)g.size(); ++i) {
    complex<double> A = g[i], B = g[(i + 1) % g.size()];
    if (ccw(l[0], l[1], A) != -1) Q.push_back(A);
    if (ccw(l[0], l[1], A) * ccw(l[0], l[1], B) < 0)
      Q.push_back(crosspoint(L(A, B), l));
  }
  return Q;
}
complex<double> centroid(const vector<complex<double> > &v) {
  double S = 0;
  complex<double> res;
  for (int i = 0; i < (int)v.size(); ++i) {
    int j = i + 1;
    if (j == v.size()) j = 0;
    double tmp = cross(v[i], v[j]);
    S += tmp;
    res += (v[i] + v[j]) * tmp;
  }
  S /= 2;
  res /= 6 * S;
  return res;
}
double manDistanceSP(const L &l, const complex<double> &p) {
  double res = INF;
  L xl = L(p, p + complex<double>(1, 0));
  if (intersectLS(xl, l)) {
    complex<double> cp = crosspoint(xl, l);
    double d = abs(p - cp);
    res = min(res, d);
  }
  L yl = L(p, p + complex<double>(0, 1));
  if (intersectLS(yl, l)) {
    complex<double> cp = crosspoint(yl, l);
    double d = abs(p - cp);
    res = min(res, d);
  }
  res = min(res, abs(l[0].real() - p.real()) + abs(l[0].imag() - p.imag()));
  res = min(res, abs(l[1].real() - p.real()) + abs(l[1].imag() - p.imag()));
  return res;
}
bool convex_contain(const vector<complex<double> > &g,
                    const complex<double> &p) {
  for (int i = 0; i < (int)g.size(); ++i)
    if (ccw(g[i], g[(i + 1) % g.size()], p) == -1) return 0;
  return 1;
}
bool intersectGG(const vector<complex<double> > &g1,
                 const vector<complex<double> > &g2) {
  if (convex_contain(g1, g2[0])) return 1;
  if (convex_contain(g2, g1[0])) return 1;
  for (int i = 0; i < (int)g1.size(); ++i)
    for (int j = 0; j < (int)g2.size(); ++j) {
      if (intersectSS(L(g1[i], g1[(i + 1) % g1.size()]),
                      L(g2[j], g2[(j + 1) % g2.size()])))
        return 1;
    }
  return 0;
}
double distanceGP(const vector<complex<double> > &g, const complex<double> &p) {
  if (convex_contain(g, p)) return 0;
  double res = INF;
  for (int i = 0; i < (int)g.size(); ++i) {
    res = min(res, distanceSP(L(g[i], g[(i + 1) % g.size()]), p));
  }
  return res;
}
L bisector(const complex<double> &a, const complex<double> &b) {
  complex<double> A = (a + b) * complex<double>(0.5, 0);
  return L(A, A + (b - a) * complex<double>(0, PI / 2));
}
vector<complex<double> > voronoi_cell(vector<complex<double> > g,
                                      const vector<complex<double> > &v,
                                      int s) {
  for (int i = 0; i < (int)v.size(); ++i)
    if (i != s) g = convex_cut(g, bisector(v[s], v[i]));
  return g;
}
double angle(const complex<double> &a, const complex<double> &b) {
  double ret = arg(b) - arg(a);
  return (ret >= 0) ? ret : ret + 2 * PI;
}
double angle2(const complex<double> &a, const complex<double> &b) {
  return min(angle(a, b), angle(b, a));
}
double rtod(double rad) { return rad * 180 / PI; }
double dtor(double deg) { return deg * PI / 180; }
complex<double> rotate(complex<double> p, double ang) {
  return p * complex<double>(cos(ang), sin(ang));
}
L rotate(L l, double ang) { return L(rotate(l[0], ang), rotate(l[1], ang)); }
int main() {
  double w, h, a;
  while (cin >> w >> h >> a) {
    w /= 2;
    h /= 2;
    a = dtor(a);
    vector<complex<double> > g;
    g.push_back(complex<double>(-w, -h));
    g.push_back(complex<double>(w, -h));
    g.push_back(complex<double>(w, h));
    g.push_back(complex<double>(-w, h));
    vector<complex<double> > g2 = g;
    for (__typeof((g2).begin()) it = (g2).begin(); it != (g2).end(); ++it) {
      *it = rotate(*it, a);
    }
    for (int i = 0; i < (int)4; ++i) {
      g = convex_cut(g, L(g2[i], g2[(i + 1) % 4]));
    }
    double ans = area(g);
    printf("%.10f\n", ans);
  }
}
