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;
struct point_i {
  int x, y;
  point_i() { x = y = 0; }
  point_i(int _x, int _y) : x(_x), y(_y) {}
};
struct point {
  double x, y;
  point() { x = y = 0.0; }
  point(double _x, double _y) : x(_x), y(_y) {}
  bool operator<(point other) const {
    if (fabs(x - other.x) > 1e-9) return x < other.x;
    return y < other.y;
  }
  bool operator==(point other) const {
    return fabs(x - other.x) < 1e-9 && fabs(y - other.y) < 1e-9;
  }
};
double dist(point p1, point p2) { return hypot(p1.x - p2.x, p1.y - p2.y); }
point rotateCCW(point p, double theta) {
  double rad = (theta * 3.1415926535) / 180.0;
  return point(p.x * cos(rad) - p.y * sin(rad),
               p.x * sin(rad) + p.y * cos(rad));
}
point rotateCW(point p, double theta) {
  double rad = (theta * 3.1415926535) / 180.0;
  return point(p.x * cos(rad) + p.y * sin(rad),
               -p.x * sin(rad) + p.y * cos(rad));
}
struct line {
  double a, b, c;
};
void pointsToLine(point p1, point p2, line &l) {
  if (fabs(p1.x - p2.x) < 1e-9) {
    l.a = 1.0;
    l.b = 0.0;
    l.c = -p1.x;
  } else {
    l.a = -(p1.y - p2.y) / (p1.x - p2.x);
    l.b = 1.0;
    l.c = -(l.a * p1.x) - p1.y;
  }
}
bool areParellel(line l1, line l2) {
  return fabs(l1.a - l2.a) < 1e-9 && fabs(l1.b - l2.b) < 1e-9;
}
bool areSame(line l1, line l2) {
  return areParellel(l1, l2) && fabs(l1.c - l2.c);
}
bool doIntersect(line l1, line l2, point &p) {
  if (areParellel(l1, l2)) return false;
  p.x = (l2.b * l1.c - l1.b * l2.c) / (l2.a * l1.b - l1.a * l2.b);
  if (fabs(l1.b) > 1e-9)
    p.y = -(l1.a * p.x + l1.c) / l1.b;
  else
    p.y = -(l2.a * p.x + l2.c) / l2.b;
  return true;
}
struct vec {
  double x, y;
  vec(double _x, double _y) : x(_x), y(_y) {}
};
vec toVec(point a, point b) { return vec(b.x - a.x, b.y - a.y); }
vec scale(vec v, double s) { vec(v.x * s, v.y * s); }
point translate(point p, vec v) { return point(p.x + v.x, p.y + v.y); }
double dot(vec a, vec b) { return (a.x * b.x + a.y * b.y); }
double norm_sq(vec v) { return v.x * v.x + v.y * v.y; }
double distToLine(point p, point a, point b, point &c) {
  vec ap = toVec(a, p), ab = toVec(a, b);
  double u = dot(ap, ab) / norm_sq(ab);
  c = translate(a, scale(ab, u));
  return dist(p, c);
}
double distToLineSegment(point p, point a, point b, point &c) {
  vec ap = toVec(a, p), ab = toVec(a, b);
  double u = dot(ap, ab) / norm_sq(ab);
  if (u < 0.0) {
    c = point(a.x, a.y);
    return dist(p, a);
  } else if (u > 1.0) {
    c = point(b.x, b.y);
    return dist(p, b);
  }
  return distToLine(p, a, b, c);
}
double angle(point a, point o, point b) {
  vec oa = toVec(o, a), ob = toVec(o, b);
  return acos(dot(oa, ob) / sqrt(norm_sq(oa) * norm_sq(ob)));
}
double cross(vec a, vec b) { return a.x * b.y - a.y * b.x; }
int whichSide(point p, point q, point r) {
  double d = cross(toVec(p, q), toVec(p, r));
  if (fabs(d) < 1e-9)
    return 0;
  else if (d > -1e-9)
    return 1;
  else
    return -1;
}
double mag(vec v) { return sqrt(norm_sq(v)); }
double areaOfTri(point a, point b, point c) {
  return fabs((a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y)) / 2);
}
void make_norm(point &p) {
  if (fabs(p.x) < 1e-9) p.x = 0.0;
  if (fabs(p.y) < 1e-9) p.y = 0.0;
}
namespace convexHull {
point pivot(0, 0);
bool angleCmp(point a, point b) {
  if (whichSide(pivot, a, b) == 0) return dist(pivot, a) < dist(pivot, b);
  double d1x = a.x - pivot.x, d1y = a.y - pivot.y;
  double d2x = b.x - pivot.x, d2y = b.y - pivot.y;
  return (atan2(d1y, d1x) - atan2(d2y, d2x)) < 0;
}
vector<point> CH(vector<point> P) {
  int i, j, n = ((int)P.size());
  if (n <= 3) {
    if (!(P[0] == P[n - 1])) P.push_back(P[0]);
    return P;
  }
  int PO = 0;
  for (int i = (1); i <= (n - 1); i++) {
    if (P[i].y < P[PO].y or
        (fabs(P[i].y - P[PO].y) < 1e-9 and P[i].x > P[PO].x))
      PO = i;
  }
  swap(P[PO], P[0]);
  pivot = P[0];
  sort(++P.begin(), P.end(), angleCmp);
  vector<point> S;
  S.push_back(P[n - 1]);
  S.push_back(P[0]);
  S.push_back(P[1]);
  i = 2;
  while (i < n) {
    j = ((int)S.size()) - 1;
    if (whichSide(S[j - 1], S[j], P[i]) > 0)
      S.push_back(P[i++]);
    else
      S.pop_back();
  }
  return S;
}
}  // namespace convexHull
void solve(int testcase) {
  double w, h, a, tot_area, b;
  cin >> w >> h >> a;
  tot_area = w * h;
  if (a == 0 or a == 180) {
    cout << tot_area;
    return;
  }
  if (a == 90) {
    cout << min(w, h) * min(w, h);
    return;
  }
  if (a > 90) a = 180 - a;
  if (w < h) swap(w, h);
  b = 2.0 * atan2(h, w) * 180 / 3.1415926535;
  point A(-w / 2, h / 2);
  point B(w / 2, h / 2);
  point C(w / 2, -h / 2);
  point D(-w / 2, -h / 2);
  point P = rotateCCW(A, a);
  point Q = rotateCCW(B, a);
  point R = rotateCCW(C, a);
  point S = rotateCCW(D, a);
  make_norm(P);
  make_norm(Q);
  make_norm(R);
  make_norm(S);
  if (fabs(a - b) < 1e-9) {
    point x;
    line sb, dc;
    pointsToLine(S, B, sb);
    pointsToLine(D, C, dc);
    doIntersect(sb, dc, x);
    cout << dist(P, x) * h << '\n';
  } else if (a > b) {
    point z, y;
    line pq, cd, sr;
    pointsToLine(P, Q, pq);
    pointsToLine(C, D, cd);
    pointsToLine(S, R, sr);
    doIntersect(pq, cd, z);
    doIntersect(sr, cd, y);
    cout << dist(z, y) * h << '\n';
  } else {
    line ab, pq, ad, ps, cd;
    point _1, _2, _3, _4;
    pointsToLine(A, B, ab);
    pointsToLine(A, D, ad);
    pointsToLine(P, S, ps);
    pointsToLine(C, D, cd);
    pointsToLine(P, Q, pq);
    doIntersect(cd, ps, _1);
    doIntersect(ad, ps, _2);
    doIntersect(ad, pq, _3);
    doIntersect(ab, pq, _4);
    if (w == h) {
      cout << tot_area - 2.0 * dist(D, _1) * dist(D, _2) << '\n';
      return;
    }
    cout << tot_area - (dist(D, _1) * dist(D, _2) + dist(A, _3) * dist(A, _4))
         << '\n';
  }
}
signed main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  cout << fixed << setprecision(10);
  clock_t b = clock();
  int t = 1;
  for (int tt = (1); tt <= (t); tt++) solve(tt);
  clock_t e = clock();
  cerr << (double(e - b) / CLOCKS_PER_SEC) << " sec";
  return 0;
}