#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define X first
#define Y second
#define ALL(v) v.begin(), v.end()
#define pb push_back
#define SZ(a) ((int)a.size())

#define double long double

typedef pair<double, double> pdd;
const double eps = 1e-10;

pll operator-(const pll &a, const pll &b) { return pll(a.X - b.X, a.Y - b.Y); }
pll operator+(const pll &a, const pll &b) { return pll(a.X + b.X, a.Y + b.Y); }
pdd operator-(const pdd &a, const pdd &b) { return pdd(a.X - b.X, a.Y - b.Y); }
pdd operator*(const pdd &a, const double &b) { return pdd(a.X * b, a.Y * b); }
pdd operator/(const pdd &a, const double &b) { return pdd(a.X / b, a.Y / b); }
template<class T>
T cross(const pair<T, T> &a, const pair<T, T> &b) { return a.X * b.Y - a.Y * b.X; }
template<class T>
T dot(const pair<T, T> &a, const pair<T, T> &b) { return a.X * b.X + a.Y * b.Y; }
template<class T>
T abs2(const pair<T, T> &a) { return dot(a, a); }
int sign(const ll &a) { return a == 0 ? 0 : a > 0 ? 1 : -1; }
int sign(const double &a) { return fabs(a) < eps ? 0 : a > 0 ? 1 : -1; }
template<class T>
int ori(const T &a, const T &b, const T &c) { return sign(cross(b - a, c - a)); }

bool line_seg_intersect(pdd p1, pdd p2, pdd p3, pdd p4) { // the four points should not colinear
    int a123 = ori(p1, p2, p3);
    int a124 = ori(p1, p2, p4);
    if (a123 == 0 && a124 == 0) return false;
    return a123 * a124 <= 0;
}

pdd intersect(pdd p1, pdd p2, pdd p3, pdd p4) {
    double a123 = cross(p2 - p1, p3 - p1);
    double a124 = cross(p2 - p1, p4 - p1);
    return (p4 * a123 - p3 * a124) / (a123 - a124);
}

void hull(vector<pdd> &dots) {
    sort(ALL(dots)), dots.resize(unique(ALL(dots)) - dots.begin());
    vector<pdd> ans(1, dots[0]);
    for (int ct = 0; ct < 2; ++ct, reverse(ALL(dots)))
        for (int i = 1, t = SZ(ans); i < SZ(dots); ans.pb(dots[i++]))
            while (SZ(ans) > t && ori(ans[SZ(ans) - 2], ans.back(), dots[i]) <= 0)
                ans.pop_back();
    if (SZ(ans) > 1)
        ans.pop_back();
    ans.swap(dots);
}

bool cmp(pll a, pll b) {
#define is_neg(k) (sign(k.Y) < 0 || (sign(k.Y) == 0 && sign(k.X) < 0))
    int A = is_neg(a);
    int B = is_neg(b);
    if (A != B) return A < B;
    if (sign(cross(a, b)) == 0)
        return abs2(a) < abs2(b);
    return sign(cross(a, b)) > 0;
}

pll arr[3005];

int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < m; ++i)
        cin >> arr[i].X >> arr[i].Y;

    vector<pdd> square;
    square.pb(pdd(0, 0));
    square.pb(pdd(n, 0));
    square.pb(pdd(n, n));
    square.pb(pdd(0, n));
    
    auto area = [&](pdd a, pdd b) {
        vector<pdd> points;
        for (int i = 0; i < SZ(square); ++i) {
            if (ori(a, b, square[i]) >= 0)
                points.pb(square[i]);
            if (line_seg_intersect(a, b, square[i], square[(i + 1) % SZ(square)]))
                points.pb(intersect(a, b, square[i], square[(i + 1) % SZ(square)]));
        }
        hull(points);
        double res = 0;
        for (int i = 0; i < SZ(points); ++i)
            res += cross(points[i], points[(i + 1) % SZ(points)]);
        return res;
    };

    double ans = 0;

    auto chmax = [&](int cnt, double a) {
        double val = (double)cnt / m - a / n / n;
        //cerr << "get val " << cnt << ", " << a << " = " << val << "\n"; 
        ans = max(ans, val);
    };

    for (int i = 0; i < m; ++i) {
        // solve one
        chmax(1, 2 * min(arr[i].X, n - arr[i].X) * min(arr[i].Y, n - arr[i].Y));
    }

    for (int base = 0; base < m; ++base) {
        vector<pll> vec;
        for (int i = 0; i < m; ++i)
            if (i != base)
                vec.pb(arr[i] - arr[base]);
        sort(ALL(vec), cmp);
        //for (auto [x, y] : vec)
            //cerr << "(" << x << ", " << y << ") ";
        //cerr << endl;
        for (int i = 0, j = 0; i < SZ(vec); ++i) {
            if (i == j) j = (j + 1) % SZ(vec);
            while (i != j && (cross(vec[i], vec[j]) > 0 || (cross(vec[i], vec[j]) == 0 && (dot(vec[i], vec[j]) < 0 || abs2(vec[i]) < abs2(vec[j]))))) j = (j + 1) % SZ(vec);
            int cnt = (j + SZ(vec) - i) % SZ(vec) + 1;
            if (i == j) cnt = SZ(vec) + 1;
            double a = area(arr[base], arr[base] + vec[i]) / 2;
            //cerr << "(" << arr[base].X << ", " << arr[base].Y << ") -> (" << (arr[base] + vec[i]).X << ", " << (arr[base] + vec[i]).Y << "): " << cnt << " " << a << "\n";
            chmax(cnt, a);
        }
    }

    cout << fixed << setprecision(15) << ans << "\n";
}