Problem: Takahashi wants to grill N pieces of meat on a grilling net, which can be seen as a two-dimensional plane. The coordinates of the i-th piece of meat are \left(x_i, y_i\right), and its hardness is c_i.

Takahashi can use one heat source to grill the meat. If he puts the heat source at coordinates \left(X, Y\right), where X and Y are real numbers, the i-th piece of meat will be ready to eat in c_i \times \sqrt{\left(X - x_i\right)^2 + \left(Y-y_i\right)^2} seconds.

Takahashi wants to eat K pieces of meat. Find the time required to have K or more pieces of meat ready if he put the heat source to minimize this time.

Constraints

* All values in input are integers.
* 1 \leq N \leq 60
* 1 \leq K \leq N
* -1000 \leq x_i , y_i \leq 1000
* \left(x_i, y_i\right) \neq \left(x_j, y_j\right) \left(i \neq j \right)
* 1 \leq c_i \leq 100

Input

Input is given from Standard Input in the following format:


N K
x_1 y_1 c_1
\vdots
x_N y_N c_N


Output

Print the answer.

It will be considered correct if its absolute or relative error from our answer is at most 10^{-6}.

Examples

Input

4 3
-1 0 3
0 0 3
1 0 2
1 1 40


Output

2.4


Input

10 5
-879 981 26
890 -406 81
512 859 97
362 -955 25
128 553 17
-885 763 2
449 310 57
-656 -204 11
-270 76 40
184 170 16


Output

7411.2252

Solution (in CPP):

Solution:
#include <cmath>
#include <iostream>
#include <utility>
#include <vector>

using dbl = long double;
static constexpr dbl eps = 1e-9;
struct Point {
  dbl x;
  dbl y;
  dbl length2() const { return x * x + y * y; }
  dbl length() const { return sqrt(length2()); }

  Point normalize() const {
    auto d = length();
    if (d < eps) {
      return {0, 0};
    }
    return {x / d, y / d};
  }

  Point rotate(Point other) const {
    return {x * other.x - y * other.y, x * other.y + y * other.x};
  }
  Point sub(Point other) const { return {x - other.x, y - other.y}; }
  Point add(Point other) const { return {x + other.x, y + other.y}; }
};

struct Circle {
  Point c;
  dbl r;
  dbl r2() const { return r * r; }
  bool in(Point x) const { return x.sub(c).length2() < r2() + eps; }
};

void guess(const Circle &first, const Circle &second,
           std::vector<Point> &dest) {
  auto dir = second.c.sub(first.c);
  auto d = dir.length();
  if (d < eps) {
    return;
  }
  dbl x = (first.r2() + d * d - second.r2()) / (2 * d);
  dbl y2 = first.r2() - x * x;
  if (y2 < -eps) {
    return;
  }
  if (y2 < eps) {
    y2 = 0;
  }
  dbl y = sqrt(y2);
  auto rot = dir.normalize();
  dest.push_back(Point{x, y}.rotate(rot).add(first.c));
  dest.push_back(Point{x, -y}.rotate(rot).add(first.c));
}

struct Task {
  bool run() {
    int n, k;
    if (scanf("%d%d", &n, &k) != 2) {
      return false;
    }
    std::vector<Circle> meats(n);
    for (auto &meat : meats) {
      std::cin >> meat.c.x >> meat.c.y >> meat.r;
    }

    dbl l = 0, r = 10000000;
    for (int t = 0; t < 200; t++) {
      dbl R = (l + r) / 2;
      std::vector<Circle> circles = meats;
      std::vector<Point> points;
      for (auto &circle : circles) {
        circle.r = R / circle.r;
        points.push_back(circle.c);
      }
      for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
          guess(circles[i], circles[j], points);
        }
      }
      bool ok = false;
      for (auto point : points) {
        int cnt = 0;
        for (auto &circle : circles) {
          cnt += circle.in(point);
        }
        // printf("%lf %lf: %d\n", point.x, point.y, cnt);
        if (cnt >= k) {
          ok = true;
          break;
        }
      }
      if (ok) {
        r = R;
      } else {
        l = R;
      }
      // break;
    }
    printf("%.10lf\n", (double)r);

    return true;
  }
};

int main(void) {
  // std::vector<Point> p;
  // guess(Circle{{-1, 0}, 0.8}, Circle{{1, 0}, 1.2}, p);
  //// guess(Circle{{1, 1}, 1}, Circle{{2, 2}, 1}, p);
  // for (auto x : p) {
  // printf("%lf %lf\n", x.x, x.y);
  //}
  // return 0;
  while (true) {
    Task task;
    if (!task.run()) {
      break;
    }
  }
}