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.
The only line of the input contains two integers *n* (5 ≤ *n* &lt; 10<sup class="upper-index">9</sup>, *n* is prime) and *r* (1 ≤ *r* ≤ 10<sup class="upper-index">9</sup>) — the number of the star corners and the radius of the circumcircle correspondingly.
none
7 10
108.395919545675
5 1
1.122569941449
7 1000
1083959.195456745256
11 1000000000
1061689977712182980.125000000000
999999937 1
1.047197551197
999999929 2
4.188790204786
999999929 1000000000
1047197551196597556.500000000000
603530531 585244
358676198261.124618709087
7369339 31415926
1033542520749354.968872070312
2341 5001
26190419.663812126875
from collections import defaultdict
from collections import deque
from collections import Counter
import bisect
import heapq
import sys
import copy
import os
import math
from io import BytesIO, IOBase, StringIO
sys.setrecursionlimit(2 * 10 ** 9)


def is_prime(x):
    for i in range(2, int(x ** 0.5 + 1)):
        if x % i == 0:
            return True
    return False


# def dj(G, src):
#     visited = set()
#     res = [-1] * len(G)
#     res[src] = 0
#     hp = [(0, src)]
#     def dfs(x):
#         if x in visited:
#             return
#         visited.add(x)
#         for nb in G[x].keys():
#             dfs(nb)
#     for _ in range(len(G)):
#         dfs(heapq.heappop(hp))
#     return res


def read_weighted_graph(n, m):
    G = [dict() for _ in range(n)]
    for i in range(m):
        a, b, w = read(int)
        a -= 1
        b -= 1
        G[a][b] = w
        G[b][a] = w
    # degs = [len(G[v]) for v in range(n)]
    return G


def read_graph(n, m):
    G = [deque() for _ in range(n)]
    for i in range(m):
        a, b = read(int)
        a -= 1
        b -= 1
        G[a].append(b)
        G[b].append(a)
    # degs = [len(G[v]) for v in range(n)]
    return G

def read_tree(n):
    G = [deque() for _ in range(n)]
    arr = read(int)
    for i in range(n - 1):
        a = arr[i]
        a -= 1
        G[a].append(i + 1)
    return G

def read(cast_type):
    return [cast_type(x) for x in input().split()]


def is_two_power(x):
    if x == 1:
        return True
    return (x % 2 == 0) and is_two_power(x // 2)



def line(pt1, pt2):
    a, b = pt1
    c, d = pt2
    tmp = (b - d)/(a - c)
    return tmp, b - tmp * a

def cross(line1, line2):
    a, b = line1
    c, d = line2
    tmp = (d - b) / (a - c)
    return tmp, a * tmp + b

def solve():
    n, r = read(int)
    theta = (2 * math.pi) / n

    def kth(k):
        return (math.cos(theta * k) * r, math.sin(theta * k) * r)


    a = kth(0)
    b = kth(1)
    p = kth(n//2)
    q = kth(n//2 + 2)
    ap = line(a, p)
    bq = line(b, q)
    ab = line(a, b)
    i, j = ab
    x, y = cross(ap, bq)
    k = (y - j) / i
    res = (k - x) * b[1] / 2
    sq = (n * math.sin(theta) * r * r) / 2
    res = sq - res * n
    print(res)


def qi():
    s = input()
    ans = 0
    res = []
    n = len(s)
    for k in range(1, min(6, n + 1)):
        num = int(s[:k])
        ahd = num - 1
        chance = 1
        flag = True
        i = k
        while i < n:
            tmp = str(num + 1)
            m = len(tmp)
            if tmp != s[i: i + m]:
                if chance == 0:
                    flag = False
                    break
                else:
                    ahd = num + 1
                    chance -= 1
            else:
                i += m
            num += 1
        if flag:
            if chance == 1:
                if ahd != 0:
                    ans += 1
                    res.append(ahd)
                if num != 99999:
                    ans += 1
                    res.append(num + 1)
            else:
                ans += 1
                res.append(ahd)
    res.sort()
    print(ans)
    print(' '.join(map(str, res)))


class trio:
    def __init__(self):
        self.pdic = dict()
        self.sdic = dict()

    def add(self, w):
        self.sub_add(self.pdic, w, 0)
        self.ssub_add(self.sdic, w, len(w) - 1)

    def sub_add(self, cur, w, i):
        if i == len(w):
            cur[0] = w
        else:
            c = w[i]
            if c not in cur.keys():
                cur[c] = dict()
            self.sub_add(cur[c], w, i + 1)

    def ssub_add(self, cur, w, i):
        if i == -1:
            cur[0] = w
        else:
            c = w[i]
            if c not in cur.keys():
                cur[c] = dict()
            self.ssub_add(cur[c], w, i - 1)

    def get(self, d):
        if type(d) == str or type(d) == int:
            return set()
        res = set()
        if 0 in d.keys():
            res.add(d[0])
        for v in d.values():
            res = res.union(self.get(v))
        return res

    def pfx(self, p):
        cur = self.pdic
        i = 0
        n = len(p)
        while i < n and cur != -1:
            cur = cur.get(p[i], -1)
            i += 1
        return self.get(cur)

    def sfx(self, s):
        cur = self.sdic
        s = s[::-1]
        i = 0
        n = len(s)
        while i < n and cur != -1:
            cur = cur.get(s[i], -1)
            i += 1
        return self.get(cur)

def qj():
    n, q = read(int)
    t = trio()
    for i in range(n):
        w = input()
        t.add(w)
    for i in range(q):
        cmd, p, s = input().split()
        pf = t.pfx(p)
        sf = t.sfx(s)
        res = 0
        if cmd == 'AND':
            res = len(pf.intersection(sf))
        elif cmd == 'OR':
            res = len(pf.union(sf))
        elif cmd == 'XOR':
            res = len(pf.union(sf)) - len(pf.intersection(sf))
        print(res)


def qk():
    n, m = read(int)
    G = read_weighted_graph(n, m)
    print(G)

def main():
    t = 1 #int(input())
    for _ in range(t):
        solve()


# BUFSIZE = 8192
#
# class FastIO(IOBase):
#     newlines = 0
#
#     def __init__(self, file):
#         self._fd = file.fileno()
#         self.buffer = BytesIO()
#         self.writable = "x" in file.mode or "r" not in file.mode
#         self.write = self.buffer.write if self.writable else None
#
#     def read(self):
#         while True:
#             b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
#             if not b:
#                 break
#             ptr = self.buffer.tell()
#             self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
#         self.newlines = 0
#         return self.buffer.read()
#
#     def readline(self, *args, **kwargs):
#         while self.newlines == 0:
#             b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
#             self.newlines = b.count(b"\n") + (not b)
#             ptr = self.buffer.tell()
#             self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
#         self.newlines -= 1
#         return self.buffer.readline()
#
#     def flush(self):
#         if self.writable:
#             os.write(self._fd, self.buffer.getvalue())
#             self.buffer.truncate(0), self.buffer.seek(0)
#
#
# class IOWrapper(IOBase):
#     def __init__(self, file):
#         self.buffer = FastIO(file)
#         self.flush = self.buffer.flush
#         self.writable = self.buffer.writable
#         self.write = lambda s: self.buffer.write(s.encode("ascii"))
#         self.read = lambda: self.buffer.read().decode("ascii")
#         self.readline = lambda: self.buffer.readline().decode("ascii")


# sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

if __name__ == "__main__":
    main()
