#include "bits/stdc++.h"
#define rep(i, a, n) for (auto i = a; i <= (n); ++i)
#define revrep(i, a, n) for (auto i = n; i >= (a); --i)
#define all(a) a.begin(), a.end()
#define sz(a) (int)(a).size()
template<class T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, T b) { if (b < a) { a = b; return 1; } return 0; }
using namespace std;

template<class A, class B> string to_string(pair<A, B> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string) s); }
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(bool x) { return x ? "true" : "false"; }
template<class A> string to_string(A v) {
	bool first = 1;
	string res = "{";
	for (const auto &x: v) {
		if (!first) res += ", ";
		first = 0;
		res += to_string(x);
	}
	res += "}";
	return res;
}
template<class A, class B> string to_string(pair<A, B> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }

void debug_out() { cerr << endl; }
template<class Head, class... Tail> void debug_out(Head H, Tail... T) {
	cerr << " " << to_string(H);
	debug_out(T...);
}
#ifndef ONLINE_JUDGE
	#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
	#define debug(...) if(0) puts("No effect.")
#endif

using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;

/**
 * Author: Yuhao Yao
 * Date: 22-08-26
 * Status:
 *  project_to_line (double) tested on https://acm.hdu.edu.cn/showproblem.php?pid=6419.
 *  dis_to_line (double) tested on https://acm.hdu.edu.cn/showproblem.php?pid=6419.
 *  dis_to_seg (double) tested on https://acm.hdu.edu.cn/showproblem.php?pid=6419.
 */
template<class T> struct Point {
	// use T = double or T = long long.
	using P = Point;
	using type = T;
	static constexpr T eps = 1e-9;
	static constexpr bool isInt = is_integral_v<T>;
	static int sgn(T x) { return (x > eps) - (x < -eps); }
	static int cmp(T x, T y) { return sgn(x - y); }

	T x, y;

	P operator +(P a) const { return P{x + a.x, y + a.y}; }
	P operator -(P a) const { return P{x - a.x, y - a.y}; }
	P operator *(T a) const { return P{x * a, y * a}; }
	P operator /(T a) const { return P{x / a, y / a}; }
	bool operator ==(P a) const { return cmp(x, a.x) == 0 && cmp(y, a.y) == 0; }
	bool operator <(P a) const { return cmp(x, a.x) == 0 ? cmp(y, a.y) < 0: x < a.x; }

	T len2() const { return x * x + y * y; }
	T len() const { return sqrt(x * x + y * y); }
	P unit() const {
		if (isInt) return *this; // for long long
		else return len() <= eps ? P{} : *this / len(); // for double / long double;
	}

	// dot and cross may lead to big relative error for imprecise point when the result is relatively smaller than the input magnitude.
	T dot(P b) const { return x * b.x + y * b.y; }
	T cross(P b) const { return x * b.y - y * b.x; }

	bool is_upper() const { return y > eps || (sgn(y) == 0 && x < -eps); }
	
	// if a has smaller pollar, then return 1; o.w. return 0.
	static bool argcmp(P a, P b) {
		if (a.is_upper() != b.is_upper()) return a.is_upper() < b.is_upper();
		return a.unit().cross(b.unit()) > eps;
		// Taking unit makes it slower but I believe it is also safer. You can drop .unit() when you think the precision is not an issue.
		// atan2 is much slower.
	}
	static bool sameDir(P a, P b) { return argcmp(a, b) == 0 && argcmp(b, a) == 0; }

	P rot90() const { return P{-y, x}; }
	P rot270() const { return P{y, -x}; }
	
	// Possible precision error: 
	// Absolute error is multiplied by the magnitude while the resulting coordinates can have 0 as magnitude!
	P rotate(T theta) const {
		P a{cos(theta), sin(theta)};
		return P{x * a.x - y * a.y, x * a.y + y * a.x};
	}

	// Returns the signed projected length onto line $ab$. Return 0 if $a = b$.
	T project_len(P a, P b) const { /// start-hash
		if (isInt) return (*this - a).dot(b - a);
		else if (a == b) return 0;
		else return (*this - a).dot(b - a) / (b - a).len();
	}
	
	// Returns the signed distance to line $ab$. Returns 0 if $a = b$.
	T dis_to_line(P a, P b) const { /// start-hash
		if (isInt) return (*this - a).cross(b - a);
		else if (a == b) return 0;
		else return (*this - a).cross(b - a) / (b - a).len();
	}  /// end-hash
	
	// Returns the distance to line segment $ab$. Safe when $a = b$.
	// Only for double / long double.
	T dis_to_seg(P a, P b) const { /// start-hash
		if (project_len(a, b) <= eps) return (*this - a).len();
		if (project_len(b, a) <= eps) return (*this - b).len();
		return fabs(dis_to_line(a, b));
	} /// end-hash

	// Calculate the projection to line $ab$. Return $a$ when $a = b$.
	// Only for double / long double.
	P project_to_line(P a, P b) const { /// start-hash
		return a + (b - a).unit() * project_len(a, b);
	} /// end-hash

	// Check if it is on segment ab. Safe when a == b.
	bool on_seg(P a, P b) const {  /// start-hash
		return dis_to_seg(a, b) <= eps; 
	}  /// end-hash

	// Check if it is on line ab. Need a != b, otherwise returns true.
	bool on_line(P a, P b) const {  /// start-hash
		return sgn(dis_to_line(a, b)) == 0;
	}  /// end-hash
	
	friend string to_string(P p) { return "(" + to_string(p.x) + ", " + to_string(p.y) + ")"; }
};

