Problem: You are given two rectangles on a plane. The centers of both rectangles are located in the origin of coordinates (meaning the center of the rectangle's symmetry). The first rectangle's sides are parallel to the coordinate axes: the length of the side that is parallel to the Ox axis, equals w, the length of the side that is parallel to the Oy axis, equals h. The second rectangle can be obtained by rotating the first rectangle relative to the origin of coordinates by angle α.

<image>

Your task is to find the area of the region which belongs to both given rectangles. This region is shaded in the picture.

Input

The first line contains three integers w, h, α (1 ≤ w, h ≤ 106; 0 ≤ α ≤ 180). Angle α is given in degrees.

Output

In a single line print a real number — the area of the region which belongs to both given rectangles.

The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.

Examples

Input

1 1 45


Output

0.828427125


Input

6 4 30


Output

19.668384925

Note

The second sample has been drawn on the picture above.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
bool deb_mode = 0;
class debugger {
  vector<string> vars;

 public:
  template <typename T>
  debugger &operator,(const T v) {
    stringstream ss;
    ss << v, vars.push_back(ss.str());
    return *this;
  }
  void printall() {
    int j = 0, l = vars.size();
    for (int i = 0; i < (l - 1); i++) {
      if (i) cout << ", ";
      for (j; j < vars[l - 1].size(); j++) {
        if (vars[l - 1][j] == ',') {
          j++;
          break;
        }
        cout << vars[l - 1][j];
      }
      cout << " = " << vars[i];
    }
    vars.clear();
  }
} Dbug;
template <typename T1, typename T2>
inline ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
  return os << "(" << p.first << "," << p.second << ")";
}
template <typename T>
inline ostream &operator<<(ostream &os, const vector<T> &v) {
  bool first = true;
  os << "{";
  for (unsigned int i = 0; i < v.size(); i++) {
    if (!first) os << ",";
    os << v[i];
    first = false;
  }
  return os << "}";
}
template <typename T>
inline ostream &operator<<(ostream &os, const set<T> &v) {
  bool first = true;
  os << "{";
  for (typename set<T>::const_iterator ii = v.begin(); ii != v.end(); ++ii) {
    if (!first) os << ",";
    os << *ii;
    first = false;
  }
  return os << "}";
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &os, const map<T1, T2> &v) {
  bool first = true;
  os << "{";
  for (typename map<T1, T2>::const_iterator ii = v.begin(); ii != v.end();
       ++ii) {
    if (!first) os << ",";
    os << *ii;
    first = false;
  }
  return os << "}";
}
template <typename T>
void getarray(T a[], int b, int e) {
  for (int i = b; i < e + b; i++) cin >> a[i];
}
template <typename T>
void printarray(T a[], int b, int e) {
  for (int i = b; i < e - 1 + b; i++) cout << a[i] << " ";
  if (e - 1 + b >= 0) cout << a[e - 1 + b] << endl;
}
template <typename T>
void printV(vector<T> v) {
  int sz = v.size();
  if (sz) cout << v[0];
  for (int i = 1; i < sz; i++) cout << " " << v[i];
  puts("");
}
template <typename T>
T gcd(T a, T b) {
  if (b == 0) return a;
  return gcd(b, a % b);
}
template <typename T>
T BigMod(T b, T p, T m) {
  if (p == 0) return 1;
  if (p % 2 == 0) {
    T s = BigMod(b, p / 2, m);
    return ((s % m) * (s % m)) % m;
  }
  return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T ModInv(T b, T m) {
  return BigMod(b, m - 2, m);
}
template <class T>
inline void read(T &x) {
  bool Minus = 0;
  char c;
  for (c = getchar(); c <= 32; c = getchar())
    ;
  if (c == '-') Minus = 1, c = getchar();
  for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
  if (Minus) x = -x;
}
char getc() {
  char c;
  for (c = getchar(); c <= 32; c = getchar())
    ;
  return c;
}
int CI(int &_x) { return scanf("%d", &_x); }
int CI(int &_x, int &_y) { return scanf("%d %d", &_x, &_y); }
int CI(int &_x, int &_y, int &_z) { return scanf("%d %d %d", &_x, &_y, &_z); }
int CI(int &_a, int &_b, int &_c, int &_d) {
  return scanf("%d %d %d %d", &_a, &_b, &_c, &_d);
}
template <class T>
string toString(T n) {
  ostringstream oss;
  oss << n;
  return oss.str();
}
int toInt(string s) {
  int r = 0;
  istringstream sin(s);
  sin >> r;
  return r;
}
long long int toLong(string s) {
  long long int r = 0;
  istringstream sin(s);
  sin >> r;
  return r;
}
bool isVowel(char ch) {
  ch = tolower(ch);
  if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
    return true;
  return false;
}
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
int dr8[8] = {+1, -1, +0, +0, +1, -1, -1, +1};
int dc8[8] = {+0, +0, -1, +1, +1, +1, -1, -1};
int dr4[4] = {+0, +0, +1, -1};
int dc4[4] = {-1, +1, +0, +0};
int kn8r[8] = {+1, +2, +2, +1, -1, -2, -2, -1};
int kn8c[8] = {+2, +1, -1, -2, -2, -1, +1, +2};
const double EPS = 1e-9;
const int INF = (1 << 30) - 1;
const long long int LINF = (1ll << 62) - 1;
const int mod = (int)1e9 + 7;
const int MAX = (int)1e5;
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); }
  void scan() { scanf("%lf %lf", &x, &y); }
  void print() { printf("(%lf,%lf)\n", x, y); }
  double mag2() { return (x) * (x) + (y) * (y); }
  double mag() { return sqrt(mag2()); }
  bool operator<(PT a) {
    if (x == a.x) return y < a.y;
    return x < a.x;
  }
};
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 dist(PT p, PT q) { return sqrt(dist2(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 RotateCCW90(PT p) { return PT(-p.y, p.x); }
PT RotateCW90(PT p) { return PT(p.y, -p.x); }
PT RotateCCW(PT p, double t) {
  return PT(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));
}
PT RotateCCWAroundOrigByT(PT p, PT orig, double t) {
  p = p - orig;
  p = RotateCCW(p, t);
  p = p + orig;
  return p;
}
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)); }
class LineSegment {
 public:
  PT v0;
  PT v1;
  LineSegment() {}
  LineSegment(const PT &begin, const PT &end) : v0(begin), v1(end) {}
  enum IntersectResult {
    PARALLEL,
    COINCIDENT,
    NOT_INTERESECTING,
    INTERESECTING
  };
  IntersectResult Intersect(const LineSegment &L, PT &intersection) {
    double denom = ((L.v1.y - L.v0.y) * (v1.x - v0.x)) -
                   ((L.v1.x - L.v0.x) * (v1.y - v0.y));
    double nume_a = ((L.v1.x - L.v0.x) * (v0.y - L.v0.y)) -
                    ((L.v1.y - L.v0.y) * (v0.x - L.v0.x));
    double nume_b =
        ((v1.x - v0.x) * (v0.y - L.v0.y)) - ((v1.y - v0.y) * (v0.x - L.v0.x));
    if (denom == 0.0f) {
      if (nume_a == 0.0f && nume_b == 0.0f) return COINCIDENT;
      return PARALLEL;
    }
    double ua = nume_a / denom;
    double ub = nume_b / denom;
    if (ua >= 0.0f && ua <= 1.0f && ub >= 0.0f && ub <= 1.0f) {
      intersection.x = v0.x + ua * (v1.x - v0.x);
      intersection.y = v0.y + ua * (v1.y - v0.y);
      return INTERESECTING;
    }
    return NOT_INTERESECTING;
  }
};
PT V[100];
int hull[100];
int Turn(PT &V0, PT &V1, PT &V2) {
  double v = cross((V1 - V0), (V2 - V0));
  if (fabs(v) < EPS) return 0;
  if (v > 0) return 1;
  return -1;
}
bool cmp(PT V1, PT V2) {
  int t = Turn(V[0], V1, V2);
  if (!t) {
    return (V1 - V[0]).mag2() < (V2 - V[0]).mag2();
  }
  return t > 0;
}
int cHull(int N) {
  int loleft = 0, i = 0, top = 0;
  if (N <= 2) {
    hull[top++] = 0;
    if (N == 2) hull[top++] = 1;
    return top;
  }
  for (i = 1; i < N; i++) {
    if (V[loleft].y == V[i].y) {
      if (V[loleft].x > V[i].x) loleft = i;
    }
    if (V[loleft].y > V[i].y) loleft = i;
  }
  swap(V[0], V[loleft]);
  sort(V + 1, V + N, cmp);
  hull[top++] = 0;
  hull[top++] = 1;
  for (i = 2; i < N; i++) {
    while (Turn(V[hull[top - 2]], V[hull[top - 1]], V[i]) < 1 && top > 1) top--;
    hull[top++] = i;
  }
  return top;
}
int main() {
  if (deb_mode) srand(int(time(NULL)));
  int i, j, k, l, n, m, q, a, b, c;
  double w, h, angel;
  cin >> w >> h >> angel;
  if (angel > 90) angel = 180 - angel;
  angel = (acos(-1.0) / 180.0) * angel;
  LineSegment L1[4], L2[4];
  L1[0] = LineSegment(PT(w / 2, -h / 2), PT(w / 2, h / 2));
  L1[1] = LineSegment(PT(w / 2, h / 2), PT(-w / 2, h / 2));
  L1[2] = LineSegment(PT(-w / 2, h / 2), PT(-w / 2, -h / 2));
  L1[3] = LineSegment(PT(-w / 2, -h / 2), PT(w / 2, -h / 2));
  L2[0] = LineSegment(RotateCCWAroundOrigByT(L1[0].v0, PT(0, 0), angel),
                      RotateCCWAroundOrigByT(L1[0].v1, PT(0, 0), angel));
  L2[1] = LineSegment(RotateCCWAroundOrigByT(L1[1].v0, PT(0, 0), angel),
                      RotateCCWAroundOrigByT(L1[1].v1, PT(0, 0), angel));
  L2[2] = LineSegment(RotateCCWAroundOrigByT(L1[2].v0, PT(0, 0), angel),
                      RotateCCWAroundOrigByT(L1[2].v1, PT(0, 0), angel));
  L2[3] = LineSegment(RotateCCWAroundOrigByT(L1[3].v0, PT(0, 0), angel),
                      RotateCCWAroundOrigByT(L1[3].v1, PT(0, 0), angel));
  int inx = 0;
  for (i = 0; i < 4; i++)
    for (j = 0; j < 4; j++) {
      PT p;
      if (L1[i].Intersect(L2[j], p) == 3) {
        V[inx++] = p;
      }
    }
  inx = cHull(inx);
  vector<PT> HullA;
  for (i = 0; i < inx; i++) {
    HullA.push_back(V[hull[i]]);
  }
  if (deb_mode) {
    cout << "Line= " << 383 << " -> ";
    Dbug, HullA, "HullA";
    Dbug.printall();
    cout << endl;
  };
  double area = ComputeArea(HullA);
  cout << fixed << setprecision(10) << area << "\n";
  if (deb_mode) cerr << "TIME = " << clock() << " ms" << endl;
  return 0;
}