/*
TASK: AKADEMIJA
LANG: C++
*/

#include <iostream>
using namespace std;

const int BEGALYBE = 1000000000;

/*
1 žingsnis. Kiekvienoje lentelės eilutėje surandame minimalią reikšmę ir
ją atimame iš kiekvieno tos eilutės elemento. Taip kiekvienoje lentelės
eilutėje gauname bent po vieną nulį.
*/
void SukuriameNulius(int n, int **lentele)
{
	/*
	eilutės
	*/
	for (int i = 0; i < n; ++i)
	{
		int minReiksme = lentele[i][0];
		for (int ii = 1; ii < n; ++ii)
		{
			if (lentele[i][ii] < minReiksme)
				minReiksme = lentele[i][ii];
		}

		for (int ii = 0; ii < n; ++ii)
			lentele[i][ii] -= minReiksme;
	}

	/*
	stulpeliai
	*/
	for (int ii = 0; ii < n; ++ii)
	{
		int minReiksme = lentele[0][ii];
		for (int i = 1; i < n; ++i)
		{
			if (lentele[i][ii] < minReiksme)
				minReiksme = lentele[i][ii];
		}

		for (int i = 0; i < n; ++i)
			lentele[i][ii] -= minReiksme;
	}
}

/*
2 žingsnis. Lentelėje pažymime tuos nulius, kurie yra vieninteliai savo
eilutėje arba stulpelyje. Pažymėdami nulį, kuris yra vienintelis savo
stulpelyje, uždengiame lentelės eilutę, kuriai jis priklauso. O pažymėdami
nulį, kuris yra vienintelis savo eilutėje, uždengiame lentelės stulpelį,
kuriam jis priklauso. Toliau tikrindami, ar nuliai yra vieninteliai savo
eilutėje ar stulpelyje, uždengtų nulių (esančių uždengtoje eilutėje ar
stulpelyje) neskaičiuojame. Pažymėdami nulį atliekame atitinkamos užduoties
priskyrimą darbininkui. Mūsų tikslas – atlikti lygiai N priskyrimų.
*/
int ZymimeNulius(int n, int **lentele, int *eil, int *stulp,
				 int *eil_nuliu, int *stulp_nuliu)
{
	int priskyrimu = 0;

	memset(eil_nuliu, 0, sizeof(int) * n);
	memset(stulp_nuliu, 0, sizeof(int) * n);
	
	/*
	suskaičiuojame, kiek nulių yra kiekvienoje eilutėje ir stulpelyje
	*/
	for (int i = 0; i < n; ++i)
	{
		for (int ii = 0; ii < n; ++ii)
		{
			if (lentele[i][ii] == 0)
			{
				++eil_nuliu[i];
				++stulp_nuliu[ii];
			}
		}
	}

	bool pakeista = true;
	while (pakeista)
	{
		pakeista = false;
		/*
		kiekvienai eilutei, kurioje yra tik vienas nulis..
		*/
		for (int j = 0; j < n; ++j)
		{
			if ((eil[j] == 0) && (eil_nuliu[j] == 1))
			{
				bool radom = false;
				for (int ii = 0; (ii < n) && !radom; ++ii)
				{
					if (lentele[j][ii] == 0)
					{
						for (int i = 0; i < n; ++i)
						{
							if (lentele[i][ii] == 0)
							{
								--eil_nuliu[i];
								--stulp_nuliu[ii];
								lentele[i][ii] = -1;
							}
						}
						++priskyrimu;
						stulp[ii] = 1;
						lentele[j][ii] = -2;
						radom = true;
					}
				}
				pakeista = true;
			}
		}
		/*
		kiekviename stulpelyje, kuriame yra tik vienas nulis..
		*/
		for (int j = 0; j < n; ++j)
		{
			if ((stulp[j] == 0) && (stulp_nuliu[j] == 1))
			{
				bool radom = false;
				for (int i = 0; (i < n) && !radom; ++i)
				{
					if (lentele[i][j] == 0)
					{
						for (int ii = 0; ii < n; ++ii)
						{
							if (lentele[i][ii] == 0)
							{
								--eil_nuliu[i];
								--stulp_nuliu[ii];
								lentele[i][ii] = -1;
							}
						}
						++priskyrimu;
						eil[i] = 1;
						lentele[i][j] = -2;
						radom = true;
					}
				}
				pakeista = true;
			}
		}
	}

	return priskyrimu;
}

