#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> Pii;
typedef pair<ll,ll> Pll;
typedef complex<double> Point;
#define rep(i,n) for (ll i=0;i<n;++i)
#define rep2(i,a,b) for (ll i=a;i<b;++i)
#define X real()
#define Y imag()
#define LE(n,m) (n<m+EPS)
#define GE(n,m) (n+EPS>m)
#define EQ(n,m) (abs(n-m)<EPS)
const ll MOD=1000000007;
const ll INF=1e9;
const ll IINF=1e18;
const double EPS=1e-9;
struct Line{Point a,b;};
struct Circle{Point center;double r;};

double dot(Point a,Point b){
    return (conj(a)*b).X;
}

double cross(Point a,Point b){
    return (conj(a)*b).Y;
}

Point proj(Line l,Point p){
    return l.a+dot(l.b-l.a,p-l.a)/norm(l.b-l.a)*(l.b-l.a);
}

vector<Point> crosspointLC(Line l,Circle c){
    vector<Point> ps;
    Point p=proj(l,c.center);
    if (!GE(c.r*c.r,norm(p-c.center))){
        return ps;
    }
    Point dir=sqrt(max(0.0,c.r*c.r-norm(p-c.center)))/abs(l.b-l.a)*(l.b-l.a);
    ps.push_back(p+dir);
    if (!EQ(c.r*c.r,norm(p-c.center))){
        ps.push_back(p-dir);
    }
    return ps;
}

vector<Point> crosspointCC(Circle c1,Circle c2){
    vector<Point> ps;
    Point d=c2.center-c1.center;
    double len=abs(d);
    double crL=(norm(d)+c1.r*c1.r-c2.r*c2.r)/(2*len);
    if (EQ(len,0.0)||c1.r<abs(crL)){
        return ps;
    }
    Point dir=d*Point(0,sqrt(c1.r*c1.r-crL*crL)/len);
    Point cp=c1.center+crL/len*d;
    ps.push_back(cp+dir);
    if (!EQ(norm(dir),0.0)){
        ps.push_back(cp-dir);
    }
    return ps;
}

int n,w;
double wall;
vector<int> x(11),y(11),h(11);
vector<Circle> cs(11);
vector<Point> cors(4);
vector<Line> ls(4);
bool uncovered(Point p){
    if (p.X<wall||100.0-wall<p.X||p.Y<wall||100.0-wall<p.Y){
        return false;
    }
    rep(i,n){
        if (!GE(abs(p-cs[i].center),cs[i].r)){
            return false;
        }
    }
    return true;
}

int main(){
    while(cin >> n >> w,n){
        rep(i,n){
            cin >> x[i] >> y[i] >> h[i];
        }
        double lb=0.0,ub=1000.0;
        while(ub-lb>1e-4){
            double mid=(ub+lb)/2.0;
            rep(i,n){
                double r=mid;
                if (h[i]<mid){
                    r=sqrt(2*mid*h[i]-h[i]*h[i]);
                }
                cs[i]=Circle{Point(x[i],y[i]),r};
            }
            wall=mid;
            if (w<mid){
                wall=sqrt(2*mid*w-w*w);
            }
            if (wall>50.0){
                ub=mid;
                continue;
            }
            cors[0]=Point(wall,wall);
            cors[1]=Point(100.0-wall,wall);
            cors[2]=Point(100.0-wall,100.0-wall);
            cors[3]=Point(wall,100.0-wall);
            rep(i,4){
                ls[i]=Line{cors[i],cors[(i+1)%4]};
            }
            vector<Point> check;
            rep(i,n){
                rep2(j,i+1,n){
                    for (Point p:crosspointCC(cs[i],cs[j])){
                        check.push_back(p);
                    }
                }
                rep(j,4){
                    for (Point p:crosspointLC(ls[j],cs[i])){
                        check.push_back(p);
                    }
                }
            }

            for (auto p:cors){
                check.push_back(p);
            }
            bool can=false;
            for (Point p:check){
                if (uncovered(p)){
                    can=true;
                }
            }
            if (can){
                lb=mid;
            }
            else {
                ub=mid;
            }
        }
        cout << fixed << setprecision(10);
        cout << lb << endl;
    }
}


Measured memory_bytes: 3136