#include <fstream>
#include <vector>
#include <queue>
#define nmax 1010
#define mmax 10100
#define oo (1<<30)
#define X Edge[i].first
#define Y Edge[i].second
#define Vecin G[Nod][i]
using namespace std;

queue <int> Queue;
vector <int> G[nmax],Answer;
pair<int,int> Edge[mmax];
int N,M,paint,used[nmax],Father[nmax];
int Mark[nmax],Flow[nmax][nmax];

void Dfs(int Nod,int mark) {
	
	Mark[Nod]=mark;
	
	for(int i=0;i<G[Nod].size();i++)
		if(mark==1 && Flow[Nod][Vecin] && !Mark[Vecin])
			Dfs(Vecin,mark);
		else
		if(mark==2 && Flow[Vecin][Nod] && !Mark[Vecin])
			Dfs(Vecin,mark);
	
}
bool BFS() {
	
	int i,Nod;
	
	Queue.push(1);
	++paint;
	used[1]=paint;
	
	while(!Queue.empty()) {
		
		Nod=Queue.front();
		Queue.pop();
		if(Nod==N)
			continue;
		
		for(i=0;i<G[Nod].size();i++)
			if(Flow[Nod][Vecin] && used[Vecin]!=paint) {
				
				used[Vecin]=paint;
				Father[Vecin]=Nod;
				Queue.push(Vecin);
				
				}
		
		}
	
	return (used[N]==paint);
	
}
void solve() {
	
	int i,minFlow,Nod;
	
	while(BFS())
		for(i=0;i<G[N].size();i++) {
			
			Nod=G[N][i];
			
			if(!Flow[Nod][N] || used[Nod]!=paint)
				continue;
			
			Father[N]=Nod;
			
			minFlow=oo;
			for(Nod=N;Nod!=1;Nod=Father[Nod])
				minFlow=min(minFlow,Flow[Father[Nod]][Nod]);
			
			if(!minFlow)
				continue;
			
			for(Nod=N;Nod!=1;Nod=Father[Nod]) {
				Flow[Nod][Father[Nod]]+=minFlow;
				Flow[Father[Nod]][Nod]-=minFlow;
				}
			
			}
	
	Dfs(1,1);
	Dfs(N,2);
	
	for(i=1;i<=M;i++)
		if(Mark[X] && Mark[Y] && Mark[X]!=Mark[Y])
			Answer.push_back(i);
		
}
void read() {
	
	int i,C;
	ifstream in("critice.in");
	in>>N>>M;
	
	for(i=1;i<=M;i++) {
		
		in>>X>>Y>>C;
		
		G[X].push_back(Y);
		G[Y].push_back(X);
		Flow[X][Y]=Flow[Y][X]=C;
		
		}
	
	in.close();
	
}
void write() {
	
	ofstream out("critice.out");
	
	out<<Answer.size()<<'\n';
	for(int i=0;i<Answer.size();i++)
		out<<Answer[i]<<'\n';
	
	out.close();
	
}
int main() {
	
	read();
	solve();
	write();
	
	return 0;
	
}