#include <bits/stdc++.h>
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pdd pair<double, double>
#define F first
#define S second
#define all(x) x.begin(), x.end()
using namespace std;


pll operator+(pll a, pll b)
{
    return pll(a.F + b.F, a.S + b.S);
}
pll operator-(pll a)
{
    return pll(-a.F, -a.S);
}
pll operator-(pll a, pll b)
{
    return pll(a.F - b.F, a.S - b.S);
}
pll operator*(pll a, double b)
{
    return pdd(a.F * b, a.S * b);
}
pdd operator/(pll a, double b)
{
    return pdd(a.F / b, a.S / b);
}
ll dot(pll a, pll b)
{
    return a.F * b.F + a.S + b.S;
}
ll cross(pll a, pll b)
{
    return a.F * b.S - a.S * b.F;
}
int sign(ll a)
{
    return a == 0 ? 0 : (a < 0 ? -1 : 1);
}
int ori(pll a, pll b, pll c)
{
    return sign(cross(b - a, c - a));
}
bool collinear(pll a, pll b, pll c)
{
    return ori(a, b, c) == 0;
}
bool btw(pll a, pll b, pll c)
{
    return collinear(a, b, c) && sign(dot(a - c, b - c)) <= 0;
}
bool is_intersect(pll p1, pll p2, pll p3, pll p4)
{
    int a123 = ori(p1, p2, p3);
    int a124 = ori(p1, p2, p4);
    return a123 * a124 <= 0;
}
pdd intersect(pll p1, pll p2, pll p3, pll p4)
{
    ll a123 = cross(p2 - p1, p3 - p1);
    ll a124 = cross(p2 - p1, p4 - p1);
    return (p4 * a123 - p3 * a124) / (a123 - a124);
}

#define is_neg(k) (sign(k.S) < 0 || (sign(k.S) == 0 && sign(k.F) < 0))

int cmp(pll a, pll b)
{
    int A = is_neg(a), B = is_neg(b);
    if (A != B)
        return A < B;
    if (sign(cross(a, b)) == 0)
        return -1;
    return sign(cross(a, b)) > 0;
}

int n, m;
pll p[3005];

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    cin >> n >> m;
    for (int i = 1; i <= m; i++)
        cin >> p[i].F >> p[i].S;
    
    double ans = 0;
    
    if (m == 1)
    {
        p[1].F = min(p[1].F, n - p[1].F);
        p[1].S = min(p[1].S, n - p[1].S);
        ans = 1 - 2.0 * p[1].F * p[1].S / n / n;
        cout << fixed << setprecision(10) << ans << '\n';
        return 0;
    }



    
    vector<pll> sq = {{0, 0}, {n, 0}, {n, n}, {0, n}}, sq3;
    for (int t = 1; t <= 3; t++)
        for (auto P : sq)
            sq3.emplace_back(P);
    
    for (int i = 1; i <= m; i++)
    {
        pll O = p[i];
        vector<pair<pll, int>> v;
        int in = 1;
        for (int j = 1; j <= m; j++)
            if (j != i)
            {
                pll vec = p[j] - O;
                if (is_neg(vec))
                    in++;
                v.emplace_back(vec, +1);
                v.emplace_back(-vec, -1);
            }
        sort(all(v), [&](pair<pll, int> a, pair<pll, int> b)
        {
            if (cmp(a.F, b.F) == -1)
                return a.S > b.S;
            return (bool)cmp(a.F, b.F);
        });
        for (auto [P, t] : v)
            if (t == -1)
                in--;
            else 
            {
                in++;
                pll A = O + P, B = O;
                for (int j = 4; j < 8; j++)
                    if (ori(A, B, sq3[j]) > 0)
                    {
                        deque<pdd> poly = {sq3[j]};
                        for (int k = j - 1;; k--)
                            if (is_intersect(A, B, sq3[k], sq3[k + 1]))
                            {
                                poly.emplace_front(intersect(A, B, sq3[k], sq3[k + 1]));
                                break;
                            }
                            else 
                                poly.emplace_front(pdd(sq3[k]));
                        for (int k = j + 1;; k++)
                            if (is_intersect(A, B, sq3[k], sq3[k - 1]))
                            {
                                poly.emplace_back(intersect(A, B, sq3[k], sq3[k - 1]));
                                break;
                            }
                            else 
                                poly.emplace_back(sq3[k]);
                        double area = 0;
                        int k = (int)poly.size();
                        for (int l = 0; l < k; l++)
                        {
                            auto [x1, y1] = poly[l];
                            auto [x2, y2] = poly[(l + 1) % k];
                            area += .5 * (x1 * y2 - x2 * y1);
                        }
                        ans = max(ans, double(in) / m - area / n / n);
                        break;
                    }
            }
    }

    cout << fixed << setprecision(10) << ans << '\n';
}