#include <algorithm>
#include <iostream>
#include <random>
#include <vector>

using namespace std;

struct Point {
    double x;
    double y;
};

double dist(Point p1, Point p2) {
    return sqrt((p1.x - p2.x) * (p1.x - p2.x) +
                (p1.y - p2.y) * (p1.y - p2.y));
}

struct Position {
    int index = 0;
    double offset = 0.0;
};

double find_min_dist(Point p1, Point p2, Point p3, Point p4) {
    double start_x = p3.x - p1.x;
    double end_x = p4.x - p2.x;
    double start_y = p3.y - p1.y;
    double end_y = p4.y - p2.y;

    auto calc = [&](double time) {
        double x = start_x + (end_x - start_x) * time;
        double y = start_y + (end_y - start_y) * time;
        return x * x + y * y;
    };

    double l = 0.0;
    double r = 1.0;
    for (int it = 0; it < 80; it++) {
        double m1 = l + (r - l) / 3.0;
        double m2 = r - (r - l) / 3.0;
        if (calc(m1) < calc(m2)) {
            r = m2;
        } else {
            l = m1;
        }
    }

    return sqrt(calc(l));
}

int main() {
    double shift;
    cin >> shift;
    int n;
    cin >> n;
    vector<Point> points(n);
    for (int i = 0; i < n; i++) {
        cin >> points[i].x >> points[i].y;
    }
    points.push_back(Point{
        1234, 4321});
    vector<double> lens;
    for (int i = 0; i + 1 < points.size(); i++) {
        lens.push_back(dist(points[i], points[i + 1]));
    }
    vector<Position> pos(2);
    auto go = [&](int index, double len) {
        while (len > 0) {
            double more_here = lens[pos[index].index] - pos[index].offset;
            if (more_here > len) {
                pos[index].offset += len;
                len = 0;
            } else {
                len -= more_here;
                pos[index].index += 1;
                pos[index].offset = 0.0;
            }
        }
    };
    auto more = [&](int index) {
        return lens[pos[index].index] - pos[index].offset;
    };
    auto conv_pos = [&](Position pos) {
        double dx = points[pos.index + 1].x - points[pos.index].x;
        double dy = points[pos.index + 1].y - points[pos.index].y;
        double coef = pos.offset / (lens[pos.index]);
        return Point{points[pos.index].x + dx * coef, points[pos.index].y + dy * coef};
    };
    go(0, shift);

    double min_dist = shift;

    while (pos[0].index < n - 1) {
        double len = min(more(0), more(1));

        Point p1 = conv_pos(pos[0]);
        Point p3 = conv_pos(pos[1]);

        go(0, len);
        go(1, len);

        Point p2 = conv_pos(pos[0]);
        Point p4 = conv_pos(pos[1]);

        min_dist = min(min_dist, find_min_dist(p1, p2, p3, p4));
    }
    cout.precision(10);
    cout << min_dist << '\n';
}