// Skyqwq
#include <bits/stdc++.h>

#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define y1 dmytxdy

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;

template <typename T> bool chkMax(T &x, T y) {
    return (y > x) ? x = y, 1 : 0;
}
template <typename T> bool chkMin(T &x, T y) {
    return (y < x) ? x = y, 1 : 0;
}

template <typename T> void inline read(T &x) {
    int f = 1;
    x = 0;
    char s = getchar();

    while (s < '0' || s > '9') {
        if (s == '-')
            f = -1;

        s = getchar();
    }

    while (s <= '9' && s >= '0')
        x = x * 10 + (s ^ 48), s = getchar();

    x *= f;
}


typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double ld;

template <typename T> bool chkmin(T &x, T y) {
    return x > y ? x = y, 1 : 0;
}
template <typename T> bool chkmax(T &x, T y) {
    return x < y ? x = y, 1 : 0;
}

int readint() {
    int x = 0, f = 1;
    char ch = getchar();

    while (ch < '0' || ch > '9') {
        if (ch == '-')
            f = -1;

        ch = getchar();
    }

    while (ch >= '0' && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }

    return x * f;
}

const int N = 1005;

const long double eps = 1e-6;
typedef pair<long double, long double> PDD;

int inline cmp(long double x, long double y) {
    if (fabs(x - y) < eps)
        return 0;

    return x < y ? -1 : 1;
}

long double inline cross(PDD a, PDD b) {
    return a.fi * b.se - a.se * b.fi;
}
PDD operator - (const PDD &a, const PDD &b) {
    return make_pair(a.fi - b.fi, a.se - b.se);
}
PDD operator + (const PDD &a, const PDD &b) {
    return make_pair(a.fi + b.fi, a.se + b.se);
}
PDD operator / (const PDD &a, long double b) {
    return make_pair(a.fi / b, a.se / b);
}
PDD operator * (const PDD &a, long double b) {
    return make_pair(a.fi * b, a.se * b);
}
long double inline area(PDD a, PDD b, PDD c) {
    return cross(b - a, c - a);
}
long double inline dot(PDD a, PDD b) {
    return a.fi * b.fi + a.se * b.se;
}
long double inline len(PDD a) {
    return sqrt(dot(a, a));
}
long double inline project(PDD a, PDD b, PDD c) {
    return dot(b - a, c - a) / len(b - a);
}
long double inline dist(PDD a, PDD b) {
    return sqrt((a.fi - b.fi) * (a.fi - b.fi) + (a.se - b.se) * (a.se - b.se));
}
// 顺时针转 x
PDD inline rotate(PDD a, long double x) {
    return make_pair(cos(x) * a.fi + sin(x) * a.se, -sin(x) * a.fi + cos(x) * a.se);
}
PDD inline norm(PDD a) {
    return a / len(a);
}
long double angle(PDD a, PDD b) {
    return acos(dot(a, b) / len(a) / len(b));
}

int n, k;

PDD a[N];

long double L = 0;

PDD x1[N], y1[N];

long double lim[N];

struct Line {
    int op;
    long double L, kx, bx, ky, by;
    bool operator < (const Line &b) const {
        return L < b.L;
    }
};

struct AC {
    int o;
    long double x, A, B, C;
    bool operator < (const AC &b) const {
        return x < b.x;
    }
} ct[N];

vector<AC> e;

vector<Line> X;

long double inline mod(long double k) {
    if (k >= L)
        k -= L;

    return k;
}

void bd(long double o, int op) {
    for (int i = 1; i <= n; i++) {
        if (lim[i] + o <= L && lim[i + 1] + o > L) {
            X.pb((Line) {
                op, lim[i] + o, x1[i].fi, x1[i].se - x1[i].fi *o, y1[i].fi, y1[i].se - y1[i].fi *o
            });
            X.pb((Line) {
                op, 0, x1[i].fi, x1[i].se - x1[i].fi * (o - L), y1[i].fi, y1[i].se - y1[i].fi * (o - L)
            });
            //  puts("tototot\n");
        } else if (lim[i] + o <= L) {
            X.pb((Line) {
                op, lim[i] + o, x1[i].fi, x1[i].se - x1[i].fi *o, y1[i].fi, y1[i].se - y1[i].fi *o
            });
        } else {
            X.pb((Line) {
                op, lim[i] + o - L, x1[i].fi, x1[i].se - x1[i].fi * (o - L), y1[i].fi, y1[i].se - y1[i].fi * (o - L)
            });
        }
    }
}

Line cur[2];



long double A, B, C, ans = 1e18, le, re;

void inline calc(long double x) {
    if (cmp(x, le) == -1 || cmp(x, re) == 1)
        return;

    long double val = x * x * A + B * x + C;
    //if (val < 0) return;
    chkMin(ans, val);
}

void inline upd() {
    calc(le);
    calc(re);
    calc(-B / A / 2);
}

int main() {
    //freopen("1.in", "r", stdin);
    n = readint();
    k = readint();

    for (int i = 1; i <= n; i++)
        a[i].fi = readint(), a[i].se = readint();

    a[n + 1] = a[1];

    for (int i = 1; i <= n; i++)
        L += dist(a[i], a[i + 1]);

    long double now = 0;
    long double D = L / k;

    for (int i = 1; i <= n; i++) {
        long double len = dist(a[i], a[i + 1]);
        x1[i] = mp((a[i + 1].fi - a[i].fi) / len, a[i].fi);
        y1[i] = mp((a[i + 1].se - a[i].se) / len, a[i].se);
        x1[i].se -= x1[i].fi * now;
        y1[i].se -= y1[i].fi * now;
        lim[i] = now;
        //  cout << x1[i].fi << " " << x1[i].se << "---" << y1[i].fi << " " << y1[i].se << " ji\n";
        now += len;
    }

    lim[n + 1] = now;

    //cout << D <<" ??aaa\n";
    for (int i = 0; i < k; i++) {
        X.clear();
        long double B = D * i, A = D * (i + 1);

        if (i == k - 1)
            A = 0;

        bd(A, 0);
        bd(B, 1);
        //cout << " now it show time for " << A << " " << B << "??\n";
        sort(X.begin(), X.end());

        for (int j = 0; j < X.size(); j++) {
            Line o = X[j];
            cur[o.op] = o;

            if (j + 1 < X.size() && !cmp(X[j].L, X[j + 1].L))
                continue;

            //  cout << o.L << "->>\n" << cur[0].kx << " " << cur[0].bx << " " << cur[0].ky << " " << cur[0].by << endl;
            //  cout << o.L << "->>\n" << cur[1].kx << " " << cur[1].bx << " " << cur[1].ky << " " << cur[1].by << endl;
            //  cout << 0 << " " << o.L << "->>\n" << cur[0].kx * o.L + cur[0].bx << " " << cur[0].ky * o.L + cur[0].by << endl;
            //  cout << 1 << " "<< o.L << "->>\n" << cur[1].kx * o.L + cur[1].bx << " " << cur[1].ky * o.L + cur[1].by << endl;
            e.pb((AC) {
                i, o.L, (cur[0].kx * cur[1].ky - cur[1].kx * cur[0].ky),
                cur[0].kx *cur[1].by + cur[0].bx *cur[1].ky - (cur[1].kx * cur[0].by + cur[1].bx * cur[0].ky),
                cur[0].bx *cur[1].by - cur[1].bx *cur[0].by
            });
        }
    }

    sort(e.begin(), e.end());

    for (int i = 0; i < e.size(); i++) {
        int u = e[i].o;
        A -= ct[u].A, B -= ct[u].B, C -= ct[u].C;
        ct[u] = e[i];
        A += ct[u].A, B += ct[u].B, C += ct[u].C;

        if (i + 1 < e.size() && !cmp(e[i].x, e[i + 1].x))
            continue;

        le = e[i].x, re = L;

        if (i + 1 < e.size())
            re = e[i + 1].x;

        //      cout << i << " " << le << " " << re << "zjsw??\n";
        upd();
    }

    printf("%.10Lf\n", ans / 2);
    return 0;
}