#include <cstdio>
#include <iostream>
#include <cstring>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;


#define maxN 1005
#define INF 0x3f3f3f
#define PB push_back


struct muchii
{
	int x , y;
}
muchie[maxN];


int N , M , cap[maxN][maxN] , flux[maxN][maxN];
int fluxmax , tata[maxN];
bool viz[maxN] , viz1[maxN] , vizN[maxN];


vector <int> lista[maxN];
queue <int> Q;

int dim = 0 , sol[maxN];

int am_flux ()
{
	Q.push (1);

	memset (viz , 0 , sizeof (viz));
	
	viz[1] = true;
	
	
	while (!Q.empty ())
	{
		int nod = Q.front ();
		Q.pop ();
		
		if (nod == N)
			continue;
		
		for (unsigned int i = 0 ; i < lista[nod].size () ; ++i)
		{
			int nodcur = lista[nod][i];
			
			
			if (cap[nod][nodcur] - flux[nod][nodcur] == 0 || cap[nodcur][nod] - flux[nodcur][nod] == 0)
				continue;
			
			
			if (viz[nodcur])
				continue;
			
			tata[nodcur] = nod;
			viz[nodcur] = true;
			
			Q.push (nodcur);
		}
	}
	
	
	if (!viz[N])
		return 0;
	
	
	for (unsigned int i = 0 ; i < lista[N].size () ; ++i)
	{
	
		int nod = lista[N][i] , minim = INF;
		
		
		if (cap[nod][N] - flux[nod][N] == 0)
			continue;
		
		if (!viz[nod])
			continue;
		
		
		
		tata[N] = nod;
		
		
		for (nod = N ; nod != 1 ; nod = tata[nod])
			minim = min (minim , cap[tata[nod]][nod] - flux[tata[nod]][nod]);
			
		if (minim == 0)
			continue;
		
		
		for (nod = N ; nod != 1 ; nod = tata[nod])
		{
			flux[tata[nod]][nod] += minim;
			flux[nod][tata[nod]] -= minim;
		}
		
	}
	
	return 1;
}




void bfs1 ()
{
	Q.push (1);
	
	memset (viz1 , 0 , sizeof (viz1));
	
	viz1[1] = true;
	
	
	while (!Q.empty ())
	{
		int nod = Q.front ();
		Q.pop ();
		
		
		for (unsigned int i = 0 ; i < lista[nod].size () ; ++i)
		{
			int nodcur = lista[nod][i];
			
			if (viz1[nodcur])
				continue;
			
			if (cap[nod][nodcur] <= flux[nod][nodcur])
				continue;
			
			Q.push (nodcur);
			viz1[nodcur] = true;
		}
	}
}


void bfsN ()
{
	Q.push (N);
	
	memset (vizN , 0 , sizeof (vizN));
	
	vizN[N] = true;
	
	
	while (!Q.empty ())
	{
		int nod = Q.front ();
		Q.pop ();
		
		
		for (unsigned int i = 0 ; i < lista[nod].size () ; ++i)
		{
			int nodcur = lista[nod][i];
			
			
			if (vizN[nodcur])
				continue;
			
			if (cap[nodcur][nod] <= flux[nodcur][nod])
				continue;
			
			Q.push (nodcur);
			vizN[nodcur] = true;
		}
	}
	
}



int main ()
{
	freopen ("critice.in" , "r" , stdin);
	freopen ("critice.out" , "w" , stdout);
	
	scanf ("%d %d" , &N , &M);
	
	
	int a , b , c;
	
	for (int i = 1 ; i <= M ; ++i)
	{
		scanf ("%d %d %d" , &a , &b , &c);
		
		lista[a].PB (b);
		lista[b].PB (a);
		
		cap[a][b] = c;
		cap[b][a] = c;
		
		
		muchie[i].x = a;
		muchie[i].y = b;
	}
	
	
	while (am_flux ());
	
	
	bfs1 ();
	bfsN ();
	
	for (int i = 1 ; i <= M ; ++i)
	{
		int xx = muchie[i].x;
		int yy = muchie[i].y;
		
		if (cap[xx][yy] == flux[xx][yy] || -cap[xx][yy] == flux[xx][yy])
			if ((viz1[xx] && vizN[yy]) || (viz1[yy] && vizN[xx]))
				sol[++dim] = i;
	}
	
	
	printf ("%d\n" , dim);
	
	sort (sol + 1 , sol + dim + 1);
	
	for (int i = 1 ; i <= dim ; ++i)
		printf ("%d\n" , sol[i]);
	
	
	return 0;
}