#include <bits/stdc++.h>

using namespace std;

#define int long long
#define all(v) (v).begin(), (v).end()
#define reps(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)

template<class T1, class T2> void chmin(T1 &a, T2 b){if(a>b)a=b;}
template<class T1, class T2> void chmax(T1 &a, T2 b){if(a<b)a=b;}

typedef pair<int, int> Pi;
typedef tuple<int, int, int> Ti;
typedef vector<int> vint;

const int inf = 1LL << 55;
const int mod = 1e9 + 7;

#define EPS (1e-5)
#define eq(a, b) (fabs((a)-(b)) < EPS)
#define lt(a, b) ((a) - (b) < -EPS)
#define le(a, b) (eq(a, b) || lt(a, b))

struct Point {
  double x, y;
  Point(double x = 0.0, double y = 0.0):x(x), y(y){}

  Point operator + (Point p) { return Point(x + p.x, y + p.y); }
  Point operator - (Point p) { return Point(x - p.x, y - p.y); }
  Point operator * (double a) { return Point(x * a, y * a); }
  Point operator / (double a) { return Point(x / a, y / a); }

  double abs() { return sqrt(norm()); }
  double norm() { return x*x + y*y; }

  bool operator < (const Point& p) const {
    return x != p.x ? x < p.x : y < p.y;
  }
  bool operator == (const Point& p) const {
    return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
  }
};
typedef Point Vector;

double norm(Vector v) { return v.x*v.x + v.y*v.y; }
double abs(Vector v) { return sqrt(norm(v)); }
double dot(Vector a, Vector b) { return a.x*b.x + a.y*b.y; }
double cross(Vector a, Vector b) { return a.x*b.y - a.y*b.x; }

bool isOrthogonal(Vector a, Vector b) {
  return eq(dot(a, b), 0.0);
}
bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) {
  return isOrthogonal(a1 - a2, b1 - b2);
}
bool isParallel(Vector a, Vector b) {
  return eq(cross(a, b), 0.0);
}
bool isParallel(Point a1, Point a2, Point b1, Point b2) {
  return isParallel(a1 - a2, b1 - b2);
}

#define COUNTER_CLOCKWISE +1
#define CLOCKWISE         -1
#define ONLINE_BACK       +2
#define ONLINE_FRONT      -2
#define ON_SEGMENT        +0
int ccw(Point p0, Point p1, Point p2) {
  Vector a = p1 - p0;
  Vector b = p2 - p0;
  if(cross(a, b) > EPS) return COUNTER_CLOCKWISE;
  if(cross(a, b) < -EPS) return CLOCKWISE;
  if(dot(a, b) < -EPS) return ONLINE_BACK;
  if(a.norm() < b.norm()) return ONLINE_FRONT;
  return ON_SEGMENT;
}
bool intersect(Point p1, Point p2, Point p3, Point p4) {
  return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
	  ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);
}

double getDistance(Point a, Point b) { return abs(a - b); }
double getAngle(Point a, Point b, Point c) {
  Vector v = b - a, w = c - b;
  double alpha = atan2(v.y, v.x), beta = atan2(w.y, w.x);
  if(alpha > beta) swap(alpha, beta);
  double theta = (beta - alpha) * 180 / M_PI;
  return min(theta, 360 - theta);
}
Vector getAngleBisectorVector(Point a, Point b, Point c) {
  Vector v = a - b, w = c - b;
  v = v / abs(v), w = w / abs(w);
  Vector u = v + w;
  return u / abs(u);
}

struct Segment {
  Point p1, p2;
  Segment(Point p1 = Point(), Point p2 = Point()):p1(p1), p2(p2){}
};
typedef Segment Line;