/*
4 žingsnis. Pažymime bet kurį neuždengtą nulį. Kartu uždengiame jo
eilutę ir stulpelį.
*/
bool YraNeuzdengtuNuliu(int n, int **lentele, int *eil, int *stulp,
						int *eil_nuliu, int *stulp_nuliu)
{
	bool radom = false;

	for (int i = 0; (i < n) && !radom; ++i)
	{
		if (eil_nuliu[i] > 0)
		{
			for (int ii = 0; (ii < n) && !radom; ++ii)
			{
				if (lentele[i][ii] == 0)
				{
					for (int j = 0; j < n; ++j)
					{
						if (lentele[i][j] == 0)
						{
							--eil_nuliu[i];
							--stulp_nuliu[j];
							lentele[i][j] = -1;
						}
					}
					for (int j = 0; j < n; ++j)
					{
						if (lentele[j][ii] == 0)
						{
							--eil_nuliu[j];
							--stulp_nuliu[ii];
							lentele[j][ii] = -1;
						}
					}
					eil[i] = 1;
					stulp[ii] = 1;
					lentele[i][ii] = -2;
					radom = true;
				}
			}
		}
	}

	return radom;
}

/*
5.1 žingsnis. Ieškome minimalaus skaičiaus linijų, eilučių arba stulpelių,
kuriomis galima uždengti visus nulius lentelėje, tokiu būdu:
1) pažymime eilutes, kuriose nėra nei vieno pažymėto nulio;
2) pažymime stulpelius, kurie turi nulių pažymėtose eilutėse;
3) pažymime eilutes, kuriose yra pažymėtų nulių iš pažymėtų stulpelių.
Paskutinius du žingsnius kartojame tol, kol atliekame nors vieną pakeitimą
žymėjimuose. Tada uždengiame pažymėtuosius lentelės stulpelius ir
nepažymėtąsias lentelės eilutes.
*/
void UzdengiameNulius(int n, int **lentele, int *eil, int *stulp)
{
	memset(eil, 0, sizeof(int) * n);
	memset(stulp, 0, sizeof(int) * n);

	// 1) žingsnelis
	for (int i = 0; i < n; ++i)
	{
		bool radom = false;
		for (int ii = 0; (ii < n) && !radom; ++ii)
		{
			if (lentele[i][ii] == -2)
				radom = true;
		}

		if (!radom)
			eil[i] = 1;
	}

	bool pakeista = true;
	while (pakeista)
	{
		pakeista = false;
		// 2) žingsnelis
		for (int i = 0; i < n; ++i)
		{
			if (eil[i] == 1)
			{
				for (int ii = 0; ii < n; ++ii)
				{
					if ((stulp[ii] == 0) && (lentele[i][ii] <= 0))
					{
						stulp[ii] = 1;
						pakeista = true;
					}
				}
			}
		}
		// 3) žingsnelis
		for (int ii = 0; ii < n; ++ii)
		{
			if (stulp[ii] == 1)
			{
				for (int i = 0; i < n; ++i)
				{
					if ((eil[i] == 0) && (lentele[i][ii] == -2))
					{
						eil[i] = 1;
						pakeista = true;
					}
				}
			}
		}
	}

	for (int i = 0; i < n; ++i)
		eil[i] = 1 - eil[i];
}

