#include<fstream>
#include<vector>
#include<queue>
#include<cmath>
using namespace std;
int n,m;
int C[1010][1010],F[1010][1010],pred[1010];
bool acces[2][1010];
vector <int> G[1010],sol;
struct Muchie{int x,y;};
Muchie M[10010];

inline void Citire()
{
	int i,x,y,c;
	ifstream fin("critice.in");
	fin>>n>>m;
	for(i=1;i<=m;i++)
	{
		fin>>x>>y>>c;
		G[x].push_back(y);
		G[y].push_back(x);
		C[x][y]=c;
		M[i].x=x;
		M[i].y=y;
	}
	fin.close();
}

inline bool Acces()
{
	int i,x;
	queue <int> Q;
	vector <int>::iterator it;
	for(i=1;i<=n;i++)
		pred[i]=0;
	Q.push(1);
	pred[1]=0;
	while(!Q.empty())
	{
		x=Q.front();
		Q.pop();
		for(it=G[x].begin();it!=G[x].end();it++)
		{
			if(!pred[*it] && F[x][*it]<C[x][*it])
			{
				pred[*it]=x;
				Q.push(*it);
			}
		}
	}
	if(pred[n])
		return true;
	return false;
}

inline void MaxFlow()
{
	vector <int>::iterator it;
	int x,val;
	while(Acces()==true)
	{
		for(it=G[n].begin();it!=G[n].end();it++)
		{
			x=*it;
			if(F[x][n]>=C[x][n])
				continue;
			val=C[x][n]-F[x][n];
			while(pred[x])
			{
				val=min(val,C[pred[x]][x]-F[pred[x]][x]);
				x=pred[x];
			}
			x=*it;
			F[x][n]+=val;
			F[n][x]-=val;
			while(pred[x])
			{
				F[pred[x]][x]+=val;
				F[x][pred[x]]-=val;
				x=pred[x];
			}
		}
	}
}

inline void BFS1(int start,bool viz[])
{
	int x;
	queue <int> Q;
	vector <int>::iterator it;
	Q.push(start);
	viz[start]=true;
	while(!Q.empty())
	{
		x=Q.front();
		Q.pop();
		for(it=G[x].begin();it!=G[x].end();it++)
		{
			if(!viz[*it] && F[x][*it]<C[x][*it])
			{
				viz[*it]=true;
				Q.push(*it);
			}
		}
	}
}

inline void BFS2(int start,bool viz[])
{
	int x;
	queue <int> Q;
	vector <int>::iterator it;
	Q.push(start);
	viz[start]=true;
	while(!Q.empty())
	{
		x=Q.front();
		Q.pop();
		for(it=G[x].begin();it!=G[x].end();it++)
		{
			if(!viz[*it] && F[*it][x]<C[*it][x])
			{
				viz[*it]=true;
				Q.push(*it);
			}
		}
	}
}

inline void Rezolvare()
{
	int i,x,y;
	BFS1(1,acces[0]);
	BFS2(n,acces[1]);
	for(i=1;i<=m;i++)
	{
		x=M[i].x;
		y=M[i].y;
		if((acces[0][x] && acces[1][y] && F[x][y]==C[x][y]) || (acces[0][y] && acces[1][x] && F[y][x]==C[y][x]))
			sol.push_back(i);
	}
}

inline void Afisare()
{
	vector <int>::iterator it;
	ofstream fout("critice.out");
	fout<<sol.size()<<"\n";
	for(it=sol.begin();it!=sol.end();it++)
		fout<<*it<<"\n";
	fout.close();
}

int main()
{
	Citire();
	MaxFlow();
	Rezolvare();
	Afisare();
	return 0;
}