#include <stdio.h>
#include <string.h>
#include <algorithm>

enum { maxn = 1024, maxe = 10001, inf = 0x3F3F3F3F };

int n;
int d[maxn][maxn];
int e;
int ee[maxe][2];
int theflow;
int ans[maxe], w;
bool source[maxn], sink[maxn]; //reachability in residual graph

int f[maxn];
int parent[maxn];
int q[maxn], qs, qe;

void bfs()
{
	int i;

	qs = 0;
	qe = 1;
	q[0] = 0; //source
	f[0] = inf;
	memset(parent, 0xFF, sizeof(parent)); //-1
	parent[0] = -2; //calc'ed

	while(qs != qe)
	{
		for(i = 0; i < n; i++)
			if(d[ q[qs] ][i] && parent[i] == -1) //not calc'ed
			{
				parent[i] = q[qs];
				f[i] = std::min(f[ q[qs] ], d[ q[qs] ][i]);

				if(i == n - 1) //sink
					return;
				q[qe++] = i;
			}

		qs++;
	}

	//can't reach sink.
}

void maxflow()
{
	int i, add;

	while(true) //increase flow
	{
		bfs();
		if(parent[n - 1] == -1) //didn't reach sink
			return;

		add = f[n - 1];
		theflow += add;

		for(i = n - 1; i; i = parent[i])
		{
			d[i][ parent[i] ] += add;
			d[ parent[i] ][i] -= add;
		}
	}

	//unreachable
}

void df(bool *tab, int node)
{
	tab[node] = true;

	for(int i = 0; i < n; i++)
		if(!tab[i] && d[node][i] && d[i][node]) //both ways, because we remove saturated edges
			df(tab, i);
}

int main()
{
	int i, tmp, a, b;
	FILE *f = fopen("critice.in", "r");
	if(!f) return 1;

	fscanf(f, "%d%d", &n, &e);
	for(i = 0; i < e; i++)
	{
		fscanf(f, "%d%d%d", &a, &b, &tmp);
		a--; b--;
		ee[i][0] = a;
		ee[i][1] = b;

		d[a][b] = tmp;
		d[b][a] = tmp;
	}

	fclose(f);
	f = fopen("critice.out", "w");
	if(!f) return 1;

	maxflow();

	df(source, 0);
	df(sink, n - 1);

	for(i = 0; i < e; i++)
	{
		a = ee[i][0];
		b = ee[i][1];

		if( (d[a][b] == 0 && source[a] && sink[b]) ||
		    (d[b][a] == 0 && source[b] && sink[a]) )
			ans[w++] = i;
	}

	fprintf(f, "%d\n", w);
	for(i = 0; i < w; i++)
		fprintf(f, "%d\n", ans[i] + 1);

	fclose(f);
	return 0;
}