#include <bits/stdc++.h>

//mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
//uniform_int_distribution<int>(1, 2000000)(rng);

using namespace std;

using ll = long long;

template <class T>
T smax(T & x, T y) {
    if (x < y) {
        x = y;
        return true;
    }
    return false;
}

template <class T>
T smin(T & x, T y) {
    if (x > y) {
        x = y;
        return true;
    }
    return false;
}

template <class T>
struct SegmentTree {
    int pow;
    T neutral;
    vector<T> seg;

    SegmentTree(vector<T> a, T n) {
        neutral = n;
        pow = 1;
        while (pow < (int)a.size()) {
            pow *= 2;
        }
        seg.resize(2 * pow);
        for (int i = 0; i < (int) a.size(); ++i) {
            seg[pow + i] = a[i];
        }
        for (int i = a.size(); i < pow; ++i) {
            seg[pow + i] = neutral;
        }
        for (int i = pow - 1; i > 0; --i) {
            seg[i] = f(seg[2 * i], seg[2 * i + 1]);
        }
    }

    T get(int l, int r) {
        return get(1, 0, pow, l, r);
    }

    T get(int v, int tl, int tr, int l, int r) {
//        cout << v << " " << tl << " " << tr << " " << l << " " << r << "\n";
        if (l >= tr || r <= tl) {
            return neutral;
        }
        if (l <= tl && tr <= r) {
//            cout << seg[v].first << " " << seg[v].second << "\n";
            return seg[v];
        }
        int tm = (tl + tr) / 2;
        return f(get(2 * v, tl, tm, l, r), get(2 * v + 1, tm, tr, l, r));
    }

    T f(T a, T b) {
        return max(a, b);
    }
};

const int POW = 31;

template<typename TI, typename TF>
class generic_point {
public:
    TI x, y;

    generic_point() = default;

    generic_point(TI _x, TI _y) : x(_x), y(_y) {}

    generic_point<TI, TF> operator+() const {
        return *this;
    }

    generic_point<TI, TF> operator-() const {
        return generic_point<TI, TF>(-x, -y);
    }

    generic_point<TI, TF> operator+(const generic_point<TI, TF>& other) const {
        return generic_point<TI, TF>(x + other.x, y + other.y);
    }

    generic_point<TI, TF> operator-(const generic_point<TI, TF>& other) const {
        return generic_point<TI, TF>(x - other.x, y - other.y);
    }

    generic_point<TI, TF> operator*(TI k) const {
        return generic_point<TI, TF>(x * k, y * k);
    }

    generic_point<TI, TF>& operator+=(const generic_point<TI, TF>& other) {
        *this = (*this) + other;
        return *this;
    }

    generic_point<TI, TF>& operator-=(const generic_point<TI, TF>& other) {
        *this = (*this) - other;
        return *this;
    }

    generic_point<TI, TF>& operator*=(TI k) {
        *this = (*this) * k;
        return *this;
    }

    bool operator==(const generic_point<TI, TF>& other) const {
        return x == other.x && y == other.y;
    }

    bool operator!=(const generic_point<TI, TF>& other) const {
        return x != other.x || y != other.y;
    }

    template<typename T = TI>
    typename std::enable_if<std::is_floating_point<T>::value, generic_point<TI, TF>>::type
    operator/(TI k) const {
        return generic_point<TI, TF>(x / k, y / k);
    }

    template<typename T = TI>
    typename std::enable_if<std::is_floating_point<T>::value, generic_point<TI, TF>&>::type
    operator/=(TI k) {
        *this = (*this) / k;
        return *this;
    }

    TI operator*(const generic_point<TI, TF>& other) const {
        return x * other.x + y * other.y;
    }

    TI operator%(const generic_point<TI, TF>& other) const {
        return x * other.y - y * other.x;
    }

    TI lenSqr() const {
        return x * x + y * y;
    }

    TF len() const {
        return sqrt(lenSqr());
    }

