// retelistica nesimtita
#include <iostream>
#include <fstream>
#include <vector>
#include <queue>

using namespace std;
 
ifstream fin("critice.in");
ofstream fout("critice.out");
 
const int N = 1000, inf = 1e9;
vector <int> adj[N + 1];
int f[N + 1][N + 1], parent[N + 1], dirty[N + 1][N + 1];
bool viz[N + 1];
 
vector <pair <int, int>> edges;

int n, m;
 
bool BFS1(){
	for(int i = 1; i <= n; i++)
		parent[i] = viz[i] = 0;
 
	queue <int> Q;
 
	Q.push(1);
	viz[1] = true;
 
	while(!Q.empty()){
		int nod = Q.front();
		Q.pop();
 
		if(nod == n)
			return true;
 
		for(auto vec : adj[nod])
			if(!viz[vec] && f[nod][vec] > 0)
				parent[vec] = nod, viz[vec] = true, Q.push(vec);
	}
 
	return false;
}

void DFS(int nod){
	viz[nod] = true;
	for(auto vec : adj[nod])
		if(!viz[vec]){
			if(f[nod][vec] == 0 || f[vec][nod] == 0)
				dirty[nod][vec]++, dirty[vec][nod]++;
			else
				DFS(vec);
		}
}

int main(){
 
	fin >> n >> m;
 
	for(int i = 1; i <= m; i++){
		int a, b, c;
		fin >> a >> b >> c;

		edges.push_back({a, b});
		adj[a].push_back(b);
		adj[b].push_back(a);

		f[a][b] = c;
		f[b][a] = c;
	}
 
	while(BFS1()){
		for(auto vec : adj[n]){
			if(f[vec][n] <= 0 || !viz[vec])
				continue;
 
			parent[n] = vec;
 
			int mini = inf, nod = n;
			while(nod != 1)
				mini = min(mini, f[parent[nod]][nod]), nod = parent[nod];
 
			if(mini == 0)
				continue;
 
			nod = n;
 
			while(nod != 1)
				f[parent[nod]][nod] -= mini, f[nod][parent[nod]] += mini, nod = parent[nod];
 		}
	}

	for(int i = 1; i <= n; i++)
		viz[i] = false;
	DFS(1);

	for(int i = 1; i <= n; i++)
		viz[i] = false;
	DFS(n);

	vector <int> ans;
	for(int i = 0; i < (int)edges.size(); i++)
		if(dirty[edges[i].first][edges[i].second] == 2)
			ans.push_back(i + 1);

	fout << (int)ans.size() << '\n';
	for(auto x : ans)
		fout << x << '\n';

	return 0;
}