#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <bitset>		//UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <iomanip>		//do setprecision
#include <ctime>
#include <complex>
using namespace std;

#define FOR(i,b,e) for(int i=(b);i<(e);++i)
#define FORQ(i,b,e) for(int i=(b);i<=(e);++i)
#define FORD(i,b,e) for(int i=(b)-1;i>=(e);--i)
#define REP(x, n) for(int x = 0; x < (n); ++x)

#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double

const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;

#define MR 500010

vector < int > g[MR];
char done[MR];

int topoSort[MR];
int wsk;
void dfsSCC(int nr)
{
	done[nr] = 1;
	REP(i,(int)g[nr].size())
		if(!done[g[nr][i]])
			dfsSCC(g[nr][i]);
	topoSort[wsk++] = nr;
}

int sCC, ktoraSCC[MR], ileSCC[MR];
void findSCC(int nr)
{
	ktoraSCC[nr] = sCC;
	REP(i,(int)g[nr].size())
		if(!ktoraSCC[g[nr][i]])
			findSCC(g[nr][i]);
}

bool found;
vector < int > S;
list < int > cykl;
list < int > :: iterator head, posCykl[MR];
bool wCyklu[MR];

vector < int > res;

void findFirst(int nr)
{
	if(found) return;
	done[nr] = 1;
	S.push_back(nr);

	REP(i,(int)g[nr].size())
		if(!done[g[nr][i]]) findFirst(g[nr][i]);
		else if(done[g[nr][i]] == 1 && !found)
		{
			// przygotuj pierwszy cykl
			found = 1;
			FORD(j,(int)S.size(),0)
			{
				cykl.push_front(S[j]);
				if(S[j] == g[nr][i]) break;
			}
			head = cykl.begin();
			for(list<int> :: iterator it = cykl.begin(); it != cykl.end(); it++)
			{
				posCykl[*it] = it;
				wCyklu[*it] = 1;
			}
		}
	S.pop_back();
	done[nr] = 2;
}

void remove(list <int> :: iterator it)
{
	if(it == head) head++;
	cykl.erase(it);
}

list < int > :: iterator next(list <int> :: iterator it)
{
	//assert(it != cykl.end());
	it++;
	if(it == cykl.end()) it = head;
	
	return it;
}

void wycieciwuj(int nr)
{
	REP(i,(int)g[nr].size())
		if(wCyklu[g[nr][i]])
		{
			// usun wszystkie nastepniki nr az do g[nr][i]
			list<int> :: iterator pom = posCykl[nr];
			list<int> :: iterator nast = next(pom);
			while(!cykl.empty())
			{
				if(*nast == g[nr][i]) break;
				pom = next(nast);
				wCyklu[*nast] = 0;
				remove(nast);
				nast = pom;
			}
		}
}

int gdzieNaCykl[MR];
bool removed[MR];
int nextNaCyklu[MR];
int initialPos[MR];
int originalNext[MR];
int lengthC;

void szamajCykl(int p, int k)
{
	if(cykl.empty()) return;

	vector < int > V;
	int firstToRemove;
	if(!removed[p]) firstToRemove = *next(posCykl[p]);
	else firstToRemove = p;
	
	// jesli nastepnik zostal usuniety, wez jego nastepnika itd
	while(removed[firstToRemove])
	{
		V.PB(firstToRemove);
		firstToRemove = nextNaCyklu[firstToRemove];
	}
	while(!V.empty())
	{
		nextNaCyklu[V.back()] = firstToRemove;
		V.pop_back();
	}

	int firstToSave = k;
	// jesli nastepnik zostal usuniety, wez jego nastepnika itd
	while(removed[firstToSave])
	{
		V.PB(firstToSave);
		firstToSave = nextNaCyklu[firstToSave];
	}
	while(!V.empty())
	{
		nextNaCyklu[V.back()] = firstToSave;
		V.pop_back();
	}

	if(firstToRemove == firstToSave)
	{
		// trzeba rozpatrzec 2 przypadki
		int start1 = initialPos[originalNext[p]], start2 = initialPos[firstToRemove];
		if(start2 < start1) start2 += lengthC;
		int end1 = initialPos[k], end2 = initialPos[firstToSave];
		if(end2 < end1) end2 += lengthC;
		// gdy koniec pokonal wieksza droge niz poczatek usun wszystko, wpp nie usuwaj nic
		if(end2-end1 > start2-start1) cykl.clear();
		return;
	}

	list<int> :: iterator it = posCykl[firstToRemove];
	list<int> :: iterator pom;
	while(!cykl.empty())
	{
		if(*it == firstToSave) break;
		pom = next(it);
		//wCyklu[*it] = 0; - nie usuwaj statusu, ze jest w cyklu
		nextNaCyklu[*it] = *pom;	// kolejny nastepnik na cyklu
		removed[*it] = 1;
		remove(it);
		it = pom;
	}
}

