#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
template<class T> void check_min(T &a, const T &b){ a = (a < b) ? a : b; }
template<class T> void check_max(T &a, const T &b){ a = (a > b) ? a : b; }
#define all(x) (x).begin(), (x).end()

typedef long double ld;
template <class T> int sgn(T x) { return (x > 0) - (x < 0); }
template<class T>
struct Point {
    typedef Point P;
    T x, y;
    explicit Point(T x=0, T y=0) : x(x), y(y) {}
    bool operator<(P p) const { return tie(x,y) < tie(p.x,p.y); }
    bool operator==(P p) const { return tie(x,y)==tie(p.x,p.y); }
    P operator+(P p) const { return P(x+p.x, y+p.y); }
    P operator-(P p) const { return P(x-p.x, y-p.y); }
    P operator*(T d) const { return P(x*d, y*d); }
    P operator/(T d) const { return P(x/d, y/d); }
    T dot(P p) const { return x*p.x + y*p.y; }
    T cross(P p) const { return x*p.y - y*p.x; }
    T cross(P a, P b) const { return (a-*this).cross(b-*this); }
    T dist2() const { return x*x + y*y; }
    ld dist() const { return sqrt((ld)dist2()); }
    // angle to x-axis in interval [-pi, pi]
    ld angle() const { return atan2(y, x); }
    P unit() const { return *this/dist(); } // makes dist()=1
    P perp() const { return P(-y, x); } // rotates +90 degrees
    P normal() const { return perp().unit(); }
    // returns point rotated 'a' radians ccw around the origin
    P rotate(ld a) const {
        return P(x*cos(a)-y*sin(a),x*sin(a)+y*cos(a)); }
    friend ostream& operator<<(ostream& os, P p) {
        return os << "(" << p.x << "," << p.y << ")"; }
};




typedef Point<ld> P;
bool circleInter(P a,P b,ld r1,ld r2,pair<P, P>* out) {
    if (a == b) { assert(r1 != r2); return false; }
    P vec = b - a;
    ld d2 = vec.dist2(), sum = r1+r2, dif = r1-r2,
           p = (d2 + r1*r1 - r2*r2)/(d2*2), h2 = r1*r1 - p*p*d2;
    if (sum*sum < d2 || dif*dif > d2) return false;
    P mid = a + vec*p, per = vec.perp() * sqrt(fmax(0, h2) / d2);
    *out = {mid + per, mid - per};
    return true;
}

const int N = 100 + 3;
const ld PI = acos(-1);

int n, r;
Point<ld> centre[N];
ld radius[N];

Point<ld> angle_to_point(ld angle){
    return (Point<ld>{r, 0}).rotate(angle);
}

ld get_angle(Point<ld> p){
    ld ans =  p.angle();
    if(ans < 0)
        ans += 2 * PI;
    if(ans > 2 * PI)
        ans -= 2 * PI;
    return ans;
}

ld dist_angle(ld a, ld b){
    Point<ld> p1 = angle_to_point(a);
    Point<ld> p2 = angle_to_point(b);
    return (p1 - p2).dist();
}

bool contains(ld a, ld b){
    if(a > b)
        swap(a, b);

    vector<ld> to_check{PI, 3 * PI, -PI, -3*PI};
    for(auto x: to_check)
        if(a <= x && x <= b)
            return true;
    return false;
}

ld calc(pair<ld, ld> a, pair<ld, ld> b){
    if(contains(a.first - b.first, a.first - b.second))
        return 2 * r;
    if(contains(a.second - b.first, a.second - b.second))
        return 2 * r;

    ld ans = 0;
    check_max(ans, dist_angle(a.first, b.first));
    check_max(ans, dist_angle(a.first, b.second));
    check_max(ans, dist_angle(a.second, b.first));
    check_max(ans, dist_angle(a.second, b.second));
    return ans;
}

void solve(){
    cin >> n >> r;

    for(int i = 0; i < n; ++i){
        int _x, _y, _r;
        cin >> _x >> _y >> _r;

        radius[i] = _r;
        centre[i] = Point<ld>{_x, _y};
    }

    vector<pair<ld, ld>> angles;
    for(int i = 0; i < n; ++i){
        pair<Point<ld>, Point<ld>> p;
        if(!circleInter(Point<ld>{0, 0}, centre[i], r, radius[i], &p))
            continue;

        ld a1 = get_angle(p.first);
        ld a2 = get_angle(p.second);
        if(a1 > a2)
            swap(a1, a2);
        ld mid = (a1 + a2) / 2;
        Point<ld> p_mid = angle_to_point(mid);
        if((centre[i] - p_mid).dist() <= radius[i]){

        }
        else{
            swap(a1, a2);
        }

        angles.push_back({a1, a2});
    }

    vector<pair<ld, bool>> sweepline;
    for(auto [l, r]: angles){
        // cout << l << " " << r << " l r" << endl; 
        sweepline.push_back({r, true});
        sweepline.push_back({l, false});
        sweepline.push_back({r + 2 * PI, true});
        sweepline.push_back({l + 2 * PI, false});
    }
    sort(all(sweepline));

    vector<pair<ld, ld>> v;
    ld prev = -1;
    for(auto [angle, start]: sweepline){
        if(!start && prev != -1){
            // cout << prev << " " << angle << " prev angle" << endl;
            v.push_back({prev, angle});
        }
        if(angle > 2 * PI)
            break;
        prev = angle;
    }

    ld ans = 0;
    for(int i = 0; i < v.size(); ++i){
        for(int j = 0; j < v.size(); ++j){
            check_max(ans, calc(v[i], v[j]));
        }
    }

    cout << fixed << setprecision(12) << ans << "\n";
}

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

    int t;
    cin >> t;

    for(int i = 1; i <= t; ++i){
        cout << "Case #" << i << ": ";
        solve();
    }
}