#include <fstream>
#include <vector>
#include <deque>

using namespace std;

ifstream fin( "critice.in" );
ofstream fout( "critice.out" );

const int NMAX = 1005;
const int INF = 2000000000;

int N, M;
vector <int> Ad[NMAX];

int flow[NMAX][NMAX];
int cap[NMAX][NMAX];

int parent[NMAX];
int index[NMAX][NMAX];

int source[NMAX];
int sink[NMAX];

void Read()
{
  fin >> N >> M;

  int x, y, c;

  for( int i = 1; i <= M; ++i )
  {
    fin >> x >> y >> c;

    Ad[x].push_back( y );
    Ad[y].push_back( x );

    cap[x][y] = c;
    cap[y][x] = c;

    index[x][y] = index[y][x] = i;
  }

  fin.close();
}

bool Bfs()
{
   deque <int> Q;
   bool vis[NMAX] = {0};

   int u, w;

   Q.push_back( 1 );
   vis[1] = true;

   while( !Q.empty() )
   {
     u = Q.front();
     Q.pop_front();

     for( int i = 0; i < Ad[u].size(); ++i )
     {
       w = Ad[u][i];

       if( !vis[w] && cap[u][w] > flow[u][w] )
       {
         vis[w] = true;
         parent[w] = u;

         if( w == N ) return true;

         Q.push_back( w );
       }
     }
   }

  return false;
}

void Dfs1( int nod )
{
  int w;

  source[nod] = true;

  for( int i = 0; i < Ad[nod].size(); ++i )
  {
    w = Ad[nod][i];

    if( !source[w] && cap[nod][w] > flow[nod][w] )
      Dfs1( w );
  }
}

void Dfs2( int nod )
{
  int w;

  sink[nod] = true;

  for( int i = 0; i < Ad[nod].size(); ++i )
  {
    w = Ad[nod][i];

    if( !sink[w] && cap[nod][w] > flow[nod][w] )
      Dfs2( w );
  }
}

void Do()
{
  int curent_flow;

  while( Bfs() )
  {
    for( int nod = N; nod != 1; nod = parent[nod] )
      curent_flow = min( curent_flow, cap[ parent[nod] ][nod] - flow[ parent[nod] ][nod] );

    for( int nod = N; nod != 1; nod = parent[nod] )
    {
      flow[ parent[nod] ][nod] += curent_flow;
      flow[nod][ parent[nod] ] -= curent_flow;
    }
  }

  vector <int> Critice;

  /*


  for( int i = 1; i <= N; ++i )
  {
    for( int j = 1; j <= N; ++j )
      fout << flow[i][j] << ' ';

    fout << '\n';
  } */

  Dfs1( 1 );
  Dfs2( N );

  for( int i = 1; i <= N; ++i )
    for( int j = 1; j <= N; ++j )
     if( flow[i][j] == cap[i][j] && cap[i][j] > 0 )
       if( ( source[i] && sink[j] ) || ( sink[i] && source[j] ) )
        Critice.push_back( index[i][j] );

  fout << Critice.size() << '\n';

  for( int i = 0; i < Critice.size(); ++i )
    fout << Critice[i] << '\n';
}

int main()
{
    Read();
    Do();

    return 0;
}