#include <bits/stdc++.h>
#define vecin v [ nod ][ i ]
using namespace std ;
const int NR = 1005 ;
const int oo = 110005 ;
ifstream in ("critice.in") ;
ofstream out ("critice.out") ;

vector < int > v [ NR ] , ans ;
vector < pair < int , int > > edge ;
int n , m , x , y , c , d [ NR ][ NR ] , TT [ NR ] , pos , flow , sol ;
bool viz [ NR ] , st [ NR ] , dr [ NR ] ;

bool bfs () {

    int i , nod ;
    queue < int > q ;

    for ( i = 1 ; i <= n ; ++ i )   TT [ i ] = 0 , viz [ i ] = 0 ;
    q.push( 1 ) ;
    viz [ 1 ] = 1 ;
    while ( !q.empty() && !viz [ n ] )    {

        nod = q.front() ;
        q.pop() ;
        viz [ nod ] = 1 ;
        for ( size_t i = 0 ; i < v [ nod ].size() ; i ++ )  {

            if ( !viz [ vecin ] && d [ nod ][ vecin ] > 0 ) {

                TT [ vecin ] = nod ;
                viz [ vecin ] = 1 ;
                q.push( vecin ) ;
            }
        }
    }
    return viz [ n ] ;
}

void bfs1 (  )
{
    int i , nod ;
    queue < int > q ;

    for ( i = 1 ; i <= n ; ++ i ) viz [ i ] = 0 ;
    q.push( 1 ) ;
    viz [ 1 ] = 1 ;
    while ( !q.empty() )    {
        nod = q.front() ;
        st [ nod ] = 1 ;
        q.pop() ;
        viz [ nod ] = 1 ;
        for ( size_t i = 0 ; i < v [ nod ].size() ; i ++ )  {

            if ( !viz [ vecin ] && d [ nod ][ vecin ] > 0 ) {

                viz [ vecin ] = 1 ;
                q.push( vecin ) ;
            }
        }
    }
}

void bfs2 (  )
{
    int i , nod ;
    queue < int > q ;

    for ( i = 1 ; i <= n ; ++ i ) viz [ i ] = 0 ;
    q.push( n ) ;
    viz [ n ] = 1 ;
    while ( !q.empty() )    {
        nod = q.front() ;
        dr [ nod ] = 1 ;
        q.pop() ;
        viz [ nod ] = 1 ;
        for ( size_t i = 0 ; i < v [ nod ].size() ; i ++ )  {

            if ( !viz [ vecin ] && d [ nod ][ vecin ] > 0 ) {
                viz [ vecin ] = 1 ;
                q.push( vecin ) ;
            }
        }
    }
}

int main () {
     in >> n >> m ;
     for ( int i = 1 ; i <= m ; ++ i ) {

        in >> x >> y >> c ;
        edge.push_back( { x , y } ) ;
        v [ x ].push_back( y ) ;
        v [ y ].push_back( x ) ;
        d [ x ][ y ] = c ;
        d [ y ][ x ] = c ;
     }
     while ( bfs () )   {
        for ( size_t i = 0 ; i < v [ n ].size() ; i ++ )     {

            if ( viz [ v [ n ][ i ] ] && d [ v [ n ][ i ] ][ n ] > 0 )    {

                pos = n ;
                flow = oo ;
                TT [ n ] = v [ n ][ i ] ;
                while ( TT [ pos ] )    {
                    flow = min ( flow , d [ TT [ pos ] ][ pos ] ) ;
                    pos = TT [ pos ] ;
                }
                sol += flow ;
                pos = n ;
                   while ( TT [ pos ] )    {
                    d [ TT[ pos ] ][ pos ] -= flow ;
                    d [ pos ][ TT[ pos ] ] += flow ;
                    pos = TT [ pos ] ;
                }
            }
        }
     }
    bfs1() ;
    bfs2() ;
     for ( int i = 0 ; i < m ; ++ i ) {

        if ( ( st [ edge [ i ].first ] && dr [ edge [ i ].second ] ) || ( st [ edge [ i ].second ] && dr [ edge [ i ].first ] ) )
            ans.push_back( i + 1 ) ;
     }

    out << ans.size() << '\n' ;
    for ( size_t i = 0 ; i < ans.size() ; i ++ ) out << ans [ i ] << '\n' ;

}