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

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], flow;
bool used[MAXN];
elem netw[MAXN][MAXN];
vector <int> list[MAXN], sol;

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(bool) * N + 1);
	queue <int> q;
	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];
}
inline void add(int val)
{
	for (int i = 0; i < (int)sol.size(); i++)
		if (sol[i] == val) return;
	sol.push_back(val);
}
void find_sol()
{
	struct q_elem{
		int node, full, prev;
	} ins;
	queue <q_elem> q;
	ins.node = 1, ins.full = 0, ins.prev = 0;
	q.push(ins);

	while (!q.empty()){
		q_elem now = q.front();
		q.pop();
		if (now.node == N && now.full) add(now.full);
		if (now.node == N) continue;

		for (int i = 0; i < (int)list[now.node].size(); i++){
			int new_node = list[now.node][i],
				free_fl = netw[now.node][new_node].cp - netw[now.node][new_node].fl;
			if (now.prev == new_node || (now.full && !free_fl)) continue;
			ins.full = now.full ? now.full : !free_fl ? netw[now.node][new_node].ord : 0;
			ins.node = new_node;
			ins.prev = now.node;
			q.push(ins);
		}
	}
}

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

	while (true){
		if (!BFS()) break;
		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;
		}
	}
	find_sol();
	fout << sol.size() << "\n";
	for (int i = 0; i < sol.size(); i++)
		fout << sol[i] << " ";

	fout.close();
	return 0;
}