#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 b)
{
    return pll(- b.F, - b.S);
}
pll operator-(pll a, pll b)
{
    return pll(a.F - b.F, a.S - b.S);
}
pdd operator*(pll a, double b)
{
    return pdd(double(a.F) * b, double(a.S) * b);
}
pdd operator/(pdd 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;
}
ll abs2(pll a)
{
    return dot(a, a);
}
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 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 intersection(pll p1, pll p2, pll p3, pll p4)
{
    double a123 = cross(p2 - p1, p3 - p1);
    double a124 = cross(p2 - p1, p4 - p1);
    return (p4 * a123 - p3 * a124) / (a123 - a124);
}
#define down(p) (sign(p.S) < 0 || (sign(p.F) < 0 && sign(p.S) == 0))

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


int n, d;
pll p[3005];

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    cin >> d >> n;

    vector<pll> rsq = {{0, 0}, {d, 0}, {d, d}, {0, d}};
    vector<pll> sq;
    sq.insert(sq.begin(), rsq.begin(), rsq.end());
    sq.insert(sq.begin(), rsq.begin(), rsq.end());
    sq.insert(sq.begin(), rsq.begin(), rsq.end());

    auto cut_area = [&](pll A, pll B)
    {
        int i = 4;
        for (; i < 8; i++)
            if (ori(A, B, sq[i]) > 0)
                break;
        if (i == 8) return 1e9;
        deque<pdd> poly = {pdd(sq[i])};
        for (int j = i - 1;; j--)
            if (intersect(A, B, sq[j], sq[j + 1]))
            {    
                poly.emplace_front(intersection(A, B, sq[j], sq[j + 1]));
                break;
            }
            else poly.emplace_front(sq[j]);
        for (int j = i + 1;; j++)
            if (intersect(A, B, sq[j], sq[j - 1]))
            {    
                poly.emplace_back(intersection(A, B, sq[j], sq[j - 1]));
                break;
            }
            else poly.emplace_back(sq[j]);
        int k = (int)poly.size();
        double area = 0;
        for (int j = 0; j < k; j++)
        {
            auto [x1, y1] = poly[j];
            auto [x2, y2] = poly[(j + 1) % k];
            area += .5 * (x1 * y2 - x2 * y1);
        }
        return area;
    };
    auto brute_in = [&](pll A, pll B)
    {
        int cnt = 0;
        for (int i = 1; i <= n; i++)
            cnt += (ori(A, B, p[i]) >= 0);
        return cnt;
    };

    double ans = 0;
    auto attempt = [&](pll A, pll B, int in)
    {
        if (in == -1)
            in = brute_in(A, B);
        double area = cut_area(A, B);
        ans = max(ans, double(in) / n - area / d / d);
    };
    
    for (int i = 1; i <= n; i++)
        cin >> p[i].F >> p[i].S;
    for (int t = 1; t <= 4; t++)
    {
        for (int i = 1; i <= n; i++)
            attempt(pll(2 * p[i].F, 0), pll(0, 2 * p[i].S), -1),
            attempt(pll(0, 0), p[i], -1),
            attempt(p[i], pll(0, 0), -1);
            
        for (int i = 1; i <= n; i++)
            p[i] = pll(d - p[i].S, p[i].F);
    }
    for (int i = 1; i <= n; i++)
    {
        pll O = p[i];
        vector<pair<pll, int>> ev;
        int in = 1;
        for (int j = 1; j <= n; j++)
            if (i != j)
            {
                pll P = p[j] - O;
                if (!down(P))
                    in++;
                ev.emplace_back(P, 0);
                ev.emplace_back(-P, 1);
            }
        sort(all(ev), [&](pair<pll, int> p, pair<pll, int> q){
            int c = acmp(p.F, q.F);
            if (c == -1)
                return p.S > q.S;
            else return (bool)c;
        });
        for (auto [P, t] : ev)
            if (t == 1)
                in++;
            else 
            {
                attempt(O, O + P, in);
                in--;
            }
    }
    cout << fixed << setprecision(10) << ans << '\n';
}