#include <bits/stdc++.h>
#define double long double

using i64 = long long;
const int N = 2e6 + 10;
double s;
int n;

struct Point {
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y) {}
} ;

typedef Point Vector;

inline Vector operator + (Vector A, Vector B) {
    return Vector(A.x + B.x, A.y + B.y);
}

inline Vector operator - (Vector A, Vector B) {
    return Vector(A.x - B.x, A.y - B.y);
}

inline Vector operator * (Vector A, double p) {
    return Vector(A.x * p, A.y * p);
}

inline Vector operator / (Vector A, double p) {
    return Vector(A.x / p, A.y / p);
}

inline bool operator < (const Point &a, const Point &b) {
    return a.x == b.x ? a.y < b.y : a.x < b.x;
}

const double eps = 1e-8;

inline int sgn(double x) {
    if(fabs(x) < eps) return 0;
    if(x < 0) return -1;
    return 1;
}

inline int dcmp(double x, double y) {
    if(fabs(x - y) < eps) return 0;
    if(x > y) return 1;
    return -1;
}

inline bool operator == (const Point &a, const Point &b) {
    if(sgn(a.x - b.x) == 0 && sgn(a.y - b.y) == 0) return 1;
    return 0;
}

inline double Dot(Vector A, Vector B) { //点乘
    return A.x * B.x + A.y * B.y;
}

inline double Length(Vector A) { //模长
    return sqrt(Dot(A, A));
}

inline double Angle(Vector A, Vector B) { // 向量角
    return acos(Dot(A, B) / Length(A) / Length(B));
}

inline double Cross(Vector A, Vector B) {//叉积
    return A.x * B.y - A.y * B.x;
}

inline double Area2(Point A, Point B, Point C) {//有向平行四边形的面积
    return Cross(B - A, C - A);
}

inline Vector Rotate(Vector A, double rad) { //逆时针旋转rad弧度后的向量
    return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad));
}

inline Vector Normal(Vector A) { //向量A左转90度的单位法向量
    double L = Length(A);
    return Vector(-A.y / L, A.x / L);
}

inline bool ToLeftTest(Point a, Point b, Point c) { //判断bc是不是ab的左转向
    return Cross(b - a, c - b);
}

inline double ss(double s) {
    return s * s;
}

void solve() {
    std::cin >> s >> n;
    std::vector < Point > p(n);
    for(int i = 0; i < n; ++i) std::cin >> p[i].x >> p[i].y;
    Point A = p[0], B = p[0];
    int toA = 1, toB = 1;
    double sts = 0;
    while(1) {
        double len = Length(p[toB] - B);
        if(sts + len > s + eps) {
            Vector used = p[toB] - B;
            B = B + used * ((s - sts) / len);
            break;
        } else {
            sts += len;
            B = p[toB++];
        }
    }
    auto f = [&](Point A, Point B, Vector k0, Vector k1) -> double {
        A = A + k0;
        B = B + k1;
        return Length(B - A);
    } ;
    double ans = 1e18;
    while(toB < n) {
        double len1 = Length(p[toA] - A);
        double len2 = Length(p[toB] - B);
        // std::cerr << toA << ' ' << toB << '\n';
        // std::cerr << A.x << ' ' << A.y << '\n';
        // std::cerr << B.x << ' ' << B.y << '\n';
        // std::cerr << len1 << ' ' << len2 << '\n';
        Vector k1 = p[toA] - A;
        Vector k2 = p[toB] - B;
        if(dcmp(len1, len2) == 0) {
            double l = 0, r = len1;
            while(l + eps < r) {
                double x = (2 * l + r) / 3;
                double y = (2 * r + l) / 3;
                if(f(A, B, k1 * (x / len1), k2 * (x / len1)) < f(A, B, k1 * (y / len1), k2 * (y / len1))) r = y;
                else l = x;
            }
            ans = std::min(ans, f(A, B, k1 * (l / len1), k2 * (l / len2)));
            A = p[toA++];
            B = p[toB++];
        } else if(dcmp(len1, len2) == 1) {
            double l = 0, r = len2;
            while(l + eps < r) {
                double x = (2 * l + r) / 3;
                double y = (2 * r + l) / 3;
                if(f(A, B, k1 * (x / len1), k2 * (x / len2)) < f(A, B, k1 * (y / len1), k2 * (y / len2))) r = y;
                else l = x;
            }
            ans = std::min(ans, f(A, B, k1 * (l / len1), k2 * (l / len2)));
            B = p[toB++];
            A = A + k1 * (len2 / len1);
        } else {
            double l = 0, r = len1;
            while(l + eps < r) {
                double x = (2 * l + r) / 3;
                double y = (2 * r + l) / 3;
                if(f(A, B, k1 * (x / len1), k2 * (x / len2)) < f(A, B, k1 * (y / len1), k2 * (y / len2))) r = y;
                else l = x;
            }
            ans = std::min(ans, f(A, B, k1 * (l / len1), k2 * (l / len2)));
            A = p[toA++];
            B = B + k2 * (len1 / len2);
        }
    }
    std::cout << ans << '\n';
}

int main() {
    std::cin.tie(nullptr) -> sync_with_stdio(false);
    std::cout << std::fixed << std::setprecision(6);
    int T = 1;
    // std::cin >> T;
    while(T--) solve();
    return 0;
}///asdasd