/*
5.2 žingsnis. Surandame minimalią neuždengtą reikšmę lentelėje ir ją atimame
iš visų neuždengtų lentelės reikšmių bei pridedame prie visų lentelės
reikšmių, ties kuriomis kertasi eilutės ir stulpelius dengiančios linijos.
Atidengiame visas lentelės eilutes ir stulpelius.
*/
void SukuriameNaujusNulius(int n, int **lentele, int *eil, int *stulp)
{
	int minReiksme = BEGALYBE;
	/*
	surandame mažiausią neuždengtą reikšmę
	*/
	for (int i = 0; i < n; ++i)
	{
		if (eil[i] == 1)
			continue;

		for (int ii = 0; ii < n; ++ii)
		{
			if ((stulp[ii] == 0) && (lentele[i][ii] < minReiksme))
				minReiksme = lentele[i][ii];
		}
	}

	/*
	atimame ją iš kiekvienos neuždengtos reikšmės ir pridedame prie kiekvienos
	dukart uždengtos reikšmės
	*/
	for (int i = 0; i < n; ++i)
	{
		if (eil[i] == 0)
		{
			for (int ii = 0; ii < n; ++ii)
			{
				if (stulp[ii] == 0)
					lentele[i][ii] -= minReiksme;
			}
		}
		else
		{
			for (int ii = 0; ii < n; ++ii)
			{
				if (stulp[ii] == 1)
				{
					lentele[i][ii] += minReiksme;
				}
			}
		}
	}
}

void Vengriskas(int n, int **lentele)
{
	int *eil = new int[n];
	int *stulp = new int[n];
	int *eil_nuliu = new int[n];
	int *stulp_nuliu = new int[n];
	bool baigta = false;
	bool buvoNeuzdengtuNuliu = false;
	int priskyrimu = 0;
	
	SukuriameNulius(n, lentele);
	memset(eil, 0, sizeof(int) * n);
	memset(stulp, 0, sizeof(int) * n);
	while (!baigta)
	{
		priskyrimu += ZymimeNulius(n, lentele, eil, stulp, eil_nuliu, stulp_nuliu);
		if (priskyrimu < n)
		{
			if (YraNeuzdengtuNuliu(n, lentele, eil, stulp, eil_nuliu, stulp_nuliu))
			{
				++priskyrimu;
				buvoNeuzdengtuNuliu = true;
			}
			else
			{
				if (buvoNeuzdengtuNuliu)
				{
					UzdengiameNulius(n, lentele, eil, stulp);
					buvoNeuzdengtuNuliu = false;
				}

				for (int i = 0; i < n; ++i)
				{
					for (int ii = 0; ii < n; ++ii)
					{
						if (lentele[i][ii] < 0)
							lentele[i][ii] = 0;
					}
				}
				SukuriameNaujusNulius(n, lentele, eil, stulp);
				memset(eil, 0, sizeof(int) * n);
				memset(stulp, 0, sizeof(int) * n);
				priskyrimu = 0;
			}
		}
		else
		{
			baigta = true;
		}
	}

	delete[] eil;
	delete[] stulp;
	delete[] eil_nuliu;
	delete[] stulp_nuliu;
}

int main()
{
	freopen("AKADEMIJA.IN", "r", stdin);
	freopen("AKADEMIJA.OUT", "w", stdout);

	int n, p;
	scanf("%d %d", &n, &p);
	int maxReiksme = 0;
	
	int **spejimai = new int*[n];
	for (int i = 0; i < n; ++i)
	{
		spejimai[i] = new int[n];
		memset(spejimai[i], 0, sizeof(int) * n);
	}
	for (int j = 0; j < p; ++j)
	{
		int i, ii;

		scanf("%d %d", &i, &ii);
		++spejimai[i - 1][ii - 1];
		if (spejimai[i - 1][ii - 1] > maxReiksme)
			maxReiksme = spejimai[i - 1][ii - 1];
	}

	/*
	surandame lentelėje maksimalią reikšmę ir iš jos atimame kiekvieną
	lentelės reikšmę
	*/
	for (int i = 0; i < n; ++i)
		for (int ii = 0; ii < n; ++ii)
			spejimai[i][ii] = maxReiksme - spejimai[i][ii];

	Vengriskas(n, spejimai);

	for (int i = 0; i < n; ++i)
	{
		for (int ii = 0; ii < n; ++ii)
			if (spejimai[i][ii] == -2)
				cout << ii + 1 << endl;
	}
	for (int i = 0; i < n; ++i)
		delete[] spejimai[i];
	delete[] spejimai;

	return 0;
}