Problem: A new bus route is opened in the city <image>. The route is a closed polygon line in the place, with all segments parallel to one of the axes. m buses will operate on the route. All buses move in a loop along the route in the same direction with equal constant velocities (stopping times are negligible in this problem).

Buses start their movement in the first vertex of the route with equal interval. Suppose that T is the total time for a single bus to travel the whole loop of the route. Then, the bus 1 starts moving at time 0, the bus 2 starts at time T / m, the bus 3 starts at time 2T / m, and so on; finally, the bus m starts moving at time (m - 1)T / m. Thus, all intervals between pairs of consecutive buses (including the interval between the last and the first bus) are equal.

Buses can communicate with each other via wireless transmitters of equal power. If the transmitters have power D, then only buses within distance D of each other can communicate.

The buses are also equipped with a distributed system of schedule tracking. For all buses to stick to the schedule, the system has to synchronize the necessary data between all buses from time to time. At the moment of synchronization, the bus 1 communicates with the bus 2, the bus 2 — with bus 3, and so on; also, the bus m communicates with the bus 1.

As a research employee, you are tasked with finding the smallest value of D such that it is possible to find a time moment to perform synchronization once all buses have started moving. 

Input

The first line contains two integers n and m (2 ≤ n, m ≤ 105) — the number of vertices of the polygonal line, and the number of buses respectively.

Next n lines describe the vertices of the route in the traversing order. Each of these lines contains two integers xi, yi ( - 1000 ≤ xi, yi ≤ 1000) — coordinates of respective vertex.

It is guaranteed that each leg of the route (including the leg between the last and the first vertex) is paralles to one of the coordinate axes. Moreover, no two subsequent vertices of the route coincide. The route is allowed to have self-intersections, and travel along the same segment multiple times.

Output

Print one real number — the answer to the problem. Your answer will be accepted if the relative or the absolute error doesn't exceed 10 - 6.

Examples

Input

4 2
0 0
0 1
1 1
1 0


Output

1.000000000


Input

2 2
0 0
1 0


Output

0.000000000

Note

Suppose that each bus travel 1 distance unit per second.

In the first sample case, in 0.5 seconds buses will be at distance 1, hence we can choose D = 1.

