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

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

struct ls
{
	int n;
	ls *next;
} *lst[maxn];

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

void add(int from, int to)
{
	ls *p = new ls;
	p->n = to;
	p->next = lst[from];
	lst[from] = p;
}

void maxflow()
{
	ls *p;
	int i, maxi, maxf, toadd;
	bool v[maxn];
	int f[maxn];
	int prev[maxn];

	while(true) //increase flow
	{
		memset(v, 0, sizeof(v));
		memset(f, 0, sizeof(f));
		f[0] = inf;

		while(true) //find augmenting path
		{
			//find best node to start with
			maxi = -1;
			maxf = 0;
			for(i = 0; i < n; i++)
				if(!v[i] && f[i] > maxf)
				{
					maxi = i;
					maxf = f[i];
				}

			if(maxi == -1) //Mordor
				return;
			if(maxi == n - 1) //path done
				break;
			assert(maxf != 0);

			//update neighbors
			v[maxi] = true;
			for(p = lst[maxi]; p; p = p->next)
				if(!v[p->n] && d[maxi][p->n])
				{
					toadd = std::min(maxf, d[maxi][p->n] - f[p->n]);

					if(f[p->n] < toadd)
					{
						assert(toadd >= 0);
						f[p->n] = toadd;
						prev[p->n] = maxi;
					}
				}
		}

		//update graph (walk back)
		for(i = n - 1; i != 0; i = prev[i])
		{
			d[ prev[i] ][i] -= maxf;
			d[i][ prev[i] ] += maxf;

			assert(d[ prev[i] ][i] >= 0);

		}

		theflow += maxf;
	}

	//unreachable
}

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

	for(ls *p = lst[node]; p; p = p->next)
		if(!tab[p->n] && d[node][p->n] && d[p->n][node]) //both ways, because we remove saturated edges
			df(tab, p->n);
}

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;

		add(a, b);
		add(b, a);
	}

	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;
}