#define _USE_MATH_DEFINES
#include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define reps(i, n) for (int i = 1; i <= (n); ++i)
#define repd(i, n) for (int i = (n)-1; i >= 0; --i)
#define repds(i, n) for (int i = (n); i > 0; --i)
#define loop(i, x, n) for (int i = (x); i < (n); ++i)
#define loops(i, x, n) for (int i = (x); i <= (n); ++i)
#define loopd(i, x, n) for (int i = (x); i > (n); --i)
#define loopds(i, x, n) for (int i = (x); i >= (n); --i)
#define itrep(i, a) for (auto i = begin(a); i != end(a); ++i)
#define itrepd(i, a) for (auto i = rbegin(a); i != rend(a); ++i)
#define each(i, x) for (auto &&i : x)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define sz(a) ((int)a.size())
#define pow2(n) (n * n)
// #define int ll
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
template <class T>
using priority_queuel = priority_queue<T, vector<T>, greater<T>>;
constexpr ll inf = static_cast<ll>(1e18);
constexpr int iinf = static_cast<int>(1e9);
constexpr double dinf = 1e10;
constexpr ld ldinf = 1e18;
constexpr double eps = 1e-9;
ll mod = static_cast<ll>(1e9 + 7);
template <class T, class... Args>
constexpr void mins(T &a, Args... args) { a = min<T>({a, args...}); }
template <class T, class... Args>
constexpr void maxs(T &a, Args... args) { a = max<T>({a, args...}); }
template <class F>
class FixPoint : private F {
public:
    explicit constexpr FixPoint(F &&f) : F(std::forward<F>(f)) {}
    template <class... Args>
    constexpr decltype(auto) operator()(Args &&... args) const { return F::operator()(*this, std::forward<Args>(args)...); }
};
template <class F>
constexpr decltype(auto) funcs(F &&f) { return FixPoint<F>{std::forward<F>(f)}; }
template <class T>
std::vector<T> vecs(int n, T &&val) { return std::vector<T>(std::forward<int>(n), std::forward<T>(val)); }
template <class... Args>
decltype(auto) vecs(int n, Args &&... args) { return std::vector<decltype(vecs(std::forward<Args>(args)...))>(std::forward<int>(n), vecs(std::forward<Args>(args)...)); }
template <class V, class T>
void fill(V &x, const T &val) { x = val; }
template <class V, class T>
void fill(vector<V> &vec, const T &val) {
    for (auto &&v : vec)
        fill(v, val);
}

template <class T>
struct VecPoint {
    T x, y;
    int id;
    VecPoint(T x = 0, T y = 0, int id = 0) : x(x), y(y), id(id) {}
    VecPoint &operator+=(const VecPoint &v) {
        x += v.x;
        y += v.y;
        return *this;
    }
    VecPoint operator+(const VecPoint &v) const { return VecPoint(*this) += v; }
    VecPoint &operator-=(const VecPoint &v) {
        x -= v.x;
        y -= v.y;
        return *this;
    }
    VecPoint operator-(const VecPoint &v) const { return VecPoint(*this) -= v; }
    VecPoint &operator*=(T s) {
        x *= s;
        y *= s;
        return *this;
    }
    VecPoint operator*(T s) const { return VecPoint(*this) *= s; }
    VecPoint &operator/=(T s) {
        x /= s;
        y /= s;
        return *this;
    }
    VecPoint operator/(T s) const { return VecPoint(*this) /= s; }
    T dot(const VecPoint &v) const { return x * v.x + y * v.y; }
    T cross(const VecPoint &v) const { return x * v.y - v.x * y; }
    VecPoint rotate90() const { return VecPoint(y, -x); }
    T norm2() const { return x * x + y * y; }
    T norm() const { return sqrt(norm2()); }
    int ort() const {
        if (abs(x) < eps && abs(y) < eps) return 0;
        if (y > 0)
            return x > 0 ? 1 : 2;
        else
            return x > 0 ? 4 : 3;
    }
    //bool operator<(const VecPoint& v) const {
    //    int o = ort(), vo = v.ort();
    //    if (o != vo) return o < vo;
    //    return cross(v) > 0;
    //}
    bool operator<(const VecPoint &v) const {
        return x < v.x || (x == v.x && y < v.y);
    }
};
using Point = VecPoint<ld>;

void solve() {
    ld a, b, h, m;
    cin >> a >> b >> h >> m;
    ld deg = M_PI * 2 * (h + m / 60) / 12;
    ld deg2 = M_PI * 2 * m / 60;
    Point s = {a * cos(deg), a * sin(deg)};
    Point t = {b * cos(deg2), b * sin(deg2)};
    cout << (s - t).norm() << endl;
}

signed main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    solve();
    cout.flush();
    return 0;
}

Measured memory_bytes: 4188