Problem: You are given an integer k and n distinct points with integer coordinates on the Euclidean plane, the i-th point has coordinates (x_i, y_i).

Consider a list of all the (n(n - 1))/(2) pairs of points ((x_i, y_i), (x_j, y_j)) (1 ≤ i < j ≤ n). For every such pair, write out the distance from the line through these two points to the origin (0, 0).

Your goal is to calculate the k-th smallest number among these distances.

Input

The first line contains two integers n, k (2 ≤ n ≤ 10^5, 1 ≤ k ≤ (n(n - 1))/(2)).

The i-th of the next n lines contains two integers x_i and y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the i-th point. It is guaranteed that all given points are pairwise distinct.

Output

You should output one number — the k-th smallest distance from the origin. Your answer is considered correct if its absolute or relative error does not exceed 10^{-6}.

Formally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.

Example

Input


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


Output


0.707106780737

Note

There are 6 pairs of points: 

  * Line 1-2 : distance 0 from the origin 
  * Line 1-3 : distance \frac{√{2}}{2} ≈ 0.707106781 from the origin 
  * Line 1-4 : distance 2 from the origin 
  * Line 2-3 : distance 1 from the origin 
  * Line 2-4 : distance 2 from the origin 
  * Line 3-4 : distance \frac{2}{√{29}} ≈ 0.371390676 from the origin 

The third smallest distance among those is approximately 0.707106781.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
namespace jyy {
const int mod = 998244353, N = 200010;
const double eps = 1e-10;
inline long long read() {
  static long long x = 0, f = 1;
  x = 0, f = 1;
  static char ch = getchar();
  while (ch < '0' || ch > '9') {
    (ch == '-') ? f *= -1 : f;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9') x = x * 10 + int(ch - 48), ch = getchar();
  return x * f;
}
inline void fw(int x) {
  if (x < 0) putchar('-'), x = -x;
  x >= 10 ? fw(x / 10), 1 : 0;
  putchar(char(x % 10 + 48));
}
int qmo(int x) { return x + ((x >> 31) & mod); }
int ksm(int x, int y) {
  int tmp = 1;
  for (; y; y >>= 1, x = 1ll * x * x % mod)
    if (y & 1) tmp = 1ll * tmp * x % mod;
  return tmp;
}
int inv(int x) { return ksm(x, mod - 2); }
int tot, head[N], fa[N];
struct edge {
  int to, next;
} dat[N * 2];
void add_edge(int x, int y) { dat[++tot] = (edge){y, head[x]}, head[x] = tot; }
int find(int x) { return fa[x] ? fa[x] = find(fa[x]) : x; }
int merge(int x, int y) {
  return find(x) != find(y) ? fa[find(x)] = find(y), 0 : 1;
}
int low(int x) { return x & -x; }
int ifac[N], fac[N];
void init(int x) {
  fac[0] = ifac[0] = 1;
  for (int i = 1; i <= x; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
  ifac[x] = inv(fac[x]);
  for (int i = x - 1; i >= 1; i--) ifac[i] = 1ll * ifac[i + 1] * (i + 1) % mod;
}
int C(int x, int y) {
  return (x < y || y < 0 || x < 0)
             ? 0
             : 1ll * fac[x] * ifac[y] % mod * ifac[x - y] % mod;
}
}  // namespace jyy
using namespace jyy;
int n, cnt;
long long k, tr[N * 2];
double val[N * 2], dis[N], L[N], R[N], pi = 3.14159265358979;
struct node {
  double x, y;
  node(double X = 0, double Y = 0) { x = X, y = Y; }
} a[N], b[N];
bool operator<(node A, node B) {
  if (A.y != B.y) return A.y < B.y;
  return A.x < B.x;
}
long long query(int x) {
  long long res = 0;
  for (int i = x; i; i -= low(i)) res += tr[i];
  return res;
}
void add(int x, long long V) {
  for (int i = x; i <= cnt; i += low(i)) tr[i] += V;
}
long long check(double d) {
  cnt = 0;
  int m = 0;
  for (int i = 1; i <= n; i++)
    if (dis[i] > d) {
      double other = acos(d / dis[i]), now = atan2(a[i].y, a[i].x),
             l = now - other, r = now + other;
      l += (l < 0) * 2.0 * pi, r += (r < 0) * 2.0 * pi;
      if (l > r) swap(l, r);
      L[++m] = l, R[m] = r, val[++cnt] = l, val[++cnt] = r;
    }
  sort(val + 1, val + 1 + cnt);
  cnt = unique(val + 1, val + 1 + cnt) - val - 1;
  for (int i = 1; i <= m; i++)
    L[i] = lower_bound(val + 1, val + 1 + cnt, L[i]) - val;
  for (int i = 1; i <= m; i++)
    R[i] = lower_bound(val + 1, val + 1 + cnt, R[i]) - val,
    b[i] = node(L[i], R[i]);
  sort(b + 1, b + 1 + m);
  long long ans = 0;
  for (int i = 1; i <= m; i++)
    ans += query(b[i].y) - query(b[i].x - 1), add(b[i].y, 1), add(b[i].x, -1);
  for (int i = 1; i <= cnt; i++) tr[i] = 0;
  return 1ll * n * (n - 1) / 2 - ans;
}
int main() {
  n = read(), k = read();
  for (int i = 1, x, y; i <= n; i++)
    x = read(), y = read(), a[i] = node(x, y), dis[i] = sqrt(x * x + y * y);
  double l = 0, r = (int)1e5;
  while (r - l > eps) {
    double mid = (l + r) / 2;
    if (check(mid) >= k)
      r = mid;
    else
      l = mid;
  }
  printf("%.10lf", l);
}