#include<vector>
#include<string>
#include<iostream>
#include<map>
#include<bitset>
#include<unordered_map>
#include<algorithm>
#include<cmath>
#include<float.h>
#include <iomanip> 
using namespace std;

#define LL long long int
#define pp pair<double,double>
#define x first
#define y second


double dist(pp a, pp b){
    return sqrt(pow(a.first-b.first,2)+pow(a.second-b.second,2));
}
pp uVec(pp a, pp b){
    double d = 1/dist(a,b);
    return {d*(b.x-a.x),d*(b.y-a.y)};
}

pp lerp(double p, double t, pp a, pp b){
    return {a.x+((p/t)*(b.x-a.x)),a.y+((p/t)*(b.y-a.y))};
}


int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    double s, n;
    cin >> s >> n;
    vector<pp> points;
    for(int i = 0; i <n;i++){ 
        double a ,b ;
        cin >> a >> b;
        points.push_back({a,b});
    }
    double t = s;
    int i = 0;
    pp ao;
    pp bo;
    int aep;
    int beo;
    while(t > 0 && i < n-1){
        double d = dist(points[i],points[i+1]);
        if(t>d){
            t-=d;
            bo = points[i+1];
        }
        else{

            bo = lerp(t,d,points[i],points[i+1]);
            t = 0;
        }
        i++;
        beo = i;
    }
    double ans;
    
    if(beo == n-1 && bo == points[i-1]){
        ans = dist(points[0],points[i]);

    }
    else{
        ans = DBL_MAX;
        ao = points[0];
        aep = 1;
        while(beo < n){
            double da = dist(ao,points[aep]);
            double db = dist(bo,points[beo]);
            double lim = min(da,db);

            pp ae = lerp(lim, da, ao, points[aep]);
            pp be = lerp(lim, db, bo, points[beo]);
            ans = min(ans, dist(ae,be));
            ans = min(ans, dist(ao,bo));
            pp uVecA = uVec(ao,ae);
            pp uVecB = uVec(bo,be);

            double yint = 2*(ae.x-be.x)*(uVecA.x-uVecB.x);
            yint += 2*(ae.y-be.y)*(uVecA.y-uVecB.y);

            double grad = 2*pow(uVecA.x-uVecB.x,2);
            grad += 2*pow(uVecA.y-uVecB.y,2);

            if(grad != 0){
                double ta = (yint)/grad;
                if(0 <= ta && ta <= lim){
                    ans = min(ans,dist(lerp(ta,lim,ao,ae),lerp(ta,lim,bo,be)));
                }
            }
            ao = ae;
            bo = be;

            if(lim == da){
                aep++;
            }
            if(lim == db){
                beo++;
            }

        }
    }
    cout <<std::setprecision(10) <<  ans;



}