#include <bits/stdc++.h>
using namespace std;
#define all(x) x.begin(), x.end()
#define int long long
#define pb push_back
void dbg_out() { cerr << endl; }
template<typename H, typename... T>
void dbg_out(H h, T... t) { cerr << ' ' << h; dbg_out(t...); }
#define dbg(...) {cerr << #__VA_ARGS__ << ':'; dbg_out(__VA_ARGS__); }

constexpr double EPS = 1e-9;

bool zero(double x){
	return abs(x) <= EPS;
}

using db = long double;

struct point{
	double x,y;

	point(): x(0), y(0) {}
	point(db _x, db _y): x(_x), y(_y) {}

	point operator+(point rhs){ return point(x+rhs.x,y+rhs.y); }
	point operator-(point rhs){ return point(x-rhs.x,y-rhs.y); }
	point operator*(db k){ return point(x*k, y*k); }
	point operator/(db k){ return point(x/k, y/k); }
	db operator*(point rhs){ return x*rhs.x + y*rhs.y; }
	db operator^(point rhs){ return x*rhs.y - y*rhs.x; }

	db norm2() { return *this * *this; }
	db norm(){ return sqrt(norm2()); }

	bool operator==(const point &rhs) const{
		return zero(x-rhs.x) && zero(y-rhs.y);
	}
};

db dist2(point p, point q){
	return (p-q)*(p-q);
}

db dist(point p, point q){
	return sqrt(dist2(p,q));
}

double area2(point a, point b, point c){
	return (b-a)^(c-a);
}

bool left(point a, point b, point c){
	return area2(a,b,c) > EPS;
}

bool right(point a, point b, point c){
	return area2(a,b,c) < -EPS;
}	

bool collinear(point a, point b, point c){
	return zero(area2(a,b,c));
}

int parallel(point a, point b){
	a = a/a.norm();
	b = b/b.norm();
	if(!collinear(point(), a,b)) return 0;
	return zero(a.x-b.x) && zero(a.y-b.y) ? 1 : -1;
}

struct segment{
	point a,b;
	segment(){}

	segment(point _a, point _b): a(_a), b(_b) {}
	point vec(){ return b-a;}
	bool contains(point p){
		return a == p || b == p || parallel(a-p,b-p) == -1;
	}

	point proj(point p){
		p = p-a;
		point v = vec();
		return a + v*((p*v)/(v*v));
	}
	
};

db dist(segment s, point p){
	point pr = s.proj(p);
	if(s.contains(pr)){
		return dist(p,pr);
	}
	return min(dist(p,s.a),dist(p,s.b));
}

db dist(segment s1, segment s2){
	point dir1 = s1.b-s1.a;
	point dir2 = s2.b-s2.a;
	point dirf = dir2-dir1;
	if(zero(dirf.x) && zero(dirf.y)){
		return dist(s2.a,s1.a);
	}
	point s3b = s2.a+dirf;
	segment s3(s2.a, s3b);
	return dist(s3,s1.a);
}

db norm(point p){
	return p.norm();
}

void solve(){
	db len;
	cin >> len;
	int n;
	cin >> n;
	vector<point> p(n);
	for(int i = 0; i < n; i++){
		cin >> p[i].x >> p[i].y;
	}
	vector<db> ini(n);
	for(int i = 1; i < n; i++){
		ini[i] = ini[i-1] + dist(p[i],p[i-1]);
	}
	db ans = 1e9;
	for(int i = 0; i < n-1; i++){
		int l = 0;
		int r = n-1;
		while(l < r){
			int m =(l+r+1)/2;
			if(ini[i]+len >= ini[m] || zero(ini[i]+len-ini[m])){
				l = m;
			}else{
				r = m-1;
			}
		}
		if(r == n-1){
			if( abs( (ini[i]+len) - ini[r]) <= EPS){
				db dis = dist(p[i],p[r]);
				ans = min(ans, dis);
			}
			continue;
		}
		point dir = p[r+1]-p[r];
		db dif = ini[i]+len-ini[r];
		dir = dir/norm(dir);
		dir = dir*dif;
		point a = p[r]+dir;
		point b = p[r+1];
		
		point c = p[i];
		point dir2 = p[i+1]-p[i];
		dir2 = dir2/norm(dir2);
		dir2 = dir2*dist(a,b);
		point d = p[i]+dir2;
		
		segment s1(a,b);
		segment s2(c,d);
		db dis = dist(s1,s2);
		ans = min(ans, dis);
	}
	for(int i = 0; i < n-1; i++){
		if(ini[i] < len) continue;
		int l = 0, r = n-1;
		while(l <r){
			int m = (l+r+1)/2;
			if(ini[i] >= ini[m]+len){
				l = m;
			}else{
				r = m-1;
			}
		}
		point dir = p[r+1]-p[r];
		db dif = ini[i]-ini[r]-len;
		dir = dir/norm(dir);
		dir = dir*dif;
		point a = p[r]+dir;
		point b = p[r+1];

		point c = p[i];
		point dir2 = p[i+1]-p[i];
		dir2 = dir2/norm(dir2);
		dir2 = dir2*dist(a,b);
		point d = p[i]+dir2;

		segment s1(a,b);
		segment s2(c,d);
		db dis = dist(s1,s2);
		ans = min(ans, dis);
	}
	cout << fixed << setprecision(10) <<ans <<  '\n';
}

signed main(){
	ios::sync_with_stdio(false); cin.tie(0);
	solve();
}