Problem: E --Disappear Drive

Story

The person in D likes basketball, but he likes shooting, so other techniques are crazy. I'm not particularly good at dribbling, and when I enter the opponent's defensive range, I always get the ball stolen. So I decided to come up with a deadly dribble that would surely pull out any opponent. After some effort, he finally completed the disappearing drive, "Disapia Drive".

This Apia Drive creates a gap by provoking the opponent to deprive him of his concentration and take his eyes off, and in that gap he goes beyond the wall of dimension and slips through the opponent's defensive range. It's a drive. However, crossing the dimensional wall puts a heavy burden on the body, so there is a limit to the number of times the dimensional wall can be crossed. Also, because he always uses his concentration, he can only change direction once, including normal movements. How do you move on the court to reach the goal in the shortest time without being robbed of the ball?

Problem

Consider a rectangle on a two-dimensional plane with (0,0) at the bottom left and (50,94) at the top right. In addition, there are N circles on this plane, the center position of the i-th circle is (x_i, y_i), and the radius is r_i. There is no overlap between the circles.

Let (25,0) be the point S and (25,94) be the point G, and consider the route from S to G. A "path" consists of (1) a line segment connecting S and G, or (2) a combination of a line segment SP and a line segment GP at any point P inside a rectangle. In the middle of the route from S to G, the period from entering the inside of a circle to exiting the inside of the circle is defined as "the section passing through the inside of the circle". However, it is assumed that the circumferences of the rectangle and the circle are not included in the rectangle and the circle, respectively.

Find the length of the shortest route among the routes where the number of sections passing through the inside of the circle is D or less. If you can't reach the goal, return -1.

Input

The input consists of the following format.


N D
x_1 y_1 r_1
...
x_N y_N r_N

The first line consists of two integers, and the number N of circles and the number of times D that can pass inside the circle are given, separated by one blank character. The following N lines are given circle information. The i + 1 line (1 \ leq i \ leq N) consists of three integers, and the x-coordinate x_i, y-coordinate y_i, and radius r_i of the center of the i-th circle are given by separating them with one blank character.

Constraints:

* 0 \ leq N \ leq 5
* 0 \ leq D \ leq 5
* 0 \ leq x_i \ leq 50
* 0 \ leq y_i \ leq 94
* 1 \ leq r_i \ leq 100
* It can be assumed that any two circles are separated by 10 ^ {-5} or more.
* It can be assumed that S and G are not included inside any circle.
* It can be assumed that S and G are separated from any circle by 10 ^ {-5} or more.
* It can be assumed that the point P in the shortest path is more than 10 ^ {-5} away from the circumference of the rectangle and any circumference.



Output

Output the length of the shortest path on one line. Be sure to start a new line at the end of the line. However, if you cannot reach the goal, return -1. Absolute error or relative error of 10 ^ {-7} or less is allowed for the correct answer.

Sample Input 1


Ten
25 47 10

Sample Output 1


96.2027355887

DisappearDrive_sample1.png

The detour route is the shortest because it cannot disappear.

Sample Input 2


1 1
25 47 10

Sample Output 2


94.0000000000

DisappearDrive_sample2.png

It can disappear, so you just have to go straight through it.

Sample Input 3


Ten
20 47 5

Sample Output 3


94.0000000000

DisappearDrive_sample3.png

Since the circumference is not included in the circle, it can pass through without disappearing.

Sample Input 4


Ten
25 47 40

Sample Output 4


-1

DisappearDrive_sample4.png

You can't reach the goal because you can't disappear or detour.

Sample Input 5


5 2
11 10 16
33 40 18
20 66 10
45 79 14
22 85 8

Sample Output 5


96.1320937224

DisappearDrive_sample5.png





Example

Input

1 0
25 47 10


Output

96.2027355887

Solution (in CPP):

Solution:
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

#define DEBUG(x) cerr << #x << " = " << x << endl

typedef double D;
const D EPS = 1e-8;
struct P {
  D x, y;
  P(D x_, D y_) : x(x_), y(y_) { }
  P() { }
};

struct C {
  P p; D r;
  C(P p_, D r_) : p(p_), r(r_) { }
  C() { }
};

struct L {
  P a, b;
  L(P a_, P b_) : a(a_), b(b_) { }
};

P operator +(P a, P b) { return P(a.x+b.x, a.y+b.y); }
P operator -(P a, P b) { return P(a.x-b.x, a.y-b.y); }
P operator *(P p, D s) { return P(p.x*s, p.y*s); }
P vec(P from, P to) { return to - from; }
D inp(P a, P b) { return a.x*b.x + a.y*b.y; }
D outp(P a, P b) { return a.x*b.y - a.y*b.x; }
D norm(P p) { return inp(p,p); }
D abs(P p) { return sqrt(norm(p)); }

