#include <bits/stdc++.h>
using namespace std;
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 inline LE(double a, double b) { return a - 1e-9 < b; }
double inline GE(double a, double b) { return a - 1e-9 > b; }
double inline EQ(double a, double b) { return fabs(a - b) < 1e-9; }
double cross(const complex<double>& a, const complex<double>& b) {
  return imag(conj(a) * b);
}
enum { OUT, ON, IN };
int convex_contains(const vector<complex<double> >& P,
                    const complex<double>& p) {
  const int n = P.size();
  complex<double> g = (P[0] + P[n / 3] + P[2 * n / 3]) / 3.0;
  int a = 0, b = n;
  while (a + 1 < b) {
    int c = (a + b) / 2;
    if (cross(P[a] - g, P[c] - g) > 0) {
      if (cross(P[a] - g, p - g) > 0 && cross(P[c] - g, p - g) < 0)
        b = c;
      else
        a = c;
    } else {
      if (cross(P[a] - g, p - g) < 0 && cross(P[c] - g, p - g) > 0)
        a = c;
      else
        b = c;
    }
  }
  b %= n;
  if (cross(P[a] - p, P[b] - p) < 0) return 0;
  if (cross(P[a] - p, P[b] - p) > 0) return 2;
  return 1;
}
bool intersect_1pt(const complex<double>& a, const complex<double>& b,
                   const complex<double>& c, const complex<double>& d,
                   complex<double>& r) {
  double D = cross(b - a, d - c);
  if (EQ(D, 0)) return false;
  double t = cross(c - a, d - c) / D;
  double s = -cross(a - c, b - a) / D;
  r = a + t * (b - a);
  return GE(t, 0) && LE(t, 1) && GE(s, 0) && LE(s, 1);
}
vector<complex<double> > convex_intersect(const vector<complex<double> >& P,
                                          const vector<complex<double> >& Q) {
  const int n = P.size(), m = Q.size();
  int a = 0, b = 0, aa = 0, ba = 0;
  enum { Pin, Qin, Unknown } in = Unknown;
  vector<complex<double> > R;
  do {
    int a1 = (a + n - 1) % n, b1 = (b + m - 1) % m;
    double C = cross(P[a] - P[a1], Q[b] - Q[b1]);
    double A = cross(P[a1] - Q[b], P[a] - Q[b]);
    double B = cross(Q[b1] - P[a], Q[b] - P[a]);
    complex<double> r;
    if (intersect_1pt(P[a1], P[a], Q[b1], Q[b], r)) {
      if (in == Unknown) aa = ba = 0;
      R.push_back(r);
      in = B > 0 ? Pin : A > 0 ? Qin : in;
    }
    if (C == 0 && B == 0 && A == 0) {
      if (in == Pin) {
        b = (b + 1) % m;
        ++ba;
      } else {
        a = (a + 1) % m;
        ++aa;
      }
    } else if (C >= 0) {
      if (A > 0) {
        if (in == Pin) R.push_back(P[a]);
        a = (a + 1) % n;
        ++aa;
      } else {
        if (in == Qin) R.push_back(Q[b]);
        b = (b + 1) % m;
        ++ba;
      }
    } else {
      if (B > 0) {
        if (in == Qin) R.push_back(Q[b]);
        b = (b + 1) % m;
        ++ba;
      } else {
        if (in == Pin) R.push_back(P[a]);
        a = (a + 1) % n;
        ++aa;
      }
    }
  } while ((aa < n || ba < m) && aa < 2 * n && ba < 2 * m);
  if (in == Unknown) {
    if (convex_contains(Q, P[0])) return P;
    if (convex_contains(P, Q[0])) return Q;
  }
  return R;
}
void rotate(double& x, double& y, double angle) {
  double tx = x * cos(angle) - y * sin(angle);
  double ty = x * sin(angle) + y * cos(angle);
  x = tx;
  y = ty;
}
double area(const vector<complex<double> >& P) {
  double A = 0;
  for (int i = 0; i < P.size(); ++i) A += cross(P[i], P[(i + 1) % P.size()]);
  return abs(A) / 2;
}
int main() {
  int w, h, alpha;
  cin >> w >> h >> alpha;
  vector<complex<double> > p1, p2;
  p1.push_back(complex<double>(w / 2., h / 2.));
  p1.push_back(complex<double>(-w / 2., h / 2.));
  p1.push_back(complex<double>(-w / 2., -h / 2.));
  p1.push_back(complex<double>(w / 2., -h / 2.));
  for (int i = 0; i < 4; i++) {
    double x = p1[i].real(), y = imag(p1[i]);
    rotate(x, y, alpha * acos(-1.) / 180.);
    p2.push_back(complex<double>(x, y));
  }
  vector<complex<double> > p3 = convex_intersect(p1, p2);
  double ans = area(p3);
  cout.precision(7);
  cout.flags(ios::fixed);
  cout << ans << endl;
}
