#include <fstream>
#include <queue>
#include <vector>
#include <algorithm>
#include <cstring>

using namespace std;

fstream fin("critice.in", ios::in);
fstream fout("critice.out", ios::out);

struct elem{
	int fl, cp, ord;
};

#define MAXN 1001
int N, M, T[MAXN], used[MAXN], flow;
elem netw[MAXN][MAXN];
vector <int> list[MAXN], out;
vector <pair<int, int>> sol;
queue <int> q;

void read()
{
	fin >> N >> M;
	for (int i = 1, x, y, c; i <= M; i++)
		fin >> x >> y >> c,
		netw[x][y].cp = netw[y][x].cp = c,
		netw[x][y].ord = netw[y][x].ord = i,
		list[x].push_back(y),
		list[y].push_back(x);
	fin.close();
}

int BFS()
{
	memset(used, false, sizeof(int) * N + 1);
	q.push(1);
	used[1] = 1;

	while (!q.empty()){
		int node = q.front();
		q.pop();
		if (node == N) continue;

		for (int i = 0; i < (int)list[node].size(); i++){
			int new_node = list[node][i];
			if (used[new_node] || netw[node][new_node].fl == netw[node][new_node].cp) continue;
			used[new_node] = 1;
			q.push(new_node);
			T[new_node] = node;
		}
	}
	return used[N];
}
void BFS2()
{
	int node, new_node, val;
	q.push(1),  q.push(N);
	used[1] = -1, used[N] = -2;

	while (!q.empty()){
		node = q.front();
		q.pop();
		for (int i = 0; i < (int)list[node].size(); i++){
			new_node = list[node][i];
			if (used[new_node] == used[node]) continue;
			if (netw[node][new_node].cp - netw[node][new_node].fl == 0 || netw[new_node][node].cp - netw[new_node][node].fl == 0){
				if(used[node] == -2)  
					sol.push_back(make_pair(node, new_node));
				continue;
			}
			q.push(new_node);
			used[new_node] = used[node];
		}
	}
}

int main()
{
	read();
	used[N] = true;

	while (BFS()){
		for (int i = 0; i < (int)list[N].size(); i++){
			T[N] = list[N][i];
			if (!T[N] || netw[T[N]][N].cp - netw[T[N]][N].fl == 0) continue;
			int minf = ~(1 << 31);

			for (int node = N, newf; node != 1; node = T[node]){
				newf = netw[T[node]][node].cp - netw[T[node]][node].fl;
				if (newf < minf)  minf = newf;
			}
			if (!minf) continue;

			for (int node = N; node != 1; node = T[node])
				netw[T[node]][node].fl += minf,
				netw[node][T[node]].fl -= minf;
			flow += minf;
		}
	}
	BFS2();
	for (int i = 0; i < (int)sol.size(); i++){
		if (used[sol[i].first] == used[sol[i].second] || used[sol[i].first] == 0 || used[sol[i].second] == 0)
			continue;
		out.push_back(netw[sol[i].first][sol[i].second].ord);
	}
	fout << out.size() << "\n";
	for (int i = 0; i < (int)out.size(); i++)
		fout << out[i] << "\n";

	fout.close();
	return 0;
}