P projection(L l, P p) {
  P a = vec(l.a, l.b);
  P b = vec(l.a, p);
  D t = inp(b, a) / norm(a);
  return l.a + a * t;
}

int sign(D a, D b = 0.0) {
  if(a < b - EPS) return -1;
  if(a > b + EPS) return +1;
  return 0;
}

int ccw(P a, P b, P c) {
  b = vec(a, b); c = vec(a, c);
  if(sign(outp(b, c)) > 0) return +1;
  if(sign(outp(b, c)) < 0) return -1;
  if(sign(inp(b, c)) < 0) return +2;
  if(norm(b) < norm(c)) return -2;
  return 0;
}

bool iSP(L s, P p) {
  return ccw(s.a, s.b, p) == 0;
}

P rot90(P p) {
  return P(-p.y, p.x);
}

D dSP(L s, P p) {
  P r = projection(s, p);
  if(iSP(s, r)) return abs(vec(p, r));
  return min(abs(vec(p, s.a)), abs(vec(p, s.b)));
}

P cLL(L l, L m) {
  D d = outp(vec(m.a, m.b), vec(l.a, l.b));
  return l.a + vec(l.a, l.b) * outp(vec(m.a, m.b), vec(l.a, m.b)) * (1.0 / d);
}

bool iSC(L s, C c) {
  return sign(dSP(s, c.p), c.r) < 0;
}

vector<P> tangentCP(C c, P p) {
  double x = norm(p - c.p);
  double d = x - c.r * c.r;
  if(sign(d) < 0) return vector<P>();
  d = max(d, 0.0);
  P q1 = (p - c.p) * (c.r * c.r / x);
  P q2 = rot90((p - c.p) * (-c.r * sqrt(d) / x));
  vector<P> ret;
  ret.push_back(c.p + q1 - q2);
  ret.push_back(c.p + q1 + q2);
  return ret;
}

const double gx[2] { 25.0, 25.0 };
const double gy[2] { 0.0, 94.0 };

int main() {
  cout.setf(ios::fixed); cout.precision(10);
  int N, D; cin >> N >> D;
  vector<C> cs(N);
  for(int i = 0; i < N; i++) {
    cin >> cs[i].p.x >> cs[i].p.y >> cs[i].r;
  }

  int k = 0;
  L l(P(gx[0], gy[0]), P(gx[1], gy[1]));
  for(int i = 0; i < N; i++) {
    if(iSC(l, cs[i])) k++;
  }
  if(k <= D) {
    // 曲がる必要がないとき
    cout << 94.0 << endl;
  }
  else {
    // 曲がる必要があるとき
    bool ok = false;
    double res = 1e9;
    for(int i = 0; i < N; i++) {
      for(int j = 0; j < N; j++) {
        vector<P> t1 = tangentCP(cs[i], P(gx[0], gy[0]));
        vector<P> t2 = tangentCP(cs[j], P(gx[1], gy[1]));
        for(int a = 0; a < 2; a++) for(int b = 0; b < 2; b++) {
          P s(gx[0], gy[0]);
          L l1(s, t1[a]);
          if(sign(abs(vec(t1[a], s))) == 0) {
            P p = rot90(vec(cs[i].p, s));
            l1 = L(s, s + p);
          }
          P g(gx[1],gy[1]);
          L l2(g, t2[b]);
          if(sign(abs(vec(t2[b], g))) == 0) {
            P p = rot90(vec(cs[j].p, g));
            l2 = L(g, g + p);
          }
          P cp = cLL(l1, l2);
          if(!(sign(0.0, cp.x) < 0 && sign(cp.x, 50.0) < 0 && sign(0.0, cp.y) < 0 && sign(cp.y, 94.0) < 0)) {
            continue;
          }
          l1 = L(P(gx[0], gy[0]), cp);
          l2 = L(P(gx[1], gy[1]), cp);

          int damage = 0;
          for(int k = 0; k < N; k++) {
            int x = (int)iSC(l1, cs[k]) + (int)iSC(l2, cs[k]);
            if(x == 1) {
              damage++;
            }
            else if(x == 2) {
              if(sign(abs(vec(cs[k].p, cp)), cs[k].r) < 0) {
                damage++;
              }
              else {
                damage+=2;
              }
            }
          }

          if(damage <= D) {
            ok = true;
            if(res > abs(l1.a - l1.b) + abs(l2.a - l2.b)) {
              res = abs(l1.a - l1.b) + abs(l2.a - l2.b);
            }
          }
        }
      }
    }
    if(ok) {
      cout << res << endl;
    }
    else {
      cout << "-1" << endl;
    }
  }
}