#include<iostream>
#include<cstdio>
#include<complex>
#include<vector>

using namespace std;

#define X real()
#define Y imag()

typedef long double D;
typedef complex<D> P;
struct L{P a, b;};

const D EPS = 1e-8;

int sig(D a, D b = 0) {return a < b - EPS ? -1 : a > b + EPS ? 1 : 0;}
bool near(P a, P b) {return !sig(norm(a - b));}
namespace std {
  bool operator<(P a, P b) {return sig(a.X, b.X) ? a.X < b.X : a.Y < b.Y;}
}

D sr(D a) {return sqrt(max(a, (D)0));}

D dot(P a, P b) {return a.X * b.X + a.Y * b.Y;}
D det(P a, P b) {return a.X * b.Y - a.Y * b.X;}

P vec(L a) {return a.b - a.a;}

enum CCW{FRONT = 1, RIGHT = 2, BACK = 4, LEFT = 8, ON = 16};
int ccw(P a, P b, P c) {
  if (near(a, c) || near(b, c)) return ON;
  int s = sig(det(b - a, c - a));
  if (s) return s > 0 ? LEFT : RIGHT;
  return (a < b) == (b < c) ? FRONT : (c < a) == (a < b) ? BACK : ON;
}

P proj(P a, P b) {return a * dot(a, b) / norm(a);}
P perp(L l, P p) {return l.a + proj(vec(l), p - l.a);}

bool iLLs(L a, L b) {return sig(det(vec(a), vec(b)));}

P pLL(L a, L b) {return a.a + vec(a) * (det(vec(b), b.a - a.a) / det(vec(b), vec(a)));}

D dLP(L l, P p) {return abs(det(vec(l), p - l.a) / vec(l));}
D dSP(L s, P p) {
  if (dot(vec(s), p - s.a) < 0) return abs(p - s.a);
  if (dot(vec(s), p - s.b) > 0) return abs(p - s.b);
  return dLP(s, p);
}

struct C{P c; D r;};
bool iCSs(C c, L s) {return sig(c.r, dSP(s, c.c)) > 0;}

pair<P, P> pCL(C c, L l) {
  P x = perp(l, c.c);
  P y = vec(l) / abs(vec(l)) * sr(c.r * c.r - norm(x - c.c));
  return make_pair(x - y, x + y);
}

pair<P, P> tCP(C c, P p) {
  D d2 = norm(p - c.c);
  D x = sqrt(max(d2 - c.r * c.r, (D)0));
  P h = c.c + (p - c.c) * (c.r * c.r / d2);
  P w = (p - c.c) * (x * c.r / d2) * P(0, 1);
  return make_pair(h - w, h + w);
}

#define rep(i, n) for (int i = 0; i < int(n); ++i)

int main() {
  int n, d;
  cin >> n >> d;
  C c[n];
  rep (i, n) {
    D x, y, r;
    cin >> x >> y >> r;
    c[i] = (C){P(x, y), r};
  }
  L l;
  l.a = P(25, 0);
  l.b = P(25, 94);
  int cnt = 0;
  rep (i, n) if (iCSs(c[i], l)) ++cnt;
  if (cnt <= d) {
    puts("94");
    return 0;
  }
  vector<L> vl1, vl2;
  rep (i, n) {
    pair<P, P> pp = tCP(c[i], l.a);
    vl1.push_back((L){l.a, pp.first});
    vl1.push_back((L){l.a, pp.second});
  }
  rep (i, n) {
    pair<P, P> pp = tCP(c[i], l.b);
    vl2.push_back((L){l.b, pp.first});
    vl2.push_back((L){l.b, pp.second});
  }
  D res = 1000;
  rep (i, vl1.size()) rep (j, vl2.size()) if (iLLs(vl1[i], vl2[j])) {
    P p = pLL(vl1[i], vl2[j]);
    if (sig(p.X) < 0 || sig(p.X, 50) > 0 || sig(p.Y) < 0 || sig(p.Y, 94) > 0) continue;
    cnt = 0;
    rep (i, n) if (iCSs(c[i], (L){l.a, p})) {
      pair<P, P> pp = pCL(c[i], (L){l.a, p});
      if (ccw(l.a, p, pp.first) == ON) ++cnt;
      if (ccw(l.a, p, pp.second) == ON) ++cnt;
    }
    rep (i, n) if (iCSs(c[i], (L){l.b, p})) {
      pair<P, P> pp = pCL(c[i], (L){l.b, p});
      if (ccw(l.b, p, pp.first) == ON) ++cnt;
      if (ccw(l.b, p, pp.second) == ON) ++cnt;
    }
    if (cnt / 2 <= d) {
      res = min(res, abs(l.a - p) + abs(l.b - p));
    }
  }
  if (sig(res, 1000) == 0) {
    puts("-1");
  } else {
    printf("%.12Lf\n", res);
  }
}

Measured memory_bytes: 1284