#include <stdio.h>
#include <stdlib.h>

#define MAXSAD 60
#define POC 121
#define PREGRADA 122

int ax[MAXSAD], ay[MAXSAD], n, d;  // Koordinate sadnica, broj, minimalna dozvoljena udanjenost.
char preb[MAXSAD][MAXSAD];         // Koje sadnice su preblizu.

int odredena[MAXSAD];              // za koje sadnice je odredeno da li ce se vaditi ili ne
int obraditi[MAXSAD], no;          // grupa sadnica koje se trenutno obraduju
int bila[MAXSAD];                  // da li je sadnica isprobana u nekoj kombinaciji
int maxostavljenih;                // maksimalan naden broj ostavljenih

void trazi_preblizu();
void optimiziraj();
void trazi_najvise_ostavljenih();

int main()
{
	int i;
	FILE *f;
	f = fopen("sadnice.in", "rt");
	fscanf(f, "%d%d", &d, &n);
	for (i=0; i<n; i++) fscanf(f, "%d%d", &ax[i], &ay[i]);
	fclose(f);
	maxostavljenih = 0;
	for (i=0; i<n; i++) odredena[i] = 0;

	/* U matricu 'preb' se zapise koje su sadnice preblizu. */
	trazi_preblizu();
	/* Uklone se sadnice za koje je ocito sto treba s njima. */
	optimiziraj();
	/* Isprobaju se svi nacini vadenja sadnica i pronade onaj
	gdje ih najvise ostane. */
	trazi_najvise_ostavljenih();

	f = fopen("sadnice.out", "wt");
	fprintf(f, "%d\n", n-maxostavljenih);
	fclose(f);
	return 0;
}



void trazi_preblizu()
{
	/* U matricu 'preb' se upisuje koje su sadnice preblizu. */
	int i, j, dx, dy;
	for (i=0; i<n-1; i++)
		for (j=i+1; j<n; j++)
		{   dx = ax[i]-ax[j];
			dy = ay[i]-ay[j];
			if (dx*dx+dy*dy < d*d)
				preb[i][j] = preb[j][i] = 1;
			else
				preb[i][j] = preb[j][i] = 0;
		}
}

int isti_susjedi(int a, int b)
{
	/* Provjerava da li sadnice a i b imaju isti skup sadnica koje
	su im preblizu. */
	int i;
	for (i=0; i<n; i++)
		if (!odredena[i])
		if (i!=a && i!=b)
			if (preb[a][i]!=preb[b][i]) return 0;
	return 1;
}

void optimiziraj()
{
	int i, j, k, ii, ponovo;
	int hash[MAXSAD];

	do
	{   ponovo = 0;
		for (i=0; i<n; i++) if (!odredena[i])
		{
			/* Racuna se 'k', broj sadnica koje su preblizu i-te.
			U niz 'hash' se za sadnicu racuna broj koji
			ovisi o tome koje su joj sadnice preblizu. To se
			koristi radi lakseg usporedivanja sadnica u (3.)*/
			k = 0;
			hash[i] = 0;
			for (j=0; j<n; j++) if (!odredena[j])
				if (preb[i][j])
				{	k++;
					hash[i] += j+1;
				}

			/* 1. Ako sadnica nije preblizu nijedne druge, za nju se odredi
			da ce se sigurno ostaviti. */

			if (k==0)
			{	odredena[i] = 1;
				maxostavljenih++;
				ponovo = 1;
			}

			/* 2. Ako sadnica ima samo jednu preblizu onda je sigurno bolje
			nju ostaviti nego tu drugu sadnicu, a nema smisla izvaditi obje.
			Za drugu sadnicu se onda odredi da ju treba izvaditi. */

			else if (k==1)
			{	odredena[i] = 1;
				maxostavljenih++;
				ponovo = 1;
				for (j=0; j<n; j++)
					if (preb[i][j])
					{	odredena[j] = 1;
						preb[i][j] = 0;
						preb[j][i] = 0;
						for (ii=0; ii<n; ii++) { preb[j][ii] = 0; preb[ii][j] = 0; }
						break;
					}
			}

			/* 3. Ako postoje dvije sadnice koje su preblizu, i imaju isti
			skup sadnica koje su im preblizu, onda se jedna od njih mora
			sigurno izvaditi, a nije bitno koja.
			*/
			else
			{	for (j=0; j<i; j++) if (!odredena[i])
					if (preb[i][j])
					/* Ako dvije nemaju isti hash onda sigurno nemaju iste
					'susjede', a ako imaju onda to jos treba provjeriti */
					if (hash[i]-j-1 == hash[j]-i-1)
						if (isti_susjedi(i,j))
						{	odredena[i] = 1;
							ponovo = 1;
							for (ii=0; ii<n; ii++) { preb[i][ii] = 0; preb[ii][i] = 0; }
							break;
						}
			}
		}
        /* Ponavlja se dok se ne moze nista vise jednostavno ukloniti. */ 
	} while (ponovo);
}

