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>
inline int read() {
  char c, _c;
  int x;
  for (c = _c = getchar(); !isdigit(c); c = getchar()) {
    _c = c;
  }
  for (x = 0; isdigit(c); c = getchar()) {
    x = x * 10 + c - '0';
  }
  return _c == '-' ? -x : x;
}
const long double eps = 1e-10, Eps = 1e-8, pi = std::acos(-1.0L);
const int N = 2e5 + 5, V = 4e7 + 5;
int n, m, rb[N];
long long k, fuck, shit;
std::pair<int, int> p[N];
long double ox, oy, a[N], b[N], c[N];
long double ans, dis[N], s[N], t[N], tb[N];
struct FenwickTree {
  int f[N];
  void reset(int n) { memset(f, 0, (n + 1) * 4); }
  void modify(int u, int x) {
    for (int i = u; i <= m; i += i & -i) {
      f[i] += x;
    }
  }
  int query(int u) {
    int res = 0;
    for (int i = u; i >= 1; i ^= i & -i) {
      res += f[i];
    }
    return res;
  }
  int query(int l, int r) {
    if (l >= r) {
      return 0;
    }
    return query(r) - query(l);
  }
} tr;
bool check(long double mid) {
  long long res = 0;
  m = 0;
  long long inner = 0;
  for (int i = 0; i < n; i++) {
    long double x = a[i], y = b[i];
    dis[i] = std::sqrt(x * x + y * y);
    if (dis[i] < mid + eps) {
      inner++;
    } else {
      s[i] = std::atan2(y, x) - std::acos(mid / dis[i]);
      t[i] = std::atan2(y, x) + std::acos(mid / dis[i]);
      if (s[i] > t[i]) {
        std::swap(s[i], t[i]);
      }
      if (s[i] < -pi + eps) {
        s[i] += pi * 2;
      }
      if (t[i] > pi) {
        t[i] -= pi * 2;
      }
      if (s[i] > t[i]) {
        std::swap(s[i], t[i]);
      }
      s[i] += eps;
      t[i] -= eps;
      tb[m++] = s[i];
      tb[m++] = t[i];
    }
  }
  std::sort(tb, tb + m);
  for (int i = 0; i < n; i++) {
    if (dis[i] < mid + eps) {
      p[i] = {m, i};
      continue;
    }
    p[i] = {std::upper_bound(tb, tb + m, s[i]) - tb - 1, i};
    rb[i] = std::upper_bound(tb, tb + m, t[i]) - tb;
  }
  std::sort(p, p + n);
  tr.reset(m);
  res = (n - inner) * (n - inner - 1ll) / 2;
  for (int i = 0; i < n; i++) {
    if (p[i].first == m) {
      break;
    }
    res -= tr.query(p[i].first, rb[p[i].second]);
    tr.modify(rb[p[i].second], 1);
  }
  res += inner * (inner - 1ll) / 2;
  res += inner * (n - inner);
  return res >= k;
}
int main() {
  scanf("%d%lld", &n, &k);
  std::vector<long double> vec;
  for (int i = 0; i < n; i++) {
    a[i] = read();
    b[i] = read();
    if (a[i] == 0 && b[i] == 0) {
      fuck++;
    } else if (a[i] != 0) {
      if (a[i] > 0) {
        vec.push_back(std::atan2(b[i], a[i]));
      } else {
        vec.push_back(std::atan2(-b[i], -a[i]));
      }
    } else {
      if (b[i] > 0) {
        vec.push_back(std::atan2(b[i], a[i]));
      } else {
        vec.push_back(std::atan2(-b[i], -a[i]));
      }
    }
  }
  std::sort(vec.begin(), vec.end());
  for (int i = 0, j; i < vec.size(); i = j) {
    for (j = i; j < n && std::abs(vec[i] - vec[j]) < eps; j++)
      ;
    shit += (j - i) * (j - i - 1ll) / 2;
  }
  shit += fuck * (fuck - 1ll) / 2;
  shit += fuck * (n - fuck);
  if (shit >= k) {
    printf("0.000000\n");
    return 0;
  }
  for (long double l = Eps, r = 2e4, mid; l <= r;) {
    mid = (l + r) / 2;
    if (check(mid)) {
      r = mid - Eps;
      ans = mid;
    } else {
      l = mid + Eps;
    }
  }
  printf("%.6f\n", (double)ans);
  return 0;
}