bool isOrthogonal(Segment s1, Segment s2) {
  return eq(dot(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
bool isParallel(Segment s1, Segment s2) {
  return eq(cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}

Point project(Segment s, Point p) {
  Vector base = s.p2 - s.p1;
  double r = dot(p - s.p1, base) / norm(base);
  return s.p1 + base * r;
}
Point reflect(Segment s, Point p) {
  return p + (project(s, p) - p) * 2.0;
}

bool intersect(Segment s1, Segment s2) {
  return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}

double getDistanceLP(Line l, Point p) {
  return abs(cross(l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}
double getDistanceSP(Segment s, Point p) {
  if(dot(s.p2 - s.p1, p - s.p1) < 0.0) return abs(p - s.p1);
  if(dot(s.p1 - s.p2, p - s.p2) < 0.0) return abs(p - s.p2);
  return getDistanceLP(s, p);
}
double getDistance(Segment s1, Segment s2) {
  if(intersect(s1, s2)) return 0.0;
  return min(min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)),
	     min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)));
}

Point getCrossPoint(Segment s1, Segment s2) {
  Vector base = s2.p2 - s2.p1;
  double d1 = abs(cross(base, s1.p1 - s2.p1));
  double d2 = abs(cross(base, s1.p2 - s2.p1));
  double t = d1 / (d1 + d2);
  return s1.p1 + (s1.p2 - s1.p1) * t;
}
Point getCrossPointLL(Line l1, Line l2) {
  Vector v1 = l1.p2 - l1.p1, v2 = l2.p2 - l2.p1;
  double d = cross(v2, v1);
  if(abs(d) < EPS) return l2.p1;
  return l1.p1 + v1 * cross(v2, l2.p2 - l1.p1) * (1.0 / d);
}
Line getPerpendicularBisector(Point p1, Point p2) {
  Point c = (p1 + p2) / 2.0;
  Point q = Point(c.x + (p1.y - p2.y), c.y + (p2.x - p1.x));
  return Line(c, q);
}
vector<Vector> getNormalLineVector(Line l) {
  vector<Vector> vs;
  Vector v = l.p2 - l.p1, p = v / abs(v);
  vs.emplace_back(-p.y, p.x);
  vs.emplace_back(p.y, p.x);
  return vs;
}
vector<Line> getTranslation(Line l, double d) {
  vector<Vector> nlv = getNormalLineVector(l);
  vector<Line> nl;
  nl.emplace_back(l.p1 + nlv[0]*d, l.p2 + nlv[0]*d);
  nl.emplace_back(l.p1 + nlv[1]*d, l.p2 + nlv[1]*d);
  return nl;
}

struct Circle {
  Point c;
  double r;
  Circle(Point c = Point(), double r = 0.0):c(c), r(r){}
};

vector<Point> getCrossPointsCL(Circle c, Line l) {
  vector<Point> res;
  Vector pr = project(l, c.c);
  if(lt(c.r, abs(c.c-pr))) return res;
  Vector e = (l.p2-l.p1)/abs(l.p2-l.p1);
  double base = sqrt(c.r*c.r-norm(pr-c.c));
  res.push_back(pr+e*base);
  if(!eq(base, 0)) res.push_back(pr-e*base);
  return res;
}

vector<Point> getCrossPointsCS(Circle c, Segment s) {
  vector<Point> res;
  vector<Point> pl = getCrossPointsCL(c, s);
  for(Point p : pl) {
    if(ccw(s.p1, s.p2, p) == ON_SEGMENT) res.push_back(p);
  }
  return res;
}

double arg(Vector p) { return atan2(p.y, p.x); }
Vector polar(double a, double r) { return Point(cos(r) * a, sin(r) * a); }

Point operator * (Point p, Point q) {
  return Point(p.x*q.x-p.y*q.y, p.x*q.y+p.y*q.x);
}

bool intersect(Circle c1, Circle c2) {
  double d = getDistance(c1.c, c2.c);
  return le(d, c1.r+c2.r) && !lt(d, fabs(c1.r-c2.r));
}

vector<Point> getCrossPoints(Circle c1, Circle c2) {
  // assert(intersect(c1, c2));
  double d = abs(c1.c - c2.c);
  double a = acos((c1.r*c1.r + d*d - c2.r*c2.r) / (2*c1.r*d));
  double t = arg(c2.c - c1.c);
  return vector<Point>{c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a)};
}


typedef vector<Point> Polygon;

#define IN_POLYGON  2
#define ON_POLYGON  1
#define OUT_POLYGON 0
int contains(Polygon g, Point p) {
  int n = g.size();
  bool x = false;
  for(int i = 0; i < n; i++) {
    Point a = g[i] - p, b = g[(i+1) % n] - p;
    if(abs(cross(a, b)) < EPS && dot(a, b) < EPS) return ON_POLYGON;
    if(a.y > b.y) swap(a, b);
    if(a.y < EPS && EPS < b.y && cross(a, b) > EPS) x = !x;
  }
  return (x ? IN_POLYGON : OUT_POLYGON);
}

int n, w;
vector<Point> ps;
vector<double> hs;

double radius(double r, double h) {
  if(lt(h, r)) return sqrt(r*r-(r-h)*(r-h));
  return r;
}

bool check(double mb) {
  double cnr = radius(mb, w);
  if(cnr+cnr >= 100) return false;
  Polygon box;
  box.push_back(Point(cnr, cnr));
  box.push_back(Point(100-cnr, cnr));
  box.push_back(Point(100-cnr, 100-cnr));
  box.push_back(Point(cnr, 100-cnr));

  vector<Circle> cs;
  rep(i, ps.size()) {
    Circle c(ps[i], radius(mb, hs[i]));
    cs.push_back(c);
  }

  vector<Point> crossps;
  rep(i, ps.size()) {
    reps(j, i+1, ps.size()) {
      Circle c1 = cs[i], c2 = cs[j];
      if(!intersect(c1, c2)) continue;
      auto cp = getCrossPoints(c1, c2);
      for(Point p : cp) {
	if(contains(box, p) != OUT_POLYGON) crossps.push_back(p);
      }
    }
  }

  rep(i, box.size()) {
    if(contains(box, box[i]) != OUT_POLYGON) crossps.push_back(box[i]);
    Segment wall = Segment(box[i], box[(i+1)%box.size()]);
    for(Circle c : cs) {
      double dist = getDistanceSP(wall, c.c);
      if(!le(dist, c.r)) continue;
      auto cp = getCrossPointsCS(c, wall);
      for(Point p : cp) {
	if(contains(box, p) != OUT_POLYGON) crossps.push_back(p);
      }
    }
  }

  for(Point cp : crossps) {
    bool flag = true;
    for(Circle c : cs) {
      double dist = getDistance(cp, c.c);
      if(lt(dist, c.r)) flag = false;
    }
    /*
    rep(i, box.size()) {
      Segment wall = Segment(box[i], box[(i+1)%box.size()]);
      double dist = getDistanceSP(wall, cp);
      if(lt(dist, radius(mb, w))) flag = false;
    }
    */
    if(flag) return true;
  }

  return false;
}

signed main()
{
  cin.tie(0);
  ios_base::sync_with_stdio(0);
  cout << fixed << setprecision(12);

  while(cin >> n >> w, n || w) {
    ps.clear();
    hs.clear();

    rep(i, n) {
      Point p; double h;
      cin >> p.x >> p.y >> h;
      ps.push_back(p);
      hs.push_back(h);
    }

    double lb =  0, ub = 10000;
    rep(i, 100) {
      double mb = (lb+ub)/2;
      if(check(mb)) lb = mb;
      else ub = mb;
    }
    cout << lb << endl;
  }

  return 0;
}

Measured memory_bytes: 3748