#include <cstdio>
#include <vector>

using namespace std;

#define PB push_back

const int NMAX = 1024;
const int MMAX = 10240;
const int INF = 0x3f3f3f3f;

int N, M, A[MMAX], B[MMAX], T[NMAX];
int C[NMAX][NMAX], F[NMAX][NMAX], W[NMAX][NMAX];
vector <int> G[NMAX];

void read(void) {
	FILE *fin = fopen("critice.in", "rt");
	int i, u, v, c;

	fscanf(fin, " %d %d", &N, &M);

	for (i = 1; i <= M; ++i) {
		fscanf(fin, " %d %d %d", &u, &v, &c);
		G[u].PB(v); G[v].PB(u);
		C[u][v] = C[v][u] = c;
		A[i] = u; B[i] = v;
	}

	fclose(fin);
}

bool BFS(int S, int D, int mark) {
	int Q[NMAX], NQ, i, u;
	vector <int> :: iterator k;

	memset(T, 0xff, sizeof(T));
	T[S] = 0; Q[NQ = 0] = S;
	for (i = 0; i <= NQ; ++i)
		for (k = G[u = Q[i]].begin(); k != G[u].end(); ++k) {
			if (mark && C[u][*k] == max(F[u][*k], F[*k][u])) {
				W[u][*k] |= mark;
				W[*k][u] |= mark;
				continue;
			}
			if (T[*k] != -1 || C[u][*k] == F[u][*k]) continue;
			T[*k] = u;
			Q[++NQ] = *k;
			if (*k == D) return true;
		}

	return false;
}

// Asa zisul dinic, care nu e chiar dinic
// E mai degraba un Edmond-Karp, optimizat
// Daca vrei sa crape, pui un nod D' si o 
// muchie de capacitate INF intre D si D'

void dinic(void) {
	int i, u, v, flux;

	while ( BFS(1, N, 0) ) 
		for (i = 1; i < N; ++i) {
			if (F[i][N] == C[i][N] || T[i] == -1) continue;

			flux = C[i][N] - F[i][N];
			for (u = T[v = i]; u; u = T[v = u])
				flux = min(flux, C[u][v] - F[u][v]);

			F[i][N] += flux; F[N][i] -= flux;
			for (u = T[v = i]; u; u = T[v = u])
				F[u][v] += flux,
				F[v][u] -= flux;
		}
}

void write(void) {
	FILE *fout = fopen("critice.out", "wt");
	int i, cnt;

	for (cnt = 0, i = 1; i <= M; ++i)
		if (W[ A[i] ][ B[i] ] == 3)
			++cnt;
	
	fprintf(fout, "%d\n", cnt);
	for (i = 1; i <= M; ++i)
		if (W[ A[i] ][ B[i] ] == 3)
			fprintf(fout, "%d\n", i);

	fclose(fout);
}

int main(void) {

	read();

	dinic();

	BFS(1, N, 1);
	BFS(N, 1, 2);

	write();

	return 0;
}