Problem: 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

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;

public class Codeforces {

	private static Print writer;

	private static Scan reader;

	static class Scan {
		private byte[] buf = new byte[1024]; // Buffer of Bytes
		private int index;
		private InputStream in;
		private int total;

		public Scan() throws IOException {
			in = System.in;
		}

		int next() throws IOException { // Scan method used to scan buf
			if (total < 0)
				throw new InputMismatchException();
			if (index >= total) {
				index = 0;
				total = in.read(buf);
				if (total <= 0)
					return -1;
			}
			return buf[index++];
		}

		int ni() throws IOException {
			int integer = 0;
			int n = next();
			while (isWhiteSpace(n)) // Removing startPointing whitespaces
				n = next();
			int neg = 1;
			if (n == '-') { // If Negative Sign encounters
				neg = -1;
				n = next();
			}
			while (!isWhiteSpace(n)) {
				if (n >= '0' && n <= '9') {
					integer *= 10;
					integer += n - '0';
					n = next();
				} else
					throw new InputMismatchException();
			}
			return neg * integer;
		}

		long nl() throws IOException {
			long integer = 0;
			int n = next();
			while (isWhiteSpace(n)) // Removing startPointing whitespaces
				n = next();
			int neg = 1;
			if (n == '-') { // If Negative Sign encounters
				neg = -1;
				n = next();
			}
			while (!isWhiteSpace(n)) {
				if (n >= '0' && n <= '9') {
					integer *= 10;
					integer += n - '0';
					n = next();
				} else
					throw new InputMismatchException();
			}
			return neg * integer;
		}

		String line() throws IOException {
			StringBuilder sb = new StringBuilder();
			int n = next();
			while (isWhiteSpace(n))
				n = next();
			while (!isNewLine(n)) {
				sb.append((char) n);
				n = next();
			}
			return sb.toString();
		}

		private boolean isNewLine(int n) {
			return n == '\n' || n == '\r' || n == -1;
		}

		private boolean isWhiteSpace(int n) {
			return n == ' ' || isNewLine(n) || n == '\t';
		}

		int[] nia(int n) throws Exception {
			if (n < 0)
				throw new Exception("Array size should be non negative");
			int[] array = new int[n];
			for (int i = 0; i < n; i++)
				array[i] = ni();
			return array;
		}

		int[][] n2dia(int r, int c) throws Exception {
			if (r < 0 || c < 0)
				throw new Exception("Array size should be non negative");
			int[][] array = new int[r][c];
			for (int i = 0; i < r; i++)
				array[i] = nia(c);
			return array;
		}

		long[] nla(int n) throws Exception {
			if (n < 0)
				throw new Exception("Array size should be non negative");
			long[] array = new long[n];
			for (int i = 0; i < n; i++)
				array[i] = nl();
			return array;
		}

		float[] nfa(int n) throws Exception {
			if (n < 0)
				throw new Exception("Array size should be non negative");
			float[] array = new float[n];
			for (int i = 0; i < n; i++)
				array[i] = nl();
			return array;
		}

		double[] nda(int n) throws Exception {
			if (n < 0)
				throw new Exception("Array size should be non negative");
			double[] array = new double[n];
			for (int i = 0; i < n; i++)
				array[i] = nl();
			return array;
		}
	}

	static class Print {
		private final BufferedWriter bw;

		Print() {
			bw = new BufferedWriter(new OutputStreamWriter(System.out));
		}

		<T> void print(T str) {
			try {
				bw.append(str.toString());
			} catch (IOException e) {
				System.out.println(e.toString());
			}
		}

		void println() {
			print("\n");
		}

		<T> void println(T str) {
			print(str + "\n");
		}

		void flush() throws IOException {
			bw.flush();
		}

		void close() {
			try {
				bw.close();
			} catch (IOException e) {
				System.out.println(e.toString());
			}
		}
	}

	public static void main(String[] args) throws Exception {
		long startPointTime = System.currentTimeMillis();
		reader = new Scan();
		writer = new Print();
		main2();
		long endTime = System.currentTimeMillis();
		float totalProgramTime = endTime - startPointTime;
		if (args.length > 0 && args[0].equals("time"))
			writer.print("Execution time is " + totalProgramTime + " (" + (totalProgramTime / 1000) + "s)");
		writer.close();
	}

	static class DisjointSet {
		int[] arr;
		int[] size;

		DisjointSet(int n) {
			arr = new int[n + 1];
			size = new int[n + 1];
			makeSet();
		}

		void makeSet() {
			for (int i = 1; i < arr.length; i++) {
				arr[i] = i;
				size[i] = 1;
			}
		}

		void union(int i, int j) {
			if (i == j)
				return;
			if (i > j) {
				i ^= j;
				j ^= i;
				i ^= j;
			}

			i = find(i);
			j = find(j);

			if (i == j)
				return;
			arr[j] = arr[i];
			size[i] += size[j];
			size[j] = size[i];
		}

		int find(int i) {
			if (arr[i] != i) {
				arr[i] = find(arr[i]);
				size[i] = size[arr[i]];
			}
			return arr[i];
		}

		int getSize(int i) {
			i = find(i);
			return size[i];
		}

		public String toString() {
			return Arrays.toString(arr);
		}
	}

	static long MOD = 1_000_000_007L;

	static void main2() throws Exception {
		double n = reader.ni();
		double r = reader.ni();
		double angle = (2 * Math.PI) / n;
		double cos = Math.cos(angle);
		double p = 1 - cos;

		double ans = Math.sqrt(4*r*r*p*p + 4*(2-p)*(p*r*r));
		ans+=2*r*p;
		ans /= 2 * (2 - p);
		writer.println(ans);
	}

	static long gcd(long a, long b) {
		if (b == 0)
			return a;
		return gcd(b, a % b);
	}
}