Problem: Finally, "Hayabusa2" will be launched at the end of this month. When Hayabusa came back four years ago, I think many people remember the excitement all over Japan. Seven years ago, "Kaguya" was launched and sent many clear images to the earth while orbiting the moon.

<image>


The figure above shows the orbit of the moon, the positions of some moons, and the Kaguya orbiting around the moon, in spatial coordinates with the earth as the origin (assuming that the z-axis points vertically from the bottom to the top of the paper). It depicts the trajectory of. The orbit of the moon is a circle centered on the origin on a plane passing through the x-axis and y-axis. Kaguya's orbit around the moon is a circle on a plane parallel to the plane passing through the x-axis and z-axis, and its center coincides with the center of the moon. The moon shall rotate in the direction of the arrow drawn along its orbit.

In the figure on the right, the positions of the moon are A, B, and C. The straight line that crosses the moon is Kaguya's orbit. Since Kaguya orbits the moon, the orbit is a circle, but since it is viewed from the positive direction of the z-axis, it looks like a straight line parallel to the x-axis of the figure (even if the position of the moon changes, it always looks like x). Note that it is parallel to the axis). Kaguya shall rotate in the direction of the arrow drawn on its orbit.

If Kaguya hides behind the moon when viewed from the earth, it will not be able to communicate directly with the earth. You, who are in charge of controlling Kaguya, are trying to programmatically determine how much time Kaguya will hide behind the moon in a given amount of time.

Given the position of the moon with respect to the earth and the time t in minutes, create a program to find the time when Kaguya hides behind the moon between that position and t minutes later. However, the earth and Kaguya are considered to be points, and the moon is considered to be a sphere with a radius of 1800 km. The moon will orbit a radius of 380,000 km in 2500,000 seconds, and Kaguya will orbit a circle at an altitude of 100 km from the surface of the moon in 2 hours. The first position of Kaguya is the position where the orbit of Kaguya has the maximum value in the z coordinate.



input

The input is given in the following format.


m t


m (0 ≤ m <360) is an integer representation of the angle of the moon position measured counterclockwise from the positive part of the x-axis to the positive part of the y-axis in the figure above. t (1 ≤ t ≤ 10000) is an integer representing the time measured in minutes.

output

Outputs the time (minutes) that Kaguya hides behind the moon in real numbers from the first position until t minutes have passed. However, the error must not exceed plus or minus 1.0 minutes. If this condition is satisfied, any number of digits after the decimal point may be displayed.

Example

Input

90 10


Output

0.0

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;

#define REP(i, n) FOR(i, 0, n)
#define FOR(i, a, b) for(int i = a; i < b; i++)

#define PB push_back
#define PI 3.141592653589793238462643383279L

#define MOD 1000000007LL
typedef long long ll;
typedef long double ld;

#define LAR(a, b) a=max(a, (b))
#define SQ(x) ((x)*(x))

int main(){
	int m, t_;
	scanf("%d%d", &m, &t_);
	const ld t0 = 2*PI*m/360;
	const ld T = 60*t_;
	const ld ttm = 2500000;
	const ld ttk = 7200;
	const ld R = 380000;
	const ld r = 1900;
	const ld rm = 1800;
	ld ans = 0;
	REP(t, T){
		ld tm = t0 + 2*PI*t/ttm;
		ld tk = PI/2+2*PI*t/ttk;
		ld xm = R*cos(tm),
			 ym = R*sin(tm),
			 zm = 0;
		ld xk = xm + r*cos(tk),
			 yk = ym,
			 zk = zm + r*sin(tk);
		ld u = (xk*xm+yk*ym+zk*zm)/(xk*xk+yk*yk+zk*zk);
		ld xh = u*xk,
			 yh = u*yk,
			 zh = u*zk;
		ld d = sqrt(SQ(xm-xh)+SQ(ym-yh)+SQ(zm-zh));
		if(false){
			printf("%d", t);
			printf("  %.3Lf %.3Lf", tm, tk);
			printf("  M(%.3Lf %.3Lf %.3Lf)", xm, ym, zm);
			printf("  H(%.3Lf %.3Lf %.3Lf)", xh, yh, zh);
			printf("  K(%.3Lf %.3Lf %.3Lf)", xk, yk, zk);
		 	printf("  %.3Lf\n", d);
		}
		if(d < rm && u < 1){
			ans += 1;
		}
	}
	printf("%.10Lf\n", ans / 60);
}