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 <bits/stdc++.h>
using namespace std;
using lint = long long;
#define rep(i, a, b) for (int i = (a); i < (b); ++i)
constexpr double EPS = 1e-6;

/* http://is2011.2-d.jp/moin/moin.cgi/amylase/icpc#A.2BUYYwbk6kcLk- */
// primitives
typedef long double Real;
typedef complex<Real> Point;
typedef pair<Point, Point> Line;
typedef pair<Point, Real> Circle;
typedef vector<Point> Poly;
Real eps = 1e-6;

vector<Point> CCintersect(Circle c, Circle d) {
    vector<Point> ret;
    const Real dist = abs(c.first - d.first);
    const Real cr = c.second;
    const Real dr = d.second;

    if (dist > cr + dr) return ret;
    if (dist < abs(cr - dr)) return ret;

    const Real s = (cr + dr + dist) / 2.;
    const Real area = sqrt(s * (s - cr) * (s - dr) * (s - dist));
    const Real h = 2 * area / dist;

    Point v = d.first - c.first; v /= abs(v);
    const Point m = c.first + sqrt(cr * cr - h * h) * v;
    const Point n = v * Point(0, 1);

    ret.push_back(m + n * h);
    ret.push_back(m - n * h);
    return ret;
}

signed main() {

    int N, K;
    cin >> N >> K;

    vector<Circle> circles;
    rep(i, 0, N) {
        int x, y, c;
        cin >> x >> y >> c;
        circles.emplace_back(Point(x, y), c);
    }

    auto check = [&](double mid) -> bool {
        vector<Point> cand;
        rep(i, 0, N) {
            Circle c1(circles[i].first, mid / circles[i].second);
            cand.emplace_back(circles[i].first);
            rep(j, i + 1, N) {
                Circle c2(circles[j].first, mid / circles[j].second);
                auto ret = CCintersect(c1, c2);
                for (auto& e: ret) cand.emplace_back(e);
            }
        }
        for (auto& c: cand) {
            int cnt = 0;
            rep(i, 0, N) {
                double dst = abs(c - circles[i].first);
                if (dst <= mid / circles[i].second + eps) ++cnt;
            }
            if (cnt >= K) return true;
        }
        return false;
    };

    double ok = 1e10, ng = 0;
    rep(_, 0, 100) {
        double mid = (ok + ng) / 2;
        (check(mid) ? ok : ng) = mid;
    }
    cout << fixed << setprecision(20) << ok << endl;

}