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>
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define all(c) (c).begin(),(c).end()
#define pb push_back
#define dbg(...) do{cerr<<__LINE__<<": ";dbgprint(#__VA_ARGS__, __VA_ARGS__);}while(0);

using namespace std;

namespace std{template<class S,class T>struct hash<pair<S,T>>{size_t operator()(const pair<S,T>&p)const{return ((size_t)1e9+7)*hash<S>()(p.first)+hash<T>()(p.second);}};template<class T>struct hash<vector<T>>{size_t operator()(const vector<T> &v)const{size_t h=0;for(auto i : v)h=h*((size_t)1e9+7)+hash<T>()(i)+1;return h;}};}
template<class T>ostream& operator<<(ostream &os, const vector<T> &v){os<<"[ ";rep(i,v.size())os<<v[i]<<(i==v.size()-1?" ]":", ");return os;}template<class T>ostream& operator<<(ostream &os,const set<T> &v){os<<"{ "; for(const auto &i:v)os<<i<<", ";return os<<"}";}
template<class T,class U>ostream& operator<<(ostream &os,const map<T,U> &v){os<<"{";for(const auto &i:v)os<<" "<<i.first<<": "<<i.second<<",";return os<<"}";}template<class T,class U>ostream& operator<<(ostream &os,const pair<T,U> &p){return os<<"("<<p.first<<", "<<p.second<<")";}
void dbgprint(const string &fmt){cerr<<endl;}template<class H,class... T>void dbgprint(const string &fmt,const H &h,const T&... r){cerr<<fmt.substr(0,fmt.find(","))<<"= "<<h<<" ";dbgprint(fmt.substr(fmt.find(",")+1),r...);}
typedef long long ll;typedef vector<int> vi;typedef pair<int,int> pi;const double EPS = 1e-8, INF = 1e12, PI = acos(-1.0);
typedef complex<double> P;
namespace std{
	bool operator<(const P& a, const P& b){
		return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
	}
}
inline double cross(const P& a, const P& b){ return imag(conj(a)*b); }
inline double dot(const P& a, const P& b){ return real(conj(a)*b); }
struct L : public vector<P>{
	L(const P &a, const P &b) {
		push_back(a); push_back(b);
	}
};
typedef vector<P> G;
inline int ccw(P a, P b, P c) {
	b -= a; c -= a;
	if(cross(b, c) >  EPS)   return +1;      // counter clockwise
	if(cross(b, c) < -EPS)   return -1;      // clockwise
	if(dot(b, c)   < -EPS)   return +2;      // c--a--b on line
	if(norm(b)+EPS <norm(c)) return -2;      // a--b--c on line
	return 0;                                   // c is between a and b (inclusive)
}
G intersect(P c, double r, P p1, P p2) {
  P u = p2 - p1, v = p1 - c;
  auto a = dot(u,u), b = dot(u,v)/a, t = (dot(v,v) - r*r)/a;
  auto det = b*b - t;
  if (det <  -EPS) return {};          // no solution

  auto t1 = -b - sqrt(det), t2 = -b + sqrt(det);
  G ps;
  auto insert_if_possible = [&](P p) {
    for (auto q: ps) if (abs(dot(p-q, p-q)) < EPS) return;
    ps.push_back(p);
  };
  if (r - norm(p1-c) > - EPS) insert_if_possible(p1);
  if (t1 > -EPS && 1-t1 > -EPS) insert_if_possible(p1+t1*u);
  if (t2 > -EPS && 1-t2 > -EPS) insert_if_possible(p1+t2*u);
  if (r - norm(p2-c) > -EPS) insert_if_possible(p2);
  return ps;
}

const double rm = 1800;
const double om = 380000;
const double pm = 2500000;

const double ok = rm + 100;
const double pk = 2 * 3600;

int main(){
	cin.tie(0); cin.sync_with_stdio(0);
	int m, t; cin >> m >> t; t *= 60;
	double ans = 0;
	const int ITER = t * 10;
	
	rep(it, ITER){
		double T = t * (it + 0.5) / ITER;
		double tm = m / 180.0 * PI + T * 2 * PI / pm;
		double tk = PI / 2 + T * 2 * PI / pk;
		
		double mx = om * cos(tm), my = om * sin(tm);
		double kx = ok * cos(tk), kz = ok * sin(tk), ky = 0;
		kx += mx; ky += my;
		
		P K(kx, ky);
		P M0 (mx, my);
		P M = K * dot(M0, K) / norm(K);
		double d = abs(M - M0);
		double mr;
		if(d > rm - EPS) mr = 0;
		else mr = sqrt(rm * rm - d * d);
		
		bool hide = !intersect(P(abs(M), 0), mr, P(0, 0), P(abs(K), kz)).empty();
		if(hide) ans += 1.0 * t / ITER;
	}
	printf("%.20f\n", ans / 60);
	return 0;
}