/**
 * Author: Yuhao Yao
 * Date: 22-08-19
 * Description: Compute the intersection of a non-self-intersecting Polygon $poly$ and a Half Plane $ab$ (i.e. the LHS of $ab$).
 *  The returned Polygon can be self intersecting, so it can only be used for area relating problem.
 *  Only works for double or long double.
 * Time: O(|poly|).
 * Status: (double) tested on https://codeforces.com/gym/101611/problem/J.
 */
template<class P>
vector<P> cutPoly(const vector<P> &poly, P a, P b) {
	vector<P> res;
	rep(i, 0, sz(poly) - 1) {
		P p = poly[i];
		P q = poly[(i + 1) % sz(poly)];
		int sgn1 = P::sgn(p.dis_to_line(a, b));
		int sgn2 = P::sgn(q.dis_to_line(a, b));

		if (sgn1 <= 0) res.push_back(p);
		if (sgn1 * sgn2 == -1) {
			auto s0 = (p - a).cross(b - a);
			auto s1 = (p - q).cross(b - a);
			res.push_back(p + (q - p) * s0 / s1);
		}
	}
	return res;
}

/**
 * Author: Yuhao Yao
 * Date: 22-08-19
 * Description: Compute the (signed) area of a simple Polygon $poly$. The result will be non-negative if $poly$ is in counter-clockwise order.
 * Time: O(|poly|).
 * Status: (double) tested on https://qoj.ac/problem/4226.
 */
template<class T>
T Area(const vector<Point<T>> &poly) {
	if (poly.empty()) return 0;
	T sum = 0;
	rep(i, 0, sz(poly) - 1) sum += (poly[i] - poly[0]).cross(poly[(i + 1) % sz(poly)] - poly[0]);
	return sum / 2;
}

int main() {
	ios::sync_with_stdio(0); cin.tie(0);

	using T = ll;
	using P = Point<T>;

	int w, n; cin >> w >> n;
	vector<P> as(n);
	for (auto &[x, y]: as) cin >> x >> y;

	using F = double;
	using PF = Point<F>;
	vector<PF> bor{{0, 0}, {w, 0}, {w, w}, {0, w}};

	F ans = 0;
	for (auto o: as) {
		vector<P> vec;
		for (auto p: as) if (! (p == o)) vec.push_back(p);
		sort(all(vec), [&](P a, P b) { return P::argcmp(a - o, b - o); });
		int tot = sz(vec), j = 0;
		rep(i, 0, tot - 1) {
			P a = vec[i];
			if (i && P::sameDir(a - o, vec[i - 1] - o)) continue;
			while (j < i + tot && vec[j % tot].dis_to_line(o, a) <= 0) {
				j++;
			}
			int cnt = j - i + 1;
			PF of{o.x, o.y};
			PF af{a.x, a.y};
			F area = Area(cutPoly(bor, of, af));
			chmax(ans, (F)cnt / n - area / (w * w));
		}
	}

	auto solve = [&]() {
		for (auto a: as) if (a.x * 2 <= w && a.y * 2 <= w) {
			P v{-a.x, a.y};
			P b = a + v;
			int cnt = 0;
			for (auto p: as) if (p.dis_to_line(a, b) <= 0) cnt++;
			PF af{a.x, a.y};
			PF bf{b.x, b.y};
			F area = Area(cutPoly(bor, af, bf));
			chmax(ans, (F)cnt / n - area / (w * w));
		}
	};

	rep(rd, 1, 4) {
		for (auto &p: as) p = p.rot90() + P{w, 0};
		solve();
	}

	printf("%.10f\n", ans);
	return 0;
}