int odredi_grupu()
{
	/* Odredi grupu povezanih sadnica koje treba obraditi. */

	int i, j;
	for (i=0; i<n; i++) if (!odredena[i]) break; /* nade prvu neobradenu */
	if (i==n) return 0;

	/* U grupu treba jos dodati sve njoj 'susjedne' sadnice, i sve
	sadnice koje su povezane sa dodanim sadnicama. Grupa se zapise
	u niz 'obraditi' */

	no = 0;
	obraditi[no++] = i;
	odredena[i] = 1;
	i = 0;
	while (i<no)
	{	for (j=0; j<n; j++)
			if (preb[obraditi[i]][j] && !odredena[j])
			{	obraditi[no++] = j;
				odredena[j] = 1;
			}
		i++;
	}
	return 1;
}

int uzmi_slobodnu(int *s)
{
	/* Odabere se neka od sadnica koju treba obraditi, a jos nisu
	isprobane kombinacije s tom sadnicom.
	Pokazalo se da program radi brze ako prve odaberimo sadnice koje
	imaju manje susjednih sadnica. */

	int i, j, naji, najss, ss;
	najss = 10000;
	for (i=0; i<no; i++) if (!bila[obraditi[i]]) // ako nije isprobana sadnica
	{	ss = 0;
		for (j=0; j<no; j++) if (!bila[obraditi[j]] && i!=j)
			if (preb[obraditi[j]][obraditi[i]])
				ss++;
		if (ss<najss)                           // i ako ima najmanje susjednih
		{	najss = ss;
			naji = i;
		}
	}
	if (najss!=10000)
	{	*s = obraditi[naji];
		return 1;
	}
	return 0;
}

void trazi_najvise_ostavljenih()
{
	/* Isprobavaju se svi nacini na koji se mogu vaditi sadnice. Prati se
	koji nacin daje najvise ostavljenih sadnica.
	Za pracenje sadnica sa kojima su isprobane kombinacije koristi se stog. */

	int rez, najrez; // trenutni i najbolji rezultat za pojedinu grupu sadnica
	int stog[3*MAXSAD+5];
	int stogn, i, prvi, s;

	while (odredi_grupu()) /* obraduje se jedna po jedna grupa povezanih sadnica */
	{
		stogn = 1;
		stog[0] = POC;
		for (i=0; i<n; i++) bila[i] = 0;
		rez = najrez = 0;
		prvi = 0;

		uzmi_slobodnu(&s); /* uzme se neka sadnica sa kojom jos nisu isprobane kombinacije */
		do
		{	/* Ako sa ta sadnica ostavi, onda treba sve susjedne sadnice
			izvaditi. Uzme se neka nova sadnica i opet se gleda - koje
			sadnice treba izvaditi ako se ona ostavi.
			Tako dalje dok se ne 'potrose' sve sadnice. */
			do
			{	stog[stogn++] = -s-1;
				bila[s] = 1;
				for (i=0; i<n; i++) if (!bila[i] && preb[s][i])
				{	bila[i] = 1;
					if (prvi) stog[stogn++] = -i-1;
					else stog[stogn++] = i+1;
				}
				prvi = 0;
				rez++;
				stog[stogn++] = PREGRADA;
			} while (uzmi_slobodnu(&s));

			/* Sa ovom kombinacijom se pogleda da li je najbolja od do sad
			isprobanih. */
			if (rez>najrez) najrez = rez;

			/* Sada se isprobavaju ostale kombinacije:
			Gleda se posljednja sadnica za koju se reklo da ce se ostaviti,
			a njoj susjedne je trebalo izvaditi. Sada se probaju kombinacije
			ako se ta sadnica izvadi, i gleda se za svaku njoj susjednu:
			sto ako se ona ostavi. */
			do
			{   s = stog[--stogn];
				if (s==PREGRADA)
				{	for (i=stogn-1; stog[i]!=PREGRADA && stog[i]!=POC; i--)
						bila[abs(stog[i])-1] = 0;
					rez--;
				}
			} while (!(s==POC || (s>0 && s<=n)));
			if (s!=POC)
			{	s--;
				prvi = 1;
			}

		} while (s!=POC);

		maxostavljenih += najrez;
	}

}