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>
const double eps = 1e-8;
template <typename T>
inline int cmpT(T x) {
  return x < 0 ? -1 : x > 0;
}
template <typename T>
struct VecT {
  T x = 0;
  T y = 0;
  static_assert(std::is_arithmetic<T>::value,
                "T should be an arithmetic type.");
  VecT() {}
  VecT(T x, T y) : x(x), y(y) {}
  ~VecT() {}
  T length_sqr() const { return x * x + y * y; }
  VecT rotate90() const { return VecT(-y, x); }
  double length() const { return hypot(x, y); }
  VecT<decltype(T(1) * double(1))> rotate(double angle) const {
    const double c = cos(angle), s = sin(angle);
    return VecT<decltype(T(1) * double(1))>(x * c - y * s, x * s + y * c);
  }
  template <typename U>
  VecT<U> convert() const {
    return VecT<U>(x, y);
  }
};
template <typename T>
inline VecT<T> operator+(const VecT<T>& lhs, const VecT<T>& rhs) {
  return VecT<T>(lhs.x + rhs.x, lhs.y + rhs.y);
}
template <typename T>
inline VecT<T>& operator+=(VecT<T>& lhs, const VecT<T>& rhs) {
  return lhs = lhs + rhs;
}
template <typename T>
inline VecT<T> operator-(const VecT<T>& lhs, const VecT<T>& rhs) {
  return VecT<T>(lhs.x - rhs.x, lhs.y - rhs.y);
}
template <typename T>
inline VecT<T>& operator-=(VecT<T>& lhs, const VecT<T>& rhs) {
  return lhs = lhs - rhs;
}
template <typename T, typename U>
inline VecT<decltype(T(1) * U(1))> operator*(const VecT<T>& v, U t) {
  return VecT<decltype(T(1) * U(1))>(v.x * t, v.y * t);
}
template <typename T, typename U>
inline VecT<decltype(T(1) * U(1))> operator*(U t, const VecT<T>& v) {
  return v * t;
}
template <typename T, typename U>
inline VecT<T>& operator*=(VecT<T>& v, U t) {
  v = v * t;
  return v;
}
template <typename T, typename U>
inline VecT<decltype(T(1) / U(1))> operator/(const VecT<T>& v, U t) {
  return VecT<decltype(T(1) / U(1))>(v.x / t, v.y / t);
}
template <typename T, typename U>
inline VecT<T>& operator/=(VecT<T>& v, U t) {
  v = v / t;
  return v;
}
template <typename T>
inline bool operator<(const VecT<T>& lhs, const VecT<T>& rhs) {
  if (cmpT(lhs.x - rhs.x) == 0) return cmpT(lhs.y - rhs.y) < 0;
  return cmpT(lhs.x - rhs.x) < 0;
}
template <typename T>
inline bool operator>(const VecT<T>& lhs, const VecT<T>& rhs) {
  return rhs < lhs;
}
template <typename T>
inline bool operator==(const VecT<T>& lhs, const VecT<T>& rhs) {
  return cmpT(lhs.x - rhs.x) == 0 && cmpT(lhs.y - rhs.y) == 0;
}
template <typename T>
inline bool operator!=(const VecT<T>& lhs, const VecT<T>& rhs) {
  return !(lhs == rhs);
}
template <typename T>
std::string to_string(const VecT<T>& v) {
  return std::string("VecT{x=") + std::to_string(v.x) +
         ",y=" + std::to_string(v.y) + "}";
}
template <typename T>
T det(const VecT<T>& a, const VecT<T>& b) {
  return a.x * b.y - a.y * b.x;
}
template <typename T>
T dot(const VecT<T>& a, const VecT<T>& b) {
  return a.x * b.x + a.y * b.y;
}
template <typename T>
using PointT = VecT<T>;
template <typename T>
using PolygonT = std::vector<PointT<T>>;
template <typename T>
bool polar_cmp(const VecT<T>& a, const VecT<T>& b) {
  if (cmpT(a.y) * cmpT(b.y) <= 0) {
    if (cmpT(a.y) > 0 || cmpT(b.y) > 0) return cmpT(a.y - b.y) < 0;
    if (cmpT(a.y) == 0 && cmpT(b.y) == 0) return cmpT(a.x - b.x) < 0;
  }
  return cmpT(det(a, b)) > 0;
}
template <typename T>
PointT<decltype(T(1) / double(1))> intersection_line_line(const PointT<T>& p,
                                                          const PointT<T>& pp,
                                                          const PointT<T>& q,
                                                          const PointT<T>& qq) {
  using R = decltype(T(1) / double(1));
  const VecT<T> u = p - q, v = pp - p, w = qq - q;
  const R ratio = det(w, u) / static_cast<R>(det(v, w));
  return PointT<R>(p.x + v.x * ratio, p.y + v.y * ratio);
}
template <typename T>
PointT<decltype(T(1) / double(1))> projection_point_line(const PointT<T>& p,
                                                         const PointT<T>& a,
                                                         const PointT<T>& b) {
  using R = decltype(T(1) / double(1));
  const VecT<T> v = b - a;
  const double ratio = dot(v, p - a) / static_cast<R>(dot(v, v));
  return PointT<R>(a.x + v.x * ratio, a.y + v.y * ratio);
}
template <typename T>
double distance_point_line(const PointT<T>& p, const PointT<T>& a,
                           const PointT<T>& b) {
  const VecT<T> v1 = b - a, v2 = p - a;
  return std::abs(det(v1, v2)) / v1.length();
}
template <typename T>
double distance_point_segment(const PointT<T>& p, const PointT<T>& a,
                              const PointT<T>& b) {
  if (a == b) return (p - a).length();
  const VecT<T> v1 = b - a, v2 = p - a, v3 = p - b;
  if (cmpT(dot(v1, v2)) < 0)
    return v2.length();
  else if (cmpT(dot(v1, v3)) > 0)
    return v3.length();
  else
    return std::abs(det(v1, v2)) / v1.length();
}
template <typename T>
bool has_proper_intersection_segment_segment(const PointT<T>& a1,
                                             const PointT<T>& a2,
                                             const PointT<T>& b1,
                                             const PointT<T>& b2) {
  T c1 = det(a2 - a1, b1 - a1), c2 = det(a2 - a1, b2 - a1),
    c3 = det(b2 - b1, a1 - b1), c4 = det(b2 - b1, a2 - b1);
  return cmpT(c1) * cmpT(c2) < 0 && cmpT(c3) * cmpT(c4) < 0;
}
template <typename T>
bool on_point_segment(const PointT<T>& p, const PointT<T>& a1,
                      const PointT<T>& a2) {
  return cmpT(det(a1 - p, a2 - p)) == 0 && cmpT(dot(a1 - p, a2 - p)) <= 0;
}
template <typename T>
bool has_intersection_segment_segment(const PointT<T>& a1, const PointT<T>& a2,
                                      const PointT<T>& b1,
                                      const PointT<T>& b2) {
  if (has_proper_intersection_segment_segment(a1, a2, b1, b2)) return true;
  return on_point_segment(a1, b1, b2) || on_point_segment(a2, b1, b2) ||
         on_point_segment(b1, a1, a2) || on_point_segment(b2, a1, a2);
}
template <typename T>
bool in_point_polygon(const PointT<T>& o, const PolygonT<T>& poly, bool flag) {
  int t = 0;
  PointT<T> a, b;
  const int n = poly.size();
  for (int i = 0; i < n; ++i)
    if (on_point_segment(o, poly[i], poly[(i + 1) % n])) return flag;
  for (int i = 0; i < n; ++i) {
    a = poly[i];
    b = poly[(i + 1) % n];
    if (cmpT(a.y - b.y) > 0) std::swap(a, b);
    if (cmpT(det(a - o, b - o)) < 0 && cmpT(a.y - o.y) < 0 &&
        cmpT(o.y - b.y) <= 0)
      ++t;
  }
  return t & 1;
}
using LL = long long;
const int kN = 100000 + 5;
int n;
LL k;
PointT<int> points[kN];
LL binom(int a, int b) {
  if (a < b || b < 0) return 0;
  LL ret = 1;
  for (int i = 1; i <= b; ++i) ret = ret * (a + 1 - i) / i;
  return ret;
}
using Point = PointT<double>;
struct Fenwick {
  std::vector<int> c;
  Fenwick(int n) : c(n) {}
  void update(int p, int dt) {
    for (int i = p; i < c.size(); i += ~i & i + 1) c[i] += dt;
  }
  int query(int p) const {
    int ret = 0;
    for (int i = p; i >= 0; i -= ~i & i + 1) ret += c[i];
    return ret;
  }
};
bool gao(double r) {
  int inner = 0;
  std::vector<Point> lp, rp;
  lp.reserve(n);
  rp.reserve(n);
  for (int i = 0; i < n; ++i) {
    const double d = points[i].length();
    if (cmpT(d - r) <= 0) {
      ++inner;
      continue;
    }
    const double theta = acos(r / d);
    const Point u = points[i] * (r / d);
    lp.emplace_back(u.rotate(-theta));
    rp.emplace_back(u.rotate(theta));
  }
  int outer = n - inner;
  LL cnt = outer * 1LL * inner + binom(inner, 2) + binom(outer, 2);
  if (cnt < k) return false;
  std::vector<Point> pts;
  pts.reserve(lp.size() + rp.size());
  pts.insert(pts.end(), lp.begin(), lp.end());
  pts.insert(pts.end(), rp.begin(), rp.end());
  std::sort(pts.begin(), pts.end(), polar_cmp<double>);
  pts.erase(std::unique(pts.begin(), pts.end()), pts.end());
  int m = pts.size();
  std::vector<std::vector<int>> segments(m), events(m);
  auto get = [&pts](const Point& p) {
    return std::lower_bound(pts.begin(), pts.end(), p, polar_cmp<double>) -
           pts.begin();
  };
  for (int i = 0; i < lp.size(); ++i) {
    int l = get(lp[i]);
    int r = get(rp[i]);
    if (l > r) std::swap(l, r);
    segments[l].emplace_back(r);
  }
  Fenwick bit(m);
  LL bad = 0;
  for (int i = 0; i < m; ++i) {
    for (int e : events[i]) {
      bit.update(e, -1);
    }
    bad += bit.query(i) * 1LL * events[i].size();
    for (int e : events[i]) {
      bad -= bit.query(e);
    }
    events[i].clear();
    if (cnt - bad < k) return false;
    bit.update(i, segments[i].size());
    for (int e : segments[i]) {
      events[e].emplace_back(i);
    }
  }
  return true;
}
double solve() {
  double l = 0.0, r = 15000.0;
  while (r - l > 5e-7) {
    double mid = (l + r) * 0.5;
    if (gao(mid))
      r = mid;
    else
      l = mid;
  }
  return (l + r) * 0.5;
}
int main() {
  scanf("%d%lld", &n, &k);
  for (int i = 0; i < n; ++i) {
    scanf("%d%d", &points[i].x, &points[i].y);
  }
  printf("%.13f\n", solve());
}