void dfs(int nr)
{
	done[nr] = 1;
	S.PB(nr);

	REP(i,(int)g[nr].size())
	{
		if(wCyklu[g[nr][i]]) szamajCykl(S.front(), g[nr][i]);
		else if(!done[g[nr][i]]) dfs(g[nr][i]);
		else if(done[g[nr][i]] == 1)
		{
			// mamy kolejny cykl
			cykl.clear();
		}
		else if(gdzieNaCykl[g[nr][i]] != -1)	// przetworzony wierzcholek, ktory dochodzi do cyklu
			szamajCykl(S.front(), gdzieNaCykl[g[nr][i]]);

		// propaguj informacje o tym gdzie sie trafia w cykl
		if(gdzieNaCykl[nr] == -1)
			gdzieNaCykl[nr] = gdzieNaCykl[g[nr][i]];
	}
	
	S.pop_back();
	done[nr] = 2;
}

bool go(int n)
{
	REP(i,n) if(!done[i]) dfsSCC(i);
	REP(i,n)
		if(!ktoraSCC[topoSort[i]])
		{
			sCC++;
			findSCC(topoSort[i]);
		}
	// spr czy jest dokladnie jedna SCC o licznosci > 1
	REP(i,n) ileSCC[ktoraSCC[i]]++;
	int pom = 0;
	FORQ(i,1,sCC) if(ileSCC[i] > 1) pom++;
	if(!pom) return 0;	// nie ma ani jednego cyklu
	if(pom == 1)
	{
		// jest ok
		int superCykl;
		FORQ(i,1,sCC)
			if(ileSCC[i] > 1)
			{
				superCykl = i;
				break;
			}
		
		REP(i,n) done[i] = 0;
		
		REP(i,n)
			if(ktoraSCC[i] == superCykl)
			{
				findFirst(i);
				break;
			}

		// pozbadz sie cieciw
		REP(i,n)
			if(wCyklu[i])
				wycieciwuj(i);

		lengthC = cykl.size();
		// wyznacz pozycje
		int pom1 = 0;
		for(list<int> :: iterator it = cykl.begin(); it != cykl.end(); it++)
		{
			initialPos[*it] = pom1++;
			originalNext[*it] = *next(it);
		}

		// jedz dfsy z kazdego wierzcholka cyklu
		REP(i,n)
		{
			done[i] = 0;
			gdzieNaCykl[i] = -1;
		}

		// ustaw pozycje gdzieNaCyklu dla cyklu
		for(list<int> :: iterator it = cykl.begin(); it != cykl.end(); it++)
			gdzieNaCykl[*it] = *it;
		
		list < int > cykl1 = cykl;
		for(list<int> :: iterator it = cykl1.begin(); it != cykl1.end(); it++)
			dfs(*it);
	}

	return 1;
}

int main()
{
	int n, m;
	scanf("%d%d", &n, &m);
	REP(i,m)
	{
		int a, b;
		scanf("%d%d", &a, &b);a--;b--;
		g[a].PB(b);
	}
	if(!go(n))
	{
		printf("NIE\n");
	}
	else
	{
		for(list < int > :: iterator it = cykl.begin(); it != cykl.end(); it++) res.PB(*it);
		sort(res.begin(), res.end());
		printf("%d\n", res.size());
		REP(i,(int)res.size()) printf("%d ", res[i]+1);
		printf("\n");
	}
	return 0;
}