Have you driven a fjord lately?

#include <bits/stdc++.h>

using namespace std;

#define llong long long int
#define ldouble long double
#define Vector Point

const ldouble EPS = 1e-6;
const ldouble INF = 1e18 + 5;

int sign(ldouble x) {
    return fabsl(x) < EPS ? 0 : (x < 0 ? -1 : 1);
}

template<typename T>
struct Point {
    T x, y;

    Point(): x(0), y(0) {}
    Point(T x, T y): x(x), y(y) {}

    Vector<T> operator -(Point<T> other) {
        return Vector<T>(x - other.x, y - other.y);
    }

    T operator *(Vector<T> other) {
        return x * other.x + y * other.y;
    }
};

template<typename T>
ldouble abs(Vector<T> v) {
    return sqrtl(v * v);
}

template<typename T>
ldouble angle(Vector<T> u, Vector<T> v) {
    return acosl(u * v / abs(u) / abs(v));
}

int n, m;
vector<Point<ldouble>> points;
vector<vector<ldouble>> memo;

ldouble savings(ldouble a, ldouble c, ldouble theta, ldouble mx) {
    ldouble left = a * cosl(theta);
    ldouble right = sqrtl(a * a * cosl(theta) * cosl(theta) - a * a + c * c);
    cout << a << " " << c << " " << theta << " " << (left + right) << " " << mx << " " << (left + right - mx) << " " << (fabsl(left + right - mx) < EPS) << " " << (left - right) << "\n";
    return sign(left + right - mx) <= 0 ? left + right : (sign(left - right) >= 0 ? left - right : -INF);
}

ldouble savings(int fjord, int bridge) {
    Vector<ldouble> u = points[fjord] - points[fjord + 1];
    Vector<ldouble> v = points[fjord + 2] - points[fjord + 1];

    ldouble l = 0.0L, r = abs(u);
    ldouble d = abs(v), theta = angle(u, v);

    for (int i = 0; i < 50; i++) {
        ldouble m1 = l + (r - l) / 3.0L;
        ldouble m2 = r - (r - l) / 3.0L;

        ldouble a1 = m1 + savings(m1, bridge, theta, d);
        ldouble a2 = m2 + savings(m2, bridge, theta, d);

        if (sign(a1 - a2) < 0) l = m1;
        else r = m2;
    }

    ldouble ans = l + savings(l, bridge, theta, d);
    cout << fjord << " " << bridge << " " << l << " " << ans << "\n";

    return l + savings(l, bridge, theta, d);
}

ldouble total_savings(int i = 0, int bridge = 0) {
    if (i >= 2 * n) return 0.0L;

    ldouble &ans = memo[i][bridge];
    if (sign(ans) >= 0) return ans;

    ans = total_savings(i + 2, bridge);
    for (int j = 1; j <= m - bridge; j++)
        ans = max(ans, total_savings(i + 2, bridge + j) + savings(i, j) - j);

    return ans;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int t = 1;
    while (cin >> n >> m, n || m) {
        points.resize(2 * n + 1);
        for (int i = 0; i <= 2 * n; i++) {
            int x, y;
            cin >> x >> y;
            points[i] = Point<ldouble>(x, y);
        }

        memo.assign(n + 5, vector<ldouble>(m + 5, -1.0L));

        ldouble ans = total_savings();
        cout << "Case " << t++ << ": " << ans << "\n";
    }
}