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;
const long double EPS = 1e-16, PI = acosl(-1);
template <class T>
int sn(const T& x) {
  return x < -EPS ? -1 : (x > EPS);
}
template <class T>
struct P {
  T x, y;
  P(T _x = T(), T _y = T()) { x = _x, y = _y; }
  inline P<T> operator!() const { return P<T>(x, -y); }
  inline P<T> operator+(const P<T>& b) const { return P<T>(x + b.x, y + b.y); }
  inline P<T> operator-(const P<T>& b) const { return P<T>(x - b.x, y - b.y); }
  inline P<T> operator*(const P<T>& b) const {
    return P<T>(x * b.x - y * b.y, x * b.y + y * b.x);
  }
  inline P<T> operator*(const T& t) const { return P<T>(x * t, y * t); }
  inline P<T> operator/(const T& t) const { return P<T>(x / t, y / t); }
  inline P<T> div2(const P<T>& b) const { return (*this) * (!b); }
  inline P<T> operator/(const P<T>& b) const { return div2(b) / b.dis2(); }
  inline T dis2() const { return x * x + y * y; }
  inline T dis() const { return sqrtl(dis2()); }
  inline T cp(const P<T>& b) const { return x * b.y - y * b.x; }
  inline T dot(const P<T>& b) const { return x * b.x + y * b.y; }
  inline P<T> rot90() const { return P<T>(-y, x); }
  inline P<T> rot(const T& x) const { return (*this) * P<T>(cos(x), sin(x)); }
  inline int qua() const {
    return sn(y) >= 0 ? (sn(x) >= 0 ? 1 : 2) : (sn(x) >= 0 ? 4 : 3);
  }
  inline P<T> splay(const T& d) const { return (*this) / dis() * d; }
  inline long double angle() const { return atan2(y, x); }
};
template <class T>
istream& operator>>(istream& s, P<T>& p) {
  return s >> p.x >> p.y;
}
template <class T>
ostream& operator<<(ostream& s, P<T>& p) {
  return s << "(" << p.x << "," << p.y << ")";
}
template <class T>
struct Line {
  P<T> a[2];
  inline P<T>& operator[](int x) { return a[x]; }
  inline P<T> v() const { return a[1] - a[0]; }
  inline int in(const P<T>& x) const { return sn(v().cp(x - a[0])); }
  inline P<T> proj(const P<T>& x) const {
    return a[0] + v() * (x - a[0]).dot(v()) / v().dis2();
  }
  inline T dis(const P<T>& x) const { return (x - proj(x)).dis(); }
  inline Line<T> tran(const P<T>& x) const {
    return (Line){a[0] + x, a[1] + x};
  }
};
template <class T>
struct Circle {
  P<T> x;
  T r;
  Circle(P<T> _x = P<T>(), T _r = T()) { x = _x, r = _r; }
  Circle(P<T> a, P<T> b, P<T> c) {
    x = getIP(getPL(a, b), getPL(b, c));
    r = (x - a).dis();
  }
  int in(P<T> y) { return sn(r - (x - y).dis()); }
  vector<P<T> > getIP(Line<T> a) {
    P<T> s = a.proj(x);
    double dis1 = (x - s).dis();
    if (in(s) < 0) return {};
    if (in(s) == 0) return {s};
    P<T> v = a.v() * sqrtl(r * r - dis1 * dis1) / a.v().dis();
    return {s + v, s - v};
  }
  vector<Line<T> > getTG(P<T> a) {
    if (in(a) > 0) return {};
    if (in(a) == 0) return {(Line<T>){a, a + (x - a).rot90()}};
    long double s1 = (x - a).dis(),
                s2 = sqrtl(max((long double)0.0, s1 * s1 - r * r));
    P<T> p1 = (x - a) * P<T>(s2 / s1, r / s1),
         p2 = (x - a) * P<T>(s2 / s1, -r / s1);
    return {Line<T>{a, a + p1.splay(s2)}, (Line<T>){a, a + p2.splay(s2)}};
  }
};
template <class T>
istream& operator>>(istream& s, Circle<T>& a) {
  return s >> a.x >> a.r;
}
template <class T>
ostream& operator<<(ostream& s, Circle<T>& a) {
  return s << "[" << a.x << a.r << "]";
}
struct BIT {
  vector<int> c;
  inline void init(int n) { c = vector<int>(n + 1); }
  inline void add(int x, int key) {
    for (; x < c.size(); x += x & -x) c[x] += key;
  }
  inline int query(int x) {
    int ret = 0;
    for (; x; x -= x & -x) ret += c[x];
    return ret;
  }
} bit;
vector<P<long double> > a;
long long k;
long double normal(long double x) {
  while (x >= 2 * PI) x -= 2 * PI;
  while (x < 0) x += 2 * PI;
  return x;
}
bool cmp(pair<long double, int> x, pair<long double, int> y) {
  if (fabs(x.first - y.first) < EPS)
    return x.second < y.second;
  else
    return x.first < y.first;
}
long long solve(long double std) {
  Circle<long double> c(P<long double>(0, 0), std);
  vector<P<long double> > f;
  long long cnt = 0, ans = 0;
  for (auto x : a) {
    if (c.in(x) >= 0)
      ++cnt;
    else
      f.push_back(x);
  }
  vector<vector<int> > b(f.size(), vector<int>(2));
  ans += cnt * ((int)a.size() - 1 + (int)f.size()) / 2;
  vector<pair<long double, int> > key(f.size() * 2);
  for (int i = 0; i < f.size(); ++i) {
    vector<long double> g(2);
    long double s = f[i].angle(), d = acosl(c.r / (c.x - f[i]).dis());
    g[0] = normal(s - d);
    g[1] = normal(s + d);
    if (g[0] > g[1]) swap(g[0], g[1]);
    key[i + i] = make_pair(g[0], -(i + 1));
    key[i + i + 1] = make_pair(g[1], i + 1);
  }
  sort(key.begin(), key.end(), cmp);
  int tp = 0;
  vector<int> s;
  for (int i = 0; i < key.size(); ++i) {
    if (i == 0 || fabs(key[i].first - key[i - 1].first) >= EPS) ++tp;
    if (key[i].second < 0) {
      int x = -key[i].second - 1;
      b[x][0] = tp;
    } else {
      int x = key[i].second - 1;
      b[x][1] = tp;
      s.push_back(x);
    }
  }
  bit.init(tp);
  int j = 0;
  for (int i = 0; i < key.size(); ++i) {
    bool type = key[i].second > 0;
    int x = abs(key[i].second) - 1;
    while (j < s.size() && b[s[j]][1] <= b[x][type]) {
      bit.add(b[s[j]][0], 1);
      ++j;
    }
    if (!type)
      ans += bit.query(b[x][0]);
    else
      ans += bit.query(b[x][1]) - bit.query(b[x][0] - 1) - 1;
  }
  return ans;
}
int main() {
  int n;
  scanf("%d%lld", &n, &k);
  a.resize(n);
  for (int i = 0; i < n; ++i) {
    int x, y;
    scanf("%d%d", &x, &y);
    a[i] = P<long double>(x, y);
  }
  long double left = 1e-10, right = sqrtl(2) * 1e4 + 1;
  while (right - left > 2e-7) {
    long double mid = (left + right) / 2;
    if (solve(mid) >= k)
      right = mid;
    else
      left = mid;
  }
  printf("%.10Lf\n", right);
  return 0;
}