NN is an experienced internet user and that means he spends a lot of time on the social media. Once he found the following image on the Net, which asked him to compare the sizes of inner circles:

<image>

It turned out that the circles are equal. NN was very surprised by this fact, so he decided to create a similar picture himself.

He managed to calculate the number of outer circles n and the radius of the inner circle r. NN thinks that, using this information, you can exactly determine the radius of the outer circles R so that the inner circle touches all of the outer ones externally and each pair of neighboring outer circles also touches each other. While NN tried very hard to guess the required radius, he didn't manage to do that. 

Help NN find the required radius for building the required picture.

Input

The first and the only line of the input file contains two numbers n and r (3 ≤ n ≤ 100, 1 ≤ r ≤ 100) — the number of the outer circles and the radius of the inner circle respectively.

Output

Output a single number R — the radius of the outer circle required for building the required picture. 

Your answer will be accepted if its relative or absolute error does not exceed 10^{-6}.

Formally, if your answer is a and the jury's answer is b. Your answer is accepted if and only when (|a-b|)/(max(1, |b|)) ≤ 10^{-6}.

Examples

Input

3 1


Output

6.4641016


Input

6 1


Output

1.0000000


Input

100 100


Output

3.2429391
    import java.util.*;

    import javax.lang.model.util.ElementScanner6;

    import java.io.*;

    public class Main{

        public static void main(String[] args) {

            InputStream inputStream = System.in;
            OutputStream outputStream = System.out;
            InputReader inp = new InputReader(inputStream);
            PrintWriter out = new PrintWriter(outputStream);
            Solver solver = new Solver();
            solver.solve(inp, out);
            out.close();
            
            }



        static class Solver {


            class Node implements Comparable<Node>{
                int i;
                long c;
            
                Node(int i,long c)
                {
                    this.i=i;
                    this.c=c;
                    

                }

            public int compareTo(Node n)
                {
                    return Long.compare(this.c, n.c);
                }
            }

            public boolean done(int[] sp,int[] par)
            {
                int root;

                root=findSet(sp[0],par);
                
            for(int i=1;i<sp.length;i++)
            {
                    if(root!=findSet(sp[i], par))
                        return false;
            }
            return true;
            }
        public int findSet(int i,int[] par)
        {
            int x =i;
                boolean flag =false;
                while(par[i]>=0)
                {
                    flag = true;
                    i=par[i];
                }
                if(flag)
                    par[x]=i;
                return i;
        }

        public void unionSet(int i,int j,int[] par)
        {
                int x = findSet(i, par);
                int y = findSet(j, par);
                if(x<y)
                {
                    par[y]=x;
                }
                else
                {
                    par[x]=y;
                }
        }

        public  long pow(long a, long b, long MOD) {
                if (b == 0) {
                    return 1;
                }
                if (b == 1) {
                    return a;
                }
                long val = pow(a, b / 2, MOD);
                if (b % 2 == 0) {
                    return val * val % MOD;
                } else {
                    return val * (val * a % MOD) % MOD;

                }
            
            }


            public void minPrimeFactor(int n,int[] s)
            {
                boolean prime[] = new boolean[n+1];
                Arrays.fill(prime, true);
                s[1]=1;
                s[2]=2;
                for(int i=4;i<=n;i+=2)
                {
                    prime[i]=false;
                    s[i]=2;
                }

                for(int i=3;i<=n;i+=2)
                {
                    if(prime[i])
                    {
                        s[i]=i;
                        for(int j=2*i;j<=n;j+=i)
                        {
                            prime[j]=false;
                            s[j]=i;
                        }
                    }
                }
                
            }

            
            // public void findAllPrime(int n,ArrayList<Node> al,int s[])
            // {
            //     int curr = s[n];
            //     int cnt = 1;
            //     while(n>1)
            //     {
            //         n/=s[n];
            //         if(curr==s[n])
            //         {
            //             cnt++;
            //             continue;

            //         }
            //         Node n1 = new Node(curr,cnt);
            //         al.add(n1);

            //         curr=s[n];
            //         cnt=1;
            //     }
            // }

            

            public int binarySearch(int n,int k)
            {
                int left=1;
                int right=100000000+5;
                int ans=0;
                while(left<=right)
                {
                    int mid = (left+right)/2;
                    if(n/mid>=k)
                    {
                        left = mid+1;
                        ans=mid;
                    }
                    else
                    {
                        right=mid-1;
                    }
                }

                return ans;
            }
            public boolean checkPallindrom(String s)
            {
                char ch[] = s.toCharArray();

                for(int i=0;i<s.length()/2;i++)
                {
                    if(ch[i]!=ch[s.length()-1-i])
                        return false;
                }
                return true;
            }


            public void dfs_util(ArrayList<Integer>[] al,boolean vis[],int x,int cnt[],int sts[],int fts[],long sv[])
            {
                    
                vis[x] = true;
                long min=Long.MAX_VALUE;
                    sts[cnt[0]]=x+1;
                    for(int i=0;i<al[x].size();i++)
                    {
                        
                        if(!vis[al[x].get(i)])
                        {
                            cnt[0]++;
                            dfs_util(al, vis, al[x].get(i),cnt,sts,fts,sv);
                            if(sv[al[x].get(i)]<min&&sv[al[x].get(i)]!=-1)
                            {
                                min=sv[al[x].get(i)];
                            }
                            
                            
                        }    
                        
                    }

                
                    if(sv[x]==-1)
                    {
                        if(min==Long.MAX_VALUE)
                        {
                            min=-1;
                        }
                        sv[x]=min;
                    }
                
                
                return ;
            }

            public void dfs(ArrayList[] al,int sts[],int fts[],long sv[])
            {
                
            boolean vis[] = new boolean[al.length];
            int cnt[]= new int[2*al.length+2];
            for(int i=0;i<al.length;i++)
            {
                    if(!vis[i])
                    {
                        
                        dfs_util(al,vis,i,cnt,sts,fts,sv);
                    }
            }
            }
    
            public void remove(ArrayList<Integer>[] al,int x)
            {
                for(int i=0;i<al.length;i++)
                {
                    for(int j=0;j<al[i].size();j++)
                    {

                        if(al[i].get(j)==x)
                            al[i].remove(j);

                    }
                }
            }

            public int gcd(int a, int b) 
            { 
                if (a == 0) 
                    return b; 
                return gcd(b % a, a); 
            }


            public void printDivisors(long n,ArrayList<Long> al) 
            { 
                // Note that this loop runs till square root 
                for (long i=1; i<=Math.sqrt(n); i++) 
                { 
                    if (n%i==0) 
                    { 
                        // If divisors are equal, print only one 
                        if (n/i == i) 
                            al.add(i);
            
                        else // Otherwise print both 
                            al.add(i);
                            al.add(n/i);
                    } 
                } 
            } 

            private void solve(InputReader inp, PrintWriter out1) {

               int n = inp.nextInt();
               double R = (double)inp.nextInt();
                double theta = 360.0/(double)n;
                double x = (180-theta)/2.0;
                // out1.println(x+" "+theta);
                // out1.println("sin "+Math.sin(x*(Math.PI/180)) );
                double ans = R*Math.sin(theta*(Math.PI/180))/((2*Math.sin(x*(Math.PI/180)))-Math.sin(theta*(Math.PI/180)));
                out1.println(ans);
                }

    }





        static class InputReader {
            BufferedReader reader;
            StringTokenizer tokenizer;

            InputReader(InputStream stream) {
                reader = new BufferedReader(new InputStreamReader(stream), 32768);
                tokenizer = null;
            }

            String next() {
                while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                    try {
                        tokenizer = new StringTokenizer(reader.readLine());
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
                return tokenizer.nextToken();
            }

            public int nextInt() {
                return Integer.parseInt(next());
            }

            public long nextLong() {
                return Long.parseLong(next());
            }
        }
    }
    class ele{
        long value;
        long i;
        boolean flag;
        public ele(long value,long i)
        {
            this.value = value;
            this.i=i;
            this.flag = false;
        }
    }