description: Mr. Chanek lives in a city represented as a plane. He wants to build an amusement park in the shape of a circle of radius r. The circle must touch the origin (point (0, 0)).
  
  There are n bird habitats that can be a photo spot for the tourists in the park. The i-th bird habitat is at point p_i = (x_i, y_i). 
  
  Find the minimum radius r of a park with at least k bird habitats inside. 
  
  A point is considered to be inside the park if and only if the distance between p_i and the center of the park is less than or equal to the radius of the park. Note that the center and the radius of the park do not need to be integers.
  
  In this problem, it is guaranteed that the given input always has a solution with r ≤ 2 ⋅ 10^5.
  
  Input
  
  The first line contains two integers n and k (1 ≤ n ≤ 10^5, 1 ≤ k ≤ n) — the number of bird habitats in the city and the number of bird habitats required to be inside the park.
  
  The i-th of the next n lines contains two integers x_i and y_i (0 ≤ |x_i|, |y_i| ≤ 10^5) — the position of the i-th bird habitat.
  
  Output
  
  Output a single real number r denoting the minimum radius of a park with at least k bird habitats inside. It is guaranteed that the given input always has a solution with r ≤ 2 ⋅ 10^5.
  
  Your answer is considered correct if its absolute or relative error does not exceed 10^{-4}.
  
  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^{-4}.
  
  Examples
  
  Input
  
  
  8 4
  -3 1
  -4 4
  1 5
  2 2
  2 -2
  -2 -4
  -1 -1
  -6 0
  
  
  Output
  
  
  3.1622776589
  
  
  Input
  
  
  1 1
  0 0
  
  
  Output
  
  
  0.0000000000
  
  Note
  
  In the first example, Mr. Chanek can put the center of the park at (-3, -1) with radius √{10} ≈ 3.162. It can be proven this is the minimum r.
  
  The following illustrates the first example. The blue points represent bird habitats and the red circle represents the amusement park.
  
  <image>
