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:
/*
 * 0311.cc: Kaguya
 */

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
 
using namespace std;

/* constant */

typedef long double ld;

const ld MR = 1800; // km
const ld OMR = 380000; // km
const ld MP = 2500000; // sec
const ld OKR = MR + 100; // km
const ld KP = 2 * 3600; // sec

const ld PI = acosl((ld)-1.0);

/* typedef */

template <typename T>
struct Pt3d {
  T x, y, z;

  Pt3d() {}
  Pt3d(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {}
  Pt3d(const Pt3d& pt) : x(pt.x), y(pt.y), z(pt.z) {}

  bool operator==(const Pt3d pt) const {
    return x == pt.x && y == pt.y && z == pt.z;
  }
  Pt3d<T> operator+(const Pt3d pt) const {
    return Pt3d<T>(x + pt.x, y + pt.y, z + pt.z);
  }
  Pt3d<T> operator-() const {
    return Pt3d<T>(-x, -y, -z);
  }
  Pt3d<T> operator-(const Pt3d pt) const {
    return Pt3d<T>(x - pt.x, y - pt.y, z - pt.z);
  }
  Pt3d<T> operator*(T t) const {
    return Pt3d<T>(x * t, y * t, z * t);
  }
  Pt3d<T> operator/(T t) const {
    return Pt3d<T>(x / t, y / t, z / t);
  }
  T dot(Pt3d v) const { return x * v.x + y * v.y + z * v.z; }
  Pt3d<T> cross(Pt3d v) const {
    return Pt3d<T>(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
  }
  Pt3d<T> mid(const Pt3d pt) {
    return Pt3d<T>((x + pt.x) / 2, (y + pt.y) / 2, (z + pt.z) / 2);
  }
  T d2() { return x * x + y * y + z * z; }
  double d() { return sqrt(d2()); }

  Pt3d<T> rotx(double th) {
    double c = cos(th), s = sin(th);
    return Pt3d<T>(x, c * y - s * z, s * y + c * z);
  }

  Pt3d<T> roty(double th) {
    double c = cos(th), s = sin(th);
    return Pt3d<T>(s * z + c * x, y, c * z - s * x);
  }

  Pt3d<T> rotz(double th) {
    double c = cos(th), s = sin(th);
    return Pt3d<T>(c * x - s * y, s * x + c * y, z);
  }

  Pt3d<T> rotx90() { return Pt3d<T>(x, -z, y); }
  Pt3d<T> roty90() { return Pt3d<T>(z, y, -x); }
  Pt3d<T> rotz90() { return Pt3d<T>(-y, x, z); }

  bool operator<(const Pt3d& pt) const {
    return (x < pt.x || (x == pt.x && (y < pt.y || (y == pt.y && z < pt.z))));
  }

  void print(string format) {
    printf(("(" + format + ", " + format + ", " + format + ")\n").c_str(),
	   x, y, z);
  }
  void print() { print("%.6lf"); }
};

typedef Pt3d<ld> pt3d;

/* subroutines */

/* global variables */

/* subroutines */

/* main */

int main() {
  int m, t;
  cin >> m >> t;

  ld mth0 = PI * m / 180;
  int tsec = t * 60;
  int cnt = 0;
  
  for (int t0 = 0; t0 < tsec; t0++) {
    ld mth = mth0 + PI * 2 * t0 / MP; // x-y coord
    ld kth = -PI * 2 * t0 / KP; // z-x coord

    pt3d mp(OMR * cosl(mth), OMR * sinl(mth), 0.0);
    pt3d kp(mp.x + OKR * sinl(kth), mp.y, mp.z + OKR * cosl(kth));

    ld kd2 = kp.d2();
    ld dot = mp.dot(kp);
    ld cp2 = (dot * dot) / kd2;
    ld h2 = OMR * OMR - cp2;
    if (h2 <= MR * MR && kd2 > cp2) cnt++;

    //printf("t0=%d: kd2=%.Lf, cp2=%.Lf, h2=%.Lf\n",
    //t0, kd2, cp2, h2);
  }

  printf("%.2lf\n", (double)cnt / 60);
  return 0;
}