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 PYTHON3):

Solution:
import sys
input = sys.stdin.readline


class Vec:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return '({}, {})'.format(self.x, self.y)

    def __add__(self, other):
        return Vec(self.x+other.x, self.y+other.y)

    def __sub__(self, other):
        return Vec(self.x-other.x, self.y-other.y)

    def __mul__(self, k):
        return Vec(self.x*k, self.y*k)

    def __truediv__(self, k):
        return Vec(self.x/k, self.y/k)

    def abs(self):
        return (self.x**2 + self.y**2)**.5


def dist(p, q):
    return (p-q).abs()


# returns a list of the intersections of two circles
# if they are outside of each other or one contains the other entirely, returns an empty list
def intersection_circles(c1, r1, c2, r2):
    d = (c1-c2).abs()

    # if the circles are outside of each other
    if r1 + r2 < d:
        return []

    # if one contains the other entirely
    if d < abs(r2 - r1):
        return []

    x = (r1**2-r2**2+d**2) / (2*d)
    y = (r1**2-x**2)**.5
    e1 = (c2-c1) / (c2-c1).abs()
    e2 = Vec(-e1.y, e1.x)
    p1 = c1 + e1*x + e2*y
    p2 = c1 + e1*x - e2*y
    return [p1, p2]


N, K = map(int, input().split())
center = [None] * N
cost = [0] * N
for i in range(N):
    x, y, c = map(int, input().split())
    center[i] = Vec(x, y)
    cost[i] = c
lb = 0
ub = 10**6
EPS = 10**(-8)
while ub - lb > EPS:
    mid = (lb + ub) / 2
    r = [mid / c for c in cost]
    points = list(center)
    for i in range(N-1):
        for j in range(i+1, N):
            points += intersection_circles(center[i], r[i], center[j], r[j])
    cnt = 0
    for p in points:
        tmp = 0
        for i in range(N):
            if dist(p, center[i]) < r[i] + EPS:
                tmp += 1
        cnt = max(cnt, tmp)
    if cnt >= K:
        ub = mid
    else:
        lb = mid
print(lb)