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>
#define LL long long
#define mp make_pair
#define pb push_back
#define VI vector<int>
#define pii pair<int,int>
using namespace std;

double INF = 1e100;
double EPS = 1e-12;

struct PT { 
  double x, y; 
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y)    {}
  PT operator + (const PT &p)  const { return PT(x+p.x, y+p.y); }
  PT operator - (const PT &p)  const { return PT(x-p.x, y-p.y); }
  PT operator * (double c)     const { return PT(x*c,   y*c  ); }
  PT operator / (double c)     const { return PT(x/c,   y/c  ); }

  bool operator<(const PT &p) const{
  	if(fabs(x - p.x) < EPS) return y - p.y < -EPS;
  	return x - p.x < -EPS;
  }
};

double dot(PT p, PT q)     { return p.x*q.x+p.y*q.y; }
double dist2(PT p, PT q)   { return dot(p-q,p-q); }
PT RotateCCW90(PT p)   { return PT(-p.y,p.x); }

vector<PT> CircleCircleIntersection(PT a, PT b, double r, double R) {
  vector<PT> ret;
  double d = sqrt(dist2(a, b));
  if (d > r+R) return ret;
  if( d+min(r, R) < max(r, R)){
  	if(r < R) ret.pb(a);
  	else ret.pb(b);
  	return ret;
  }
  double x = (d*d-R*R+r*r)/(2*d);
  double y = sqrt(r*r-x*x);
  PT v = (b-a)/d;
  ret.push_back(a+v*x + RotateCCW90(v)*y);
  if (y > 0)
    ret.push_back(a+v*x - RotateCCW90(v)*y);
  return ret;
}

int n, k;
PT P[70];
int c[70];
double r[70];

set<PT> in;
bool f(double t){
	for(int i = 0; i < n; i++) r[i] = t/(1.0*c[i]);
	in.clear();
	for(int i = 0; i < n; i++){
		for(int j = i + 1; j < n; j++){
			vector<PT> inter = CircleCircleIntersection(P[i], P[j], r[i], r[j]);
			for(int k = 0; k < inter.size(); k++){
				in.insert(inter[k]);
				//printf("%lf %lf\n%lf %lf\n", P[i].x, P[i].y, inter[k].x, inter[k].y);
				//printf("%lf %lf\n", r[i], sqrt(dist2(P[i], inter[k])));
			}
		}
	}
	for(auto it = in.begin(); it != in.end(); it++){
		int tot = 0;
		for(int i = 0; i < n; i++) tot += sqrt(dist2(P[i], *it)) - r[i] < EPS;
		//printf("%lf %lf\n", (*it).x, (*it).y);
		if(tot >= k) return true;
	}
	return false;
}
int main(){
	scanf("%d %d", &n, &k);
	if(k == 1){
		printf("0\n");
		return 0;
	}
	for(int i = 0; i < n; i++){
		int x, y;
		scanf("%d %d %d", &x, &y, &c[i]);
		P[i] = PT(x,y);
	}

	double lo = 0, hi = 1e7, mid;
	int iter = 0;
	while(iter++ < 100){
		mid = (lo + hi)/2.0;
		if(f(mid)) hi = mid;
		else lo = mid;
	}
	printf("%.10lf\n", lo);
	return 0;
}