/**
 * Code by Patrick Sava
 * "Spiru Haret" National College of Bucharest
 **/

# include "fstream"
# include "cstring"
# include "vector"
# include "queue"
# include "bitset"
# include "algorithm"
# include "map"
# include "unordered_map"
# include "deque"
# include "string"
# include "iomanip"
# include "cmath"
# include "stack"
# include "cassert"

const char IN [ ] =  "critice.in" ;
const char OUT [ ] = "critice.out" ;
const int MAX = 1014 ;

# define pb push_back
# define mp make_pair
# define FORN( a , b , c ) for ( int a = b ; a <= c ; ++ a )
# define FORNBACK( a , b , c ) for ( int a = b ; a >= c ; -- a )

using namespace std ;

ifstream cin ( IN ) ;
ofstream cout ( OUT ) ;

vector < int > gr [ MAX ] ;
int cap [ MAX ] [ MAX ] , n ;
int flow [ MAX ] [ MAX ] , tata [ MAX ] ;
vector < int > sol ;

queue < int > Q ;

bitset < MAX > viz ;

inline int bfs ( )
{
    viz.reset ( ) ;
    viz [ 1 ] = 1 ;
    Q.push ( 1 ) ;

    while ( !Q.empty() )
    {
        int nod = Q.front ( ) ;

        Q.pop ( ) ;

        if ( nod == n ) continue ;

        for ( auto x : gr [ nod ] )
        {
            if ( cap [ nod ] [ x ] == flow [ nod ] [ x ] ) continue ;
            if ( viz [ x ] ) continue ;

            tata [ x ] = nod ;
            viz [ x ] = 1 ;
            Q.push ( x ) ;
        }
    }

    return viz [ n ] ;
}

int good [ MAX ] ;

inline void dfs ( int nod , int val )
{
    good [ nod ] = val ;
    for ( auto x : gr [ nod ] )
        if ( !good [ x ] and flow [ nod ] [ x ] < cap [ nod ] [ x ] )
            dfs ( x , val ) ;
}

pair < int , int > E [ MAX ] ;

int main()
{
    int m ;
    cin >> n >> m ;
    FORN ( i , 1 , m )
    {
        int x , y , z ;
        cin >> x >> y >> z ;
        E [ i ] = mp ( x , y ) ;
        gr [ x ].pb ( y ) ;
        gr [ y ].pb ( x ) ;
        cap [ x ] [ y ] = z ;
        cap [ y ] [ x ] = z ;
    }

    int flux = 0 ;
    for ( ; bfs ( ) ; )
    {
        for ( auto x : gr [ n ] )
        {
            if ( viz [ x ] == 0 ) continue ;

            int minim = 1 << 30 ;

            tata [ n ] = x ;

            for ( int i = n ; tata [ i ] ; i = tata [ i ] )
            {
                minim = min ( minim , cap [ tata [ i ] ] [ i ] - flow [ tata [ i ] ] [ i ] ) ;
            }

            if ( minim == 0 ) continue ;

            for ( int i = n ; tata [ i ] ; i = tata [ i ] )
            {
                flow [ tata [ i ] ] [ i ] += minim ;
                flow [ i ] [ tata [ i ] ] -= minim ;
            }

            flux += minim ;
        }
    }
    //cout << flux << '\n' ;
    dfs ( 1 , 1 ) ;
    dfs ( n , 2 ) ;

    FORN ( i , 1 , m )
        if ( abs ( flow [ E [ i ].first ] [ E [ i ].second ] ) == cap [ E [ i ].first ] [ E [ i ].second ] and good [ E [ i ].first ] + good [ E [ i ].second ] == 3 )
            sol.pb ( i ) ;

    cout << ( int ) sol.size ( ) << '\n' ;

    for ( auto x : sol )
        cout << x << '\n' ;
    return 0;
}