    TI distSqr(const generic_point<TI, TF>& other) const {
        return (other - *this).lenSqr();
    }

    TF dist(const generic_point<TI, TF>& other) const {
        return sqrt(distSqr(other));
    }

    generic_point<TI, TF> norm() const {
        return *this / len();
    }

    // Counterclockwise rotation by 90 degrees
    generic_point<TI, TF> ort() const {
        return generic_point<TI, TF>(-y, x);
    }

    // Counterclockwise rotation by c = cos(alpha), s = sin(alpha)
    template<typename T = TI>
    typename std::enable_if<std::is_floating_point<T>::value, generic_point<TI, TF>>::type
    rot(TF c, TF s) const {
        return *this * c + ort() * s;
    }

    // Counterclockwise rotation by alpha
    generic_point<TI, TF> rot(TF alpha) const {
        return rot(cos(alpha), sin(alpha));
    }

    TF arg() const {
        return atan2(y, x);
    }

    int quad() const {
        if (x >= 0 && y >= 0) {
            return 1;
        } else if (x < 0 && y >= 0) {
            return 2;
        } else if (x < 0 && y < 0) {
            return 3;
        } else if (x >= 0 && y < 0) {
            return 4;
        }
        throw;
    }

    template<typename T = TI>
    typename std::enable_if<std::is_floating_point<T>::value>::type
    scan() {
        double _x, _y;
        scanf("%lf%lf", &_x, &_y);
        x = _x;
        y = _y;
    }

    template<typename T = TI>
    typename std::enable_if<std::is_integral<T>::value>::type
    scan() {
        ll _x, _y;
        scanf("%lld%lld", &_x, &_y);
        x = _x;
        y = _y;
    }

    template<typename T = TI>
    typename std::enable_if<std::is_floating_point<T>::value>::type
    print() {
        printf("%.10lf %.10lf\n", (double)x, (double)y);
    }

    template<typename T = TI>
    typename std::enable_if<std::is_integral<T>::value>::type
    print() {
        printf("%lld %lld\n", (ll)x, (ll)y);
    }
};
using point = generic_point<double, double>;

double EPS = 1e-9;

int N = 1000000;
vector<point> line(N);

point onSeg(int i, double len) {
    point v = line[i + 1] - line[i];
    return line[i] + v * (len / v.len());
}

void solve() {
    double s;
    cin >> s;
    int n;
    cin >> n;
    for (int i = 0; i < n; ++i) {
        double x, y;
        cin >> x >> y;
        line[i].x = x;
        line[i].y = y;
    }
    vector<double> len(n - 1);
    for (int i = 0; i < n - 1; ++i) {
        len[i] = (line[i + 1] - line[i]).len();
    }
    int cur = 0;
    while (len[cur] < s - EPS) {
        s -= len[cur++];
    }
    int i = 0;
    double x = 0;
    int j = cur;
    double y = s;
    double ans = (onSeg(j, y) - onSeg(i, x)).len();
    while (j < n - 1) {
        double d = min(len[i] - x, len[j] - y);
        point r = onSeg(j, y) - onSeg(i, x);
        point v1 = line[i + 1] - line[i];
        v1 /= v1.len();
        point v2 = line[j + 1] - line[j];
        v2 /= v2.len();
        point v = v2 - v1;
        if (v.len() > EPS) {
            v /= v.len();
            if (r * v < -EPS) {
                if (- r * v < d) {
                    smin(ans, abs(r % v));
                }
            }
        }
        if (len[i] - x < len[j] - y) {
            y += len[i] - x;
            i++;
            x = 0;
        } else {
            x += len[j] - y;
            j++;
            y = 0;
        }
        smin(ans, (onSeg(j, y) - onSeg(i, x)).len());
    }
    cout << ans << "\n";
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
//    cin >> t;
    cout << fixed << setprecision(10);
    while (t--) {
        solve();
    }
    return 0;
}