In the second sample case, in 0.5 seconds both buses will be at (0.5, 0), hence we can choose D = 0.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
const int MAXM = 1e5 + 100;
const double EPS = 1e-9;
const int MAXO = 35;
const double INF = 3000;
inline bool eq(double a, double b) { return abs(a - b) < EPS; }
inline bool gr(double a, double b) { return a >= b + EPS; }
inline bool gr_eq(double a, double b) { return a > b - EPS; }
struct Point {
  double x, y;
  Point() {}
  inline Point(double xx, double yy) {
    x = xx;
    y = yy;
  }
};
struct Vector {
  double x, y;
  Vector() {}
  inline Vector(double xx, double yy) {
    x = xx;
    y = yy;
  }
  inline Vector(Point a, Point b) {
    x = b.x - a.x;
    y = b.y - a.y;
  }
  inline double dist() { return abs(x + y); }
  inline double distn() { return pow(x * x + y * y, 0.5); }
};
inline Vector norm_vector(Vector v, double k = 1) {
  double d = v.dist();
  v.x /= d;
  v.y /= d;
  v.x *= k;
  v.y *= k;
  return v;
}
inline Vector norm_vectorn(Vector v, double k = 1) {
  double d = v.distn();
  v.x /= d;
  v.y /= d;
  v.x *= k;
  v.y *= k;
  return v;
}
inline Vector operator+(Vector a, Vector b) {
  a.x += b.x;
  a.y += b.y;
  return a;
}
inline Vector operator-(Vector a, Vector b) {
  a.x -= b.x;
  a.y -= b.y;
  return a;
}
inline Point operator+(Point a, Vector b) {
  a.x += b.x;
  a.y += b.y;
  return a;
}
inline Point operator-(Point a, Vector b) {
  a.x -= b.x;
  a.y -= b.y;
  return a;
}
inline double operator*(Vector a, Vector b) { return (a.x * b.x + a.y * b.y); }
struct Line {
  double a, b, c;
  Line() {}
  inline Line(Point p1, Point p2) {
    a = -(p2.y - p1.y);
    b = p2.x - p1.x;
    c = -a * p1.x - b * p1.y;
    double d = pow(a * a + b * b, 0.5);
    a /= d;
    b /= d;
    c /= d;
  }
};
struct Circle {
  Point c;
  double r;
  Circle() {}
  inline Circle(Point cc, double rr) {
    c = cc;
    r = rr;
  }
};
inline bool point_in_circle(Point a, Circle c) {
  if (gr(c.r, Vector(c.c, a).distn())) {
    return true;
  } else {
    return false;
  }
}
bool cmt(pair<double, int>& a, pair<double, int>& b) {
  if (eq(a.first, b.first)) {
    return a.second < b.second;
  } else {
    return gr(b.first, a.first);
  }
}
int m;
vector<Point> ev_m[MAXM];
inline pair<double, double> per(Point p1, Point p2, Point q1, Point q2,
                                double r) {
  Vector v1 = Vector(p1, p2);
  Vector v2 = Vector(q1, q2);
  double sz = v1.distn();
  Vector v = v1 - v2;
  if (eq(v.x, 0) && eq(v.y, 0)) {
    if (point_in_circle(p1, Circle(q1, r))) {
      return {0, Vector(p1, p2).dist()};
    } else {
      return {0, 0};
    }
  } else {
    p1.x -= q1.x;
    p1.y -= q1.y;
    Line l(p1, p1 + v);
    Vector kat1(-l.a * l.c, -l.b * l.c);
    if (gr_eq(kat1.distn(), r)) {
      return {0, 0};
    } else {
      Vector kat2 = norm_vectorn(Vector(-l.b, l.a),
                                 pow(r * r - kat1.distn() * kat1.distn(), 0.5));
      Point a1 = Point(0, 0) + kat1 + kat2;
      kat2.x *= -1;
      kat2.y *= -1;
      Point a2 = Point(0, 0) + kat1 + kat2;
      Vector vs1 = Vector(p1, a1);
      Vector vs2 = Vector(p1, a2);
      double da1 = vs1.distn();
      double da2 = vs2.distn();
      if (gr(0, vs1 * v)) {
        da1 *= -1;
      }
      if (gr(0, vs2 * v)) {
        da2 *= -1;
      }
      if (gr(da1, da2)) {
        swap(da2, da1);
      }
      da1 = max((double)0, min(da1, v.distn()));
      da2 = max((double)0, min(da2, v.distn()));
      return {(da1 / v.distn()) * sz, (da2 / v.distn()) * sz};
    }
  }
}
inline bool pr(double r) {
  vector<pair<double, int>> vec;
  for (int l = 0; l < m; ++l) {
    int m1 = l;
    int m2 = (l + 1) % m;
    int mi1 = 0;
    int mi2 = 0;
    double mld1 = 0;
    double mld2 = 0;
    double cur_dist = 0;
    while (mi1 != ev_m[m1].size() - 1) {
      Vector v1 = Vector(ev_m[m1][mi1], ev_m[m1][mi1 + 1]);
      Vector v2 = Vector(ev_m[m2][mi2], ev_m[m2][mi2 + 1]);
      double d = min(v1.dist() - mld1, v2.dist() - mld2);
      Point s1 = ev_m[m1][mi1] + norm_vector(v1, mld1);
      Point s2 = ev_m[m2][mi2] + norm_vector(v2, mld2);
      auto for_d =
          per(s1, s1 + norm_vector(v1, d), s2, s2 + norm_vector(v2, d), r);
      for_d.first += cur_dist;
      for_d.second += cur_dist;
      vec.push_back({for_d.first, 1});
      vec.push_back({for_d.second, 0});
      mld1 += d;
      mld2 += d;
      cur_dist += d;
      if (eq(mld1, v1.dist())) {
        mi1++;
        mld1 = 0;
      }
      if (eq(mld2, v2.dist())) {
        mi2++;
        mld2 = 0;
      }
    }
  }
  sort(vec.begin(), vec.end(), cmt);
  int op = 0;
  for (int i = 0; i < vec.size(); ++i) {
    if (vec[i].second == 0) {
      op--;
    } else {
      op++;
    }
    if (op == m) {
      return true;
    }
  }
  return false;
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int n;
  cin >> n >> m;
  Point mas[MAXN];
  for (int i = 0; i < n; ++i) {
    cin >> mas[i].x >> mas[i].y;
  }
  double sz_marsh = 0;
  for (int i = 0; i < n; ++i) {
    sz_marsh += Vector(mas[i], mas[(i + 1) % n]).distn();
  }
  int last_v = 0;
  double last_dist = 0;
  for (int i = 0; i < m; ++i) {
    double ost_dist = sz_marsh / ((double)m);
    ev_m[i].push_back(
        mas[last_v] +
        norm_vector(Vector(mas[last_v], mas[(last_v + 1) % n]), last_dist));
    while (gr(ost_dist, 0)) {
      Vector v = Vector(mas[last_v], mas[(last_v + 1) % n]);
      double add_d = min(v.dist() - last_dist, ost_dist);
      last_dist += add_d;
      ost_dist -= add_d;
      if (eq(last_dist, v.dist())) {
        last_v = (last_v + 1) % n;
        last_dist = 0;
      }
      ev_m[i].push_back(
          mas[last_v] +
          norm_vector(Vector(mas[last_v], mas[(last_v + 1) % n]), last_dist));
    }
  }
  double l = 0;
  double r = INF;
  for (int o = 0; o < MAXO; ++o) {
    double m = (l + r) / 2;
    if (pr(m)) {
      r = m;
    } else {
      l = m;
    }
  }
  cout.precision(30);
  cout << l << endl;
  return 0;
}