solution: #include <bits/stdc++.h>
  using namespace std;
  using Real = double;
  const Real EPS = 1e-10;
  const Real PI = acos((Real)-1);
  bool eq(Real a, Real b) { return abs(a - b) < EPS; }
  struct Point {
    Real x, y;
    Point(Real x_ = 0, Real y_ = 0) : x(x_), y(y_) {}
    Point operator-() const { return Point(-x, -y); }
    Point operator+(const Point& p) const { return Point(x + p.x, y + p.y); }
    Point operator-(const Point& p) const { return Point(x - p.x, y - p.y); }
    Point operator*(const Real k) const { return Point(x * k, y * k); }
    Point operator/(const Real k) const { return Point(x / k, y / k); }
    bool operator<(const Point& p) const {
      return eq(x, p.x) ? y < p.y : x < p.x;
    }
    bool operator==(const Point& p) const { return eq(x, p.x) && eq(y, p.y); }
  };
  istream& operator>>(istream& is, Point& p) { return is >> p.x >> p.y; }
  ostream& operator<<(ostream& os, const Point& p) {
    return os << fixed << setprecision(9) << p.x << ' ' << p.y;
  }
  struct Line {
    Point p1, p2;
    Line(Point p1_ = Point(), Point p2_ = Point()) : p1(p1_), p2(p2_) {}
  };
  struct Segment : Line {
    Segment(Point p1_ = Point(), Point p2_ = Point()) : Line(p1_, p2_) {}
  };
  struct Circle {
    Point o;
    Real r;
    Circle(Point o_ = Point(), Real r_ = 0) : o(o_), r(r_) {}
  };
  using Polygon = vector<Point>;
  Point vec(const Line&);
  Real norm(const Point&);
  Real norm(const Line&);
  Real abs(const Point&);
  Real abs(const Line&);
  Real arg(const Point&);
  Real arg(const Line&);
  Real arg(const Point&, const Point&, const Point&);
  int argtype(const Point&);
  bool argless(const Point&, const Point&);
  Real dot(const Point&, const Point&);
  Real cross(const Point&, const Point&);
  Point polar(const Real, const Real);
  Point rotate(const Point&, const Real);
  enum {
    ONLINE_FRONT = -2,
    CLOCKWISE = -1,
    ON_SEGMENT = 0,
    COUNTER_CLOCKWISE = 1,
    ONLINE_BACK = 2
  };
  int ccw(const Point&, const Point&);
  int ccw(const Point&, const Point&, const Point&);
  int ccw(const Line&, const Point&);
  bool orthogonal(const Point&, const Point&);
  bool orthogonal(const Line&, const Line&);
  bool parallel(const Point&, const Point&);
  bool parallel(const Line&, const Line&);
  bool intersect(const Line&, const Point&);
  bool intersect(const Line&, const Line&);
  bool intersect(const Segment&, const Point&);
  bool intersect(const Segment&, const Segment&);
  bool intersect(const Line&, const Segment&);
  bool intersect(const Segment&, const Line&);
  bool intersect(const Circle&, const Point&);
  int intersect(const Circle&, const Line&);
  int intersect(const Circle&, const Segment&);
  bool intersect(const Circle&, const Circle&);
  int count_tangent(const Circle&, const Circle&);
  Real distance(const Point&, const Point&);
  Real distance(const Line&, const Point&);
  Real distance(const Line&, const Line&);
  Real distance(const Segment&, const Point&);
  Real distance(const Segment&, const Segment&);
  Real distance(const Line&, const Segment&);
  Real distance(const Segment&, const Line&);
  Real distance(const Circle&, const Point&);
  Real distance(const Circle&, const Line&);
  Real distance(const Circle&, const Segment&);
  Real distance(const Circle&, const Circle&);
  Point projection(const Line&, const Point&);
  Point reflection(const Line&, const Point&);
  Point crosspoint(const Line&, const Line&);
  pair<Point, Point> crosspoint(const Circle&, const Line&);
  pair<Point, Point> crosspoint(const Circle&, const Segment&);
  pair<Point, Point> crosspoint(const Circle&, const Circle&);
  pair<Point, Point> tangent(const Circle&, const Point&);
  vector<Line> tangent(const Circle&, const Circle&);
  bool is_convex(const Polygon&);
  Polygon convex_hull(Polygon, bool = false);
  enum { OUT, ON, IN };
  int contain(const Polygon&, const Point&);
  int contain(const Circle&, const Point&);
  int contain(const Circle&, const Segment&);
  int convex_contain(const Polygon&, const Point&);
  Polygon convex_cut(const Polygon&, const Line&);
  Real diameter(Polygon);
  Real area(const Polygon&);
  Real area(const Polygon&, const Line&);
  Real area(const Polygon&, const Circle&);
  Real area(const Circle&);
  Real area(const Circle&, const Circle&);
  Point vec(const Line& s) { return s.p2 - s.p1; }
  Real norm(const Point& p) { return p.x * p.x + p.y * p.y; }
  Real norm(const Line& s) { return norm(vec(s)); }
  Real abs(const Point& p) { return hypot(p.x, p.y); }
  Real abs(const Line& s) { return abs(vec(s)); }
  Real arg(const Point& p) { return atan2(p.y, p.x); }
  Real arg(const Line& s) { return arg(vec(s)); }
  Real arg(const Point& a, const Point& b, const Point& c) {
    Real A = arg(a - b), B = arg(c - b);
    Real theta = abs(A - B);
    return min(theta, 2 * PI - theta);
  }
  int argtype(const Point& a) {
    return a.y < -EPS ? -1 : a.y > EPS ? 1 : a.x < -EPS ? 1 : a.x > EPS ? -1 : 0;
  }
  bool argless(const Point& a, const Point& b) {
    int at = argtype(a), bt = argtype(b);
    return at != bt ? at < bt : ccw(a, b) > 0;
  }
  Real dot(const Point& a, const Point& b) { return a.x * b.x + a.y * b.y; }
  Real cross(const Point& a, const Point& b) { return a.x * b.y - a.y * b.x; }
  Point polar(const Real r, const Real theta) {
    return Point(cos(theta), sin(theta)) * r;
  }
  Point rotate(const Point& p, const Real theta) {
    return Point(p.x * cos(theta) - p.y * sin(theta),
                 p.x * sin(theta) + p.y * cos(theta));
  }
  int ccw(const Point& a, const Point& b) {
    return cross(a, b) > EPS    ? COUNTER_CLOCKWISE
           : cross(a, b) < -EPS ? CLOCKWISE
           : dot(a, b) < 0      ? ONLINE_BACK
           : norm(a) < norm(b)  ? ONLINE_FRONT
                                : ON_SEGMENT;
  }
  int ccw(const Point& a, const Point& b, const Point& c) {
    return ccw(b - a, c - a);
  }
  int ccw(const Line& s, const Point& p) { return ccw(s.p1, s.p2, p); }
  bool orthogonal(const Point& a, const Point& b) { return eq(dot(a, b), 0); }
  bool orthogonal(const Line& s, const Line& t) {
    return orthogonal(vec(s), vec(t));
  }
  bool parallel(const Point& a, const Point& b) { return eq(cross(a, b), 0); }
  bool parallel(const Line& s, const Line& t) { return parallel(vec(s), vec(t)); }
  bool intersect(const Line& s, const Point& p) {
    return eq(cross(vec(s), p - s.p1), 0);
  }
  bool intersect(const Line& s, const Line& t) {
    return !parallel(s, t) || intersect(s, t.p1);
  }
  bool intersect(const Segment& s, const Point& p) {
    return ccw(s, p) == ON_SEGMENT;
  }
  bool intersect(const Segment& s, const Segment& t) {
    return ccw(s, t.p1) * ccw(s, t.p2) <= 0 && ccw(t, s.p1) * ccw(t, s.p2) <= 0;
  }
  bool intersect(const Line& s, const Segment& t) {
    return cross(vec(s), t.p1 - s.p1) * cross(vec(s), t.p2 - s.p1) < EPS;
  }
  bool intersect(const Segment& s, const Line& t) { return intersect(t, s); }
  bool intersect(const Circle& c, const Point& p) {
    return eq(distance(c.o, p), c.r);
  }
  int intersect(const Circle& c, const Line& s) {
    Real d = distance(s, c.o);
    return eq(d, c.r) ? 1 : d < c.r ? 2 : 0;
  }
  int intersect(const Circle& c, const Segment& s) {
    Point h = projection(s, c.o);
    Real d1 = distance(c.o, s.p1), d2 = distance(c.o, s.p2);
    return distance(c.o, h) > c.r + EPS       ? 0
           : d1 < c.r - EPS && d2 < c.r - EPS ? 0
           : (d1 < c.r - EPS && d2 > c.r - EPS) ||
                   (d1 > c.r - EPS && d2 < c.r - EPS)
               ? 1
           : intersect(s, h) ? eq(distance(c.o, h), c.r) ? 1 : 2
                             : 0;
  }
  bool intersect(const Circle& a, const Circle& b) {
    int c = count_tangent(a, b);
    return 1 <= c && c <= 3;
  }
  int count_tangent(const Circle& a, const Circle& b) {
    Real d = distance(a.o, b.o);
    return eq(d, a.r + b.r)        ? 3
           : d > a.r + b.r         ? 4
           : eq(d, abs(a.r - b.r)) ? 1
           : d > abs(a.r - b.r)    ? 2
                                   : 0;
  }
  Real distance(const Point& a, const Point& b) { return abs(a - b); }
  Real distance(const Line& s, const Point& p) {
    return distance(p, projection(s, p));
  }
  Real distance(const Line& s, const Line& t) {
    return intersect(s, t) ? 0 : distance(s, t.p1);
  }
  Real distance(const Segment& s, const Point& p) {
    return distance(p, dot(vec(s), p - s.p1) < 0    ? s.p1
                       : dot(-vec(s), p - s.p2) < 0 ? s.p2
                                                    : projection(s, p));
  }
  Real distance(const Segment& s, const Segment& t) {
    return intersect(s, t) ? 0
                           : min({distance(s, t.p1), distance(s, t.p2),
                                  distance(t, s.p1), distance(t, s.p2)});
  }
  Real distance(const Line& s, const Segment& t) {
    return intersect(s, t) ? 0 : min(distance(s, t.p1), distance(s, t.p2));
  }
  Real distance(const Segment& s, const Line& t) { return distance(t, s); }
  Real distance(const Circle& c, const Point& p) {
    return abs(distance(c.o, p) - c.r);
  }
  Real distance(const Circle& c, const Line& s) {
    return max(distance(s, c.o) - c.r, (Real)0);
  }
  Real distance(const Circle& c, const Segment& s) {
    return intersect(c, s) ? 0
           : contain(c, s) ? c.r - max(distance(c.o, s.p1), distance(c.o, s.p2))
                           : distance(s, c.o) - c.r;
  }
  Real distance(const Circle& a, const Circle& b) {
    return max(distance(a.o, b.o) - a.r - b.r, (Real)0);
  }
  Point projection(const Line& s, const Point& p) {
    return s.p1 + vec(s) * dot(p - s.p1, vec(s)) / norm(s);
  }
  Point reflection(const Line& s, const Point& p) {
    return projection(s, p) * 2 - p;
  }
  Point crosspoint(const Line& s, const Line& t) {
    Real d1 = cross(vec(s), t.p1 - s.p1);
    Real d2 = -cross(vec(s), t.p2 - s.p1);
    return t.p1 + vec(t) * (d1 / (d1 + d2));
  }
  pair<Point, Point> crosspoint(const Circle& c, const Line& s) {
    Point h = projection(s, c.o);
    Point e = vec(s) / abs(s) * sqrt(c.r * c.r - norm(h - c.o));
    return minmax(h - e, h + e);
  }
  pair<Point, Point> crosspoint(const Circle& c, const Segment& s) {
    pair<Point, Point> p = crosspoint(c, Line(s));
    return intersect(c, s) == 2    ? p
           : intersect(s, p.first) ? make_pair(p.first, p.first)
                                   : make_pair(p.second, p.second);
  }
  pair<Point, Point> crosspoint(const Circle& a, const Circle& b) {
    Real d = distance(a.o, b.o);
    Real alpha = acos((a.r * a.r + d * d - b.r * b.r) / (2 * a.r * d));
    Real theta = arg(b.o - a.o);
    return minmax(a.o + polar(a.r, theta + alpha),
                  a.o + polar(a.r, theta - alpha));
  }
  pair<Point, Point> tangent(const Circle& c, const Point& p) {
    return crosspoint(c, Circle(p, sqrt(norm(c.o - p) - c.r * c.r)));
  }
  vector<Line> tangent(const Circle& a, const Circle& b) {
    vector<Line> ret;
    Real g = distance(a.o, b.o);
    if (eq(g, 0)) return ret;
    Point u = (b.o - a.o) / g;
    Point v = rotate(u, PI / 2);
    for (int s : {-1, 1}) {
      Real h = (a.r + b.r * s) / g;
      if (eq(h * h, 1))
        ret.emplace_back(a.o + (h > 0 ? u : -u) * a.r,
                         a.o + (h > 0 ? u : -u) * a.r + v);
      else if (1 - h * h > 0) {
        Point U = u * h, V = v * sqrt(1 - h * h);
        ret.emplace_back(a.o + (U + V) * a.r, b.o - (U + V) * b.r * s);
        ret.emplace_back(a.o + (U - V) * a.r, b.o - (U - V) * b.r * s);
      }
    }
    return ret;
  }
  bool is_convex(const Polygon& P) {
    for (int i = 0; i < P.size(); i++)
      if (ccw(P[i], P[(i + 1) % P.size()], P[(i + 2) % P.size()]) == CLOCKWISE)
        return false;
    return true;
  }
  Polygon convex_hull(Polygon P, bool ONSEG) {
    if (P.size() <= 2) return P;
    sort(P.begin(), P.end());
    Polygon ret(2 * P.size());
    int k = 0, t;
    if (ONSEG) {
      for (const Point& p : P) {
        while (k >= 2 && ccw(ret[k - 2], ret[k - 1], p) == CLOCKWISE) k--;
        ret[k++] = p;
      }
      t = k;
      for (int i = P.size() - 2; i >= 0; i--) {
        while (k >= t + 1 && ccw(ret[k - 2], ret[k - 1], P[i]) == CLOCKWISE) k--;
        ret[k++] = P[i];
      }
    } else {
      for (const Point& p : P) {
        while (k >= 2 && ccw(ret[k - 2], ret[k - 1], p) != COUNTER_CLOCKWISE) k--;
        ret[k++] = p;
      }
      t = k;
      for (int i = P.size() - 2; i >= 0; i--) {
        while (k >= t + 1 &&
               ccw(ret[k - 2], ret[k - 1], P[i]) != COUNTER_CLOCKWISE)
          k--;
        ret[k++] = P[i];
      }
    }
    ret.resize(k - 1);
    int mi = 0;
    for (int i = 1; i < k - 1; i++)
      if (eq(ret[mi].y, ret[i].y) ? ret[mi].x > ret[i].x : ret[mi].y > ret[i].y)
        mi = i;
    rotate(ret.begin(), ret.begin() + mi, ret.end());
    return ret;
  }
  int contain(const Polygon& P, const Point& p) {
    bool in = false;
    for (int i = 0; i < P.size(); i++) {
      Segment s(P[i], P[(i + 1) % P.size()]);
      if (intersect(s, p))
        return ON;
      else {
        Point a = s.p1 - p, b = s.p2 - p;
        if (a.y > b.y) swap(a, b);
        if (a.y < EPS && EPS < b.y && cross(a, b) > EPS) in = !in;
      }
    }
    return in ? IN : OUT;
  }
  int contain(const Circle& c, const Point& p) {
    Real d = distance(c.o, p);
    return eq(d, c.r) ? ON : d < c.r ? IN : OUT;
  }
  int contain(const Circle& c, const Segment& s) {
    Real d1 = distance(c.o, s.p1), d2 = distance(c.o, s.p2);
    return d1 < c.r + EPS && d2 < c.r + EPS ? eq(d1, c.r) || eq(d2, c.r) ? ON : IN
                                            : OUT;
  }
  int convex_contain(const Polygon& P, const Point& p) {
    if (P[0] == p) return ON;
    int l = 0, r = P.size();
    while (r - l > 1) {
      int mid = (l + r) / 2;
      int t = ccw(P[0], P[mid], p);
      if (t == CLOCKWISE)
        r = mid;
      else
        l = mid;
    }
    if (r == 1) return OUT;
    if (l + 1 == P.size()) {
      if (intersect(Segment(P[0], P[P.size() - 1]), p))
        return ON;
      else
        return OUT;
    }
    if (l == 1 && intersect(Segment(P[0], P[1]), p)) return ON;
    Polygon tmp = {P[0], P[l], P[l + 1]};
    int ret = contain(tmp, p);
    if (ret == ON) {
      if (intersect(Segment(P[l], P[l + 1]), p))
        return ON;
      else
        return IN;
    }
    return ret;
  }
  Polygon convex_cut(const Polygon& P, const Line& s) {
    Polygon ret;
    for (int i = 0; i < P.size(); i++) {
      Segment t(P[i], P[(i + 1) % P.size()]);
      if (ccw(s, t.p1) != CLOCKWISE) ret.push_back(t.p1);
      if (!parallel(s, t) && !intersect(s, t.p1) && !intersect(s, t.p2) &&
          intersect(s, t))
        ret.push_back(crosspoint(s, t));
    }
    return ret;
  }
  Real diameter(Polygon P) {
    if (!is_convex(P)) P = convex_hull(P);
    int mi = 0, Mi = 0;
    for (int i = 1; i < P.size(); i++) {
      if (P[i].x < P[mi].x) mi = i;
      if (P[i].x > P[Mi].x) Mi = i;
    }
    Real ret = 0;
    int sm = mi, sM = Mi;
    while (mi != sM || Mi != sm) {
      ret = max(ret, norm(P[mi] - P[Mi]));
      if (cross(P[(mi + 1) % P.size()] - P[mi], P[(Mi + 1) % P.size()] - P[Mi]) <
          0)
        mi = (mi + 1) % P.size();
      else
        Mi = (Mi + 1) % P.size();
    }
    return sqrt(ret);
  }
  Real area(const Polygon& P) {
    Real ret = 0;
    for (int i = 0; i < P.size(); i++) ret += cross(P[i], P[(i + 1) % P.size()]);
    return ret / 2;
  }
  Real area(const Polygon& P, const Line& s) { return area(convex_cut(P, s)); }
  Real area(const Polygon& P, const Circle& c) {
    Real ret = 0;
    for (int i = 0; i < P.size(); i++) {
      Segment s(P[i], P[(i + 1) % P.size()]);
      if (contain(c, s))
        ret += cross(s.p1 - c.o, s.p2 - c.o);
      else if (!intersect(c, s)) {
        Real a = arg(s.p2 - c.o) - arg(s.p1 - c.o);
        if (a > PI) a -= 2 * PI;
        if (a < -PI) a += 2 * PI;
        ret += c.r * c.r * a;
      } else {
        pair<Point, Point> p = crosspoint(c, s);
        Point tmp[4] = {s.p1, p.first, p.second, s.p2};
        if (intersect(c, Segment(s.p1, p.first)) == 2) swap(tmp[1], tmp[2]);
        for (int j = 0; j < 3; j++) {
          Segment t(tmp[j], tmp[j + 1]);
          if (contain(c, t))
            ret += cross(t.p1 - c.o, t.p2 - c.o);
          else {
            Real a = arg(t.p2 - c.o) - arg(t.p1 - c.o);
            if (a > PI) a -= 2 * PI;
            if (a < -PI) a += 2 * PI;
            ret += c.r * c.r * a;
          }
        }
      }
    }
    return ret / 2;
  }
  Real area(const Circle& c) { return PI * c.r * c.r; }
  Real area(const Circle& a, const Circle& b) {
    int c = count_tangent(a, b);
    if (c >= 3)
      return 0;
    else if (c <= 1)
      return area(a.r < b.r ? a : b);
    else {
      Real d = distance(a.o, b.o);
      Real ret = 0;
      {
        Real alpha = acos((a.r * a.r + d * d - b.r * b.r) / (2 * a.r * d));
        ret += alpha * a.r * a.r;
        ret -= sin(alpha * 2) * a.r * a.r / 2;
      }
      {
        Real alpha = acos((b.r * b.r + d * d - a.r * a.r) / (2 * b.r * d));
        ret += alpha * b.r * b.r;
        ret -= sin(alpha * 2) * b.r * b.r / 2;
      }
      return ret;
    }
  }
  int N, K;
  Point P[1 << 17];
  bool check(double r) {
    vector<pair<double, bool> > X;
    X.reserve(4 * N);
    int cnt = 0;
    for (int i = 0; i < N; i++) {
      Real d = distance(Point(), P[i]);
      if (d < EPS) {
        cnt++;
        continue;
      }
      if (d > 2 * r - EPS) continue;
      Real alpha = acos(d / (2 * r));
      Real theta = arg(P[i]);
      double t = theta - alpha, u = theta + alpha;
      while (t < 0) t += 2 * M_PI, u += 2 * M_PI;
      u += EPS;
      X.push_back(make_pair(t, false));
      X.push_back(make_pair(t + 2 * M_PI, false));
      X.push_back(make_pair(u, true));
      X.push_back(make_pair(u + 2 * M_PI, true));
    }
    sort(X.begin(), X.end());
    if (cnt >= K) return true;
    for (pair<double, bool> p : X) {
      if (!p.second) cnt++;
      if (cnt >= K) return true;
      if (p.second) cnt--;
    }
    return false;
  }
  int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> N >> K;
    for (int i = 0; i < N; i++) cin >> P[i];
    double L = 0, R = 2e5 + 10;
    for (int t = 0; t < 70; t++) {
      double r = (L + R) / 2;
      if (check(r))
        R = r;
      else
        L = r;
    }
    cout << fixed << setprecision(16) << R << endl;
  }
  