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<iostream>
#include<cmath>
#include<cstdio>
#include<algorithm>
using namespace std;
const long double PI = 3.14159265358979323846l;
const long double Moon_T = 41666.666666666667l;
const long double Moon_S = 1800.0000000000000l;
const long double Kaguya_S = 1900.00000000000l;
const long double Kaguya_T = 120.000000000000l;
const long double Dist = 380000.0000000000000l;
long double start, times;

struct Point { long double x, y, z; };
long double SIN(long double r) { return sin(r*PI / 180.0l); }
long double COS(long double r) { return cos(r*PI / 180.0l); }
Point getpoint(long double r, long double t) {
	Point mn = Point{ Dist*COS(r), Dist*SIN(r), 0.0l };
	Point Kgy = { mn.x - Kaguya_S*SIN(t / Kaguya_T*360.0l),mn.y, mn.z + Kaguya_S*COS(t / Kaguya_T*360.0l) };
	return Kgy;
}
long double dist(Point a, Point b) {
	long double a1 = (a.x - b.x)*(a.x - b.x);
	long double a2 = (a.y - b.y)*(a.y - b.y);
	long double a3 = (a.z - b.z)*(a.z - b.z);
	return sqrtl(a1 + a2 + a3);
}
long double dst(Point a, Point b) {
	long double L1 = 375000, R1 = 385000, c1, c2;
	long double A1 = dist(Point{ 0,0,0 }, b);
	R1 = A1;
	long double Ax1 = b.x / A1;
	long double Ay1 = b.y / A1;
	long double Az1 = b.z / A1;
	long double minx = 1000000000.0l;
	for (int i = 0; i < 60; i++) {
		c1 = (L1 + L1 + R1) / 3.0l;
		c2 = (L1 + R1 + R1) / 3.0l;
		Point RR1 = { Ax1*c1,Ay1*c1,Az1*c1 };
		Point RR2 = { Ax1*c2,Ay1*c2,Az1*c2 };
		long double d1 = dist(a, RR1);
		long double d2 = dist(a, RR2);
		if (d1 < d2)R1 = c2;
		if (d1 > d2)L1 = c1;
		minx = min(minx, min(d1, d2));
	}
	return minx;
}
long double solve(long double t) {
	long double rr = (start / 360.0l + (t / Moon_T))*360.0l;
	Point PP1 = getpoint(rr, t);
	Point PP2 = Point{ Dist*COS(rr), Dist*SIN(rr), 0.0l };
	long double ans = dst(PP2, PP1);
	return ans;
}
int main() {
	cin >> start >> times; long double cnt = 0.0l;
	for (long double i = 0.0l; i < times; i += 0.005l) {
		if (solve(i) < Moon_S)cnt += 0.005l;
	}
	printf("%.12Lf\n", cnt);
	return 0;
}