#include <stdio.h>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <deque>
#include <string.h>

using namespace std;

typedef pair<int, int> PII;

#ifdef _WIN32
#define TYPEOF decltype
#else
#define TYPEOF typeof
#endif

#define FOR(i,s,e) for(int i = s;i < e; i++)
#define TR(i, c) for(TYPEOF(c.begin()) i = c.begin(); i != c.end(); ++i)
#define TRS(i, c, ...) TR(__itr, c) { TYPEOF(*c.begin()) &i = *__itr;  __VA_ARGS__ }
#define TRP(f, s, c, ...) TR(__itr, c) { TYPEOF(c.begin()->first) &f = __itr->first; TYPEOF(c.begin()->second) &s = __itr->second;  __VA_ARGS__ }
#define ERASE_IF(i, c, ...) for(TYPEOF(c.begin()) __itr = c.begin(); __itr != c.end(); ) { TYPEOF(*c.begin()) &i = *__itr; if( __VA_ARGS__ ) c.erase(__itr++); else ++__itr; }

#define NMAX 1024

int C[NMAX][NMAX];
int F[NMAX][NMAX];
int P[NMAX];
int Q[NMAX];
int viz[NMAX];
int idx[NMAX][NMAX];

vector<int> G[NMAX];

int N,M;

int bfs() {

	int s = 0, e = 1;
	Q[0] = 1;
	memset(viz, 0, (N+1) * sizeof(int));
	viz[1] = 1;

	while(s < e) {
		int na = Q[s++];
		if(na == N) continue;
		FOR(i,0,G[na].size()) {
			int nb = G[na][i];
			if(viz[nb] || C[na][nb] == F[na][nb]) continue;
			viz[nb] = 1;
			P[nb] = na;
			Q[e++] = nb;
		}
	}

	return viz[N];
}

#define INF 0x3f3f3f3f

void dfs(int na, int ep)
{
	FOR(i,0,G[na].size()) {
		int nb = G[na][i];
		if(!viz[nb] && C[na][nb] != F[na][nb]) {
			viz[nb] |= ep;
			dfs(nb, ep);
		}
	}
}

int main()
{
#if 1
	freopen("critice.in", "r", stdin);
#ifndef MY_STUFF
	freopen("critice.out", "w", stdout);
#endif
#endif

	scanf("%d %d", &N, &M);

	FOR(i,0,M) {
		int x,y,c;
		scanf("%d %d %d", &x, &y, &c);
		C[x][y] = c;
		C[y][x] = c;
		idx[x][y] = i+1;
		idx[y][x] = i+1;
		G[x].push_back(y);
		G[y].push_back(x);
	}

	int flow, fmin;

	for(flow = 0; bfs(); )
		FOR(i, 0, G[N].size()) {
			int nod = G[N][i];
			if(!viz[nod] || C[nod][N] == F[nod][N]) continue;
			P[N] = nod;
			fmin = INF;
			for(int nod = N; nod != 1; nod = P[nod]) {
				int c = C[ P[nod] ][nod], f = F[ P[nod] ][nod];
				fmin = min(fmin, c - f);
			}
			for(int nod = N; nod != 1; nod = P[nod]) {
				F[ P[nod] ][nod] += fmin;
				F[nod][ P[nod] ] -= fmin;
			}
			flow += fmin;
		}

	memset(viz, 0, (N+1) * sizeof(int));
	viz[1] = 1;
	viz[N] = 2;
	dfs(1, 1);
	dfs(N, 2);

	set<int> a;
	FOR(i,1,N+1) {
		FOR(j,0,G[i].size()) {
			int k = G[i][j];
			if(C[i][k] == F[i][k] && (
				((viz[i] & 1) && (viz[k] & 2)) ||
				((viz[k] & 1) && (viz[i] & 2))
				))
				a.insert(idx[i][k]);
		}
	}

	printf("%d\n", a.size());

	TRS(i, a, 
		printf("%d\n", i);
	)

	return 0;
}