/*
 * 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;
}

Measured memory_bytes: 1196