#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<ll,ll> pll;
#define F first
#define S second

template<typename T,typename U>istream & operator >> (istream &i,pair<T,U> &A){i>>A.F>>A.S; return i;}
template<typename T>istream & operator >> (istream &i,vector<T> &A){for(auto &I:A){i>>I;} return i;}



namespace Geometry{
    typedef long double D;
    typedef complex<long double> P;
    typedef pair<P,D> C;
    
    const D EPS=1e-9;
    
    static bool comp(const P &p1,const P &p2){
        if(p1.real()==p2.real()){return p1.imag()<p2.imag();}
        return p1.real()<p2.real();
    }
    
    D dot(P p1,P p2){return p1.real()*p2.real()+p1.imag()*p2.imag();}
    
    D cross(P p1,P p2){return p1.real()*p2.imag()-p1.imag()*p2.real();}
    
    bool intersectSL(P p1,P p2,P vec){
        vec/=abs(vec); p1/=vec; p2/=vec;
        return (p1.imag()<EPS && p2.imag()>-EPS) || (p1.imag()>-EPS && p2.imag()<EPS);
    }
    
    bool intersectSL(P p1,P p2,P p3,P p4){return intersectSL(p1-p4,p2-p4,p3-p4);}
    
    bool intersectSS(P p1,P p2,P p3,P p4){
        if(dot(p2-p1,p3-p1)<-EPS && dot(p2-p1,p4-p1)<-EPS){return false;}
        if(dot(p1-p2,p3-p2)<-EPS && dot(p1-p2,p4-p2)<-EPS){return false;}
        return intersectSL(p1,p2,p3,p4) && intersectSL(p3,p4,p1,p2);
    }
    
    P crosspointLL(P p1,P p2,P vec){
        if(abs(cross(p2-p1,vec))<EPS){return vec;}
        return vec*cross(p2-p1,p2)/cross(p2-p1,vec);
    }
    
    P crosspointLL(P p1,P p2,P p3,P p4){
        return p4+crosspointLL(p1-p4,p2-p4,p3-p4);
    }
    
    bool intersectShL(P p1,P p2,P vec){
        vec/=abs(vec);
        return intersectSL(p1,p2,vec) &&
        crosspointLL(p1/vec,p2/vec,vec/vec).real()>-EPS;
    }
    
    bool intersectShL(P p1,P p2,P p3,P p4){
        return intersectShL(p1-p3,p2-p3,p4-p3);
    }
    
    D distLP(P vec,P x){return abs((x/vec).imag())*abs(vec);}
    
    D distLP(P p1,P p2,P x){return distLP(p2-p1,x-p1);}
    
    D distSP(P p1,P p2,P x){
        if(dot(p2-p1,x-p1)<-EPS){return abs(x-p1);}
        if(dot(p1-p2,x-p2)<-EPS){return abs(x-p2);}
        return distLP(p1,p2,x);
    }
    
    //1::in,0::on edge,-1::out
    int contain(const vector<P> &poly,const P &p){
        vector<P> A={{65537,96847},{-24061,6701},{56369,-86509},{-93763,-78049},{56957,10007}};
        int s=A.size();
        vector<bool> cnt(s,false);
        for(int i=0;i<(int)poly.size();i++){
            int k=(i+1)%poly.size();
            if(distSP(poly[i],poly[k],p)<EPS){return 0;}
            for(int j=0;j<s;j++){
                if(intersectShL(poly[i],poly[k],p,p+A[j])){cnt[j]=!cnt[j];}
            }
        }
        int in=0;
        for(int j=0;j<s;j++){if(cnt[j]){in++;}}
        return in>s/2?1:-1;
    }
    
    vector<P> convexhull(vector<P> pts){
        vector<P> ret;
        sort(pts.begin(),pts.end(),comp);
        auto fnc=[&](){
            for(auto &I:pts){
                if(!ret.empty() && I==ret.back()){continue;}
                while(ret.size()>=2 && cross(ret.back()-ret[ret.size()-2],I-ret.back())<-EPS){
                    ret.pop_back();
                }
                ret.push_back(I);
            }
        };
        fnc();
        reverse(pts.begin(),pts.end());
        fnc();
        if(ret[0]==ret.back()){ret.pop_back();}
        return ret;
    }
    
    istream & operator >> (istream &i,P &p){D x,y; i>>x>>y; p={x,y}; return i;}
};

using namespace Geometry;



D cul(const vector<int> &poly,const vector<P> &A){
    D ret=0;
    int N=(int)poly.size();
    for(int i=1;i<=N;i++){ret+=abs(A[poly[i-1]]-A[poly[i%N]]);}
    return ret;
}


bool OK(const vector<int> &poly,const vector<P> &A){
    int N=A.size(),M=poly.size();
    vector<P> B(M);
    for(int i=0;i<M;i++){B[i]=A[poly[i]];}
    for(int i=1;i<=M;i++){
        for(int j=i+2;j<=M;j++){
            if(i==1 && j==M){continue;}
            if(intersectSS(B[i-1],B[i%M],B[j-1],B[j%M])){return false;}
        }
    }
    for(int i=0;i<N;i++){if(contain(B,A[i])==-1){return false;}}
    return true;
}


bool solve(){
    int n,k;
    cin>>n>>k;
    if(n==0){return false;}
    vector<P> A(n);
    cin>>A;
    typedef vector<int> poly;
    set<poly> used;
    priority_queue<pair<D,poly>,vector<pair<D,poly>>,greater<pair<D,poly>>> Q;
    vector<pair<D,poly>> ans;
    auto cvx=convexhull(A);
    vector<int> pl(cvx.size(),-1);
    for(int i=0;i<cvx.size();i++){
        for(int j=0;j<n;j++){
            if(cvx[i]==A[j]){pl[i]=j;}
        }
    }
    //cout<<pl<<endl;
    //cout<<OK(pl,A)<<endl;
    Q.push({cul(pl,A),pl});
    used.insert(Q.top().S);
    while(!Q.empty() && ans.size()<k){
        ans.push_back(Q.top()); Q.pop();
        pl=ans.back().S;
        set<int> in_poly;
        for(auto &I:pl){in_poly.insert(I);}
        for(int i=0;i<n;i++){
            if(!in_poly.count(i)){
                for(int j=1;j<=pl.size();j++){
                    vector<int> N(pl.size()+1);
                    for(int k=0;k<=pl.size();k++){
                        if(k<j){N[k]=pl[k];}
                        else if(k==j){N[k]=i;}
                        else{N[k]=pl[k-1];}
                    }
                    if(!used.count(N) && OK(N,A)){Q.push({cul(N,A),N}); used.insert(N);}
                }
            }
        }
    }
    if(ans.size()<k){cout<<-1<<endl;}
    else{cout<<fixed<<setprecision(12)<<ans.back().F<<endl;}
    //for(auto &I:ans){cout<<I<<endl;}
    
    return true;
}


int main(){
    while(solve());
    
    return 0;
}



Measured memory_bytes: 3584