Problem: It was decided in IT City to distinguish successes of local IT companies by awards in the form of stars covered with gold from one side. To order the stars it is necessary to estimate order cost that depends on the area of gold-plating. Write a program that can calculate the area of a star.

A "star" figure having n ≥ 5 corners where n is a prime number is constructed the following way. On the circle of radius r n points are selected so that the distances between the adjacent ones are equal. Then every point is connected by a segment with two maximally distant points. All areas bounded by the segments parts are the figure parts.

<image>

Input

The only line of the input contains two integers n (5 ≤ n < 109, n is prime) and r (1 ≤ r ≤ 109) — the number of the star corners and the radius of the circumcircle correspondingly.

Output

Output one number — the star area. The relative error of your answer should not be greater than 10 - 7.

Examples

Input

7 10


Output

108.395919545675

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
const ld pi = acosl(ld(-1));
const ld inf = 1e20;
const ld eps = 1e-8;
inline ld sqr(ld x) { return x * x; }
inline int sgn(ld x) { return (x > eps) - (x < (-eps)); }
inline int cmp(ld x, ld y) { return sgn((x - y) / max(ld(1), fabsl(x))); }
struct point {
  ld x, y;
  point() {}
  point(ld x, ld y) : x(x), y(y) {}
  void input() {
    int _x, _y;
    scanf("%d%d", &_x, &_y);
    x = _x, y = _y;
  }
  void display() { printf("%.10Lf %.10Lf\n", x, y); }
  bool operator<(const point &p) const {
    if (fabsl(x - p.x) > eps) return x < p.x;
    return y + eps < p.y;
  }
  bool operator==(const point &p) const {
    return fabsl(x - p.x) < eps && fabsl(y - p.y) < eps;
  }
};
point operator+(point p1, point p2) { return point(p1.x + p2.x, p1.y + p2.y); }
point operator-(point p1, point p2) { return point(p1.x - p2.x, p1.y - p2.y); }
point operator*(point p, ld c) { return point(p.x * c, p.y * c); }
point operator/(point p, ld c) { return point(p.x / c, p.y / c); }
ld dis(point p) { return sqrtl(sqr(p.x) + sqr(p.y)); }
ld dis(point p1, point p2) { return dis(p1 - p2); }
ld dis2(point p) { return sqr(p.x) + sqr(p.y); }
ld dis2(point p1, point p2) { return dis2(p1 - p2); }
ld vect(point p1, point p2) { return p1.x * p2.y - p2.x * p1.y; }
ld vect(point p, point p1, point p2) { return vect(p1 - p, p2 - p); }
ld scal(point p1, point p2) { return p1.x * p2.x + p1.y * p2.y; }
ld scal(point p, point p1, point p2) { return scal(p1 - p, p2 - p); }
ld getAngle(point p) { return atan2l(p.y, p.x); }
ld getAngle(point p, point p1, point p2) {
  return acosl(scal(p, p1, p2) / dis(p - p1) / dis(p - p2));
}
point normalize(point p) { return p / dis(p); }
point virt(point p) { return point(-p.y, p.x); }
point rot(point p, ld t) {
  return point(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));
}
point polar(point p, ld r, ld t) {
  return point(p.x + r * cos(t), p.y + r * sin(t));
}
point projection(point a, point b, point p) {
  return a + (a - b) * (scal(p - a, a - b) / dis2(a - b));
}
ld disToLine(point p, point p1, point p2) {
  return fabsl(vect(p, p1, p2)) / dis(p1, p2);
}
ld disToSeg(point p, point p1, point p2) {
  if (scal(p1, p, p2) < 0) return dis(p, p1);
  if (scal(p2, p, p1) < 0) return dis(p, p2);
  return disToLine(p, p1, p2);
}
bool onLine(point p, point p1, point p2) {
  return fabsl(vect(p1 - p, p2 - p)) < eps;
}
bool onSeg(point p, point p1, point p2) {
  if (!onLine(p, p1, p2)) return 0;
  return (p1.x - p.x) * (p2.x - p.x) < eps && (p1.y - p.y) * (p2.y - p.y) < eps;
}
bool cross(point p1, point p2, point p3, point p4) {
  return vect(p1, p2, p3) * vect(p1, p2, p4) < -eps &&
         vect(p3, p4, p1) * vect(p3, p4, p2) < -eps;
}
bool common(point p1, point p2, point p3, point p4) {
  if (max(p1.x, p2.x) + eps < min(p3.x, p4.x) ||
      max(p3.x, p4.x) + eps < min(p1.x, p2.x))
    return 0;
  if (max(p1.y, p2.y) + eps < min(p3.y, p4.y) ||
      max(p3.y, p4.y) + eps < min(p1.y, p2.y))
    return 0;
  return vect(p1, p2, p3) * vect(p1, p2, p4) < eps &&
         vect(p3, p4, p1) * vect(p3, p4, p2) < eps;
}
int posLineLine(point p1, point p2, point p3, point p4, point &p) {
  ld s1 = vect(p1, p2, p3), s2 = vect(p1, p2, p4);
  if (fabsl(s1 - s2) < eps) {
    if (fabsl(s1) < eps) return 2;
    return 0;
  }
  p = p3 + (p4 - p3) * (s1 / (s1 - s2));
  return 1;
}
int posCirLine(point p, ld r, point p1, point p2, point *q) {
  ld a = dis2(p1 - p2);
  ld b = scal(p1, p, p2);
  ld c = dis2(p - p1) - sqr(r);
  ld d2 = sqr(b) - a * c;
  if (d2 < -eps) return 0;
  ld d = sqrtl(fabsl(d2));
  q[0] = p1 + (p2 - p1) * ((b + d) / a);
  q[1] = p1 + (p2 - p1) * ((b - d) / a);
  if (d2 < eps) return 1;
  return 2;
}
int posCirCir(point p1, ld r1, point p2, ld r2, point *q) {
  if (p1 == p2) return 0;
  ld dx = p2.x - p1.x, dy = p2.y - p1.y;
  ld d = dis(p1 - p2);
  ld e = (sqr(r1) - sqr(r2) + sqr(d)) / 2 / d;
  ld f2 = sqr(r1) - sqr(e);
  if (f2 < -eps) return 0;
  ld f = sqrtl(fabsl(f2));
  q[0] = point(p1.x + (e * dx - f * dy) / d, p1.y + (e * dy + f * dx) / d);
  q[1] = point(p1.x + (e * dx + f * dy) / d, p1.y + (e * dy - f * dx) / d);
  if (f2 < eps) return 1;
  return 2;
}
vector<point> convex_hull(vector<point> ps) {
  if ((int)ps.size() <= 1) return ps;
  int n = ps.size(), k = 0;
  sort(ps.begin(), ps.end());
  vector<point> ch(2 * n);
  for (int i = 0; i < n; ch[k++] = ps[i++])
    while (k >= 2 && vect(ch[k - 2], ch[k - 1], ps[i]) < eps) --k;
  for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = ps[i--])
    while (k >= t && vect(ch[k - 2], ch[k - 1], ps[i]) < eps) --k;
  ch.resize(k - 1);
  return ch;
}
int n, r;
point get(ld alp) { return point((ld)r * cosl(alp), (ld)r * sinl(alp)); }
ld area(point pt[], int n) {
  ld ret = 0;
  for (int i = 0; i < n; i++) ret += vect(pt[i], pt[(i + 1) % n]);
  return fabsl(ret) / 2;
}
int main() {
  scanf("%d%d", &n, &r);
  ld ang = (ld)2 * pi / n;
  point A = get(pi / 2), B = get(pi / 2 + ang * (n / 2));
  point C = get(pi / 2 + ang), D = get(pi / 2 + ang * (n / 2 + 2));
  point thep;
  posLineLine(A, B, C, D, thep);
  point pt[4] = {point(0, 0), A, thep, C};
  printf("%.20Lf\n", area(pt, 4) * n);
  return 0;
}