#include<fstream>
#include<cstring>
#include<vector>
#include<queue>
using namespace std ;

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

#define maxn 1005
#define maxm 10005
#define inf ( 1 << 30 )

struct muchie
{
    int a, b ;
};

int N, M ;
muchie muchii[maxm] ;
vector <int> graf[maxn] ;

int cap[maxn][maxn], flux[maxn][maxn] ;
int tata[maxn] ;

bool sel[maxn], viz[maxn][2] ;
queue<int> coada ;

int sol[maxm] ;

bool bfs()
{
    memset( sel, false, sizeof(sel) ) ;
    coada.push(1) ;
    sel[1] = true ;

    while( coada.empty() == false )
    {
        int nod = coada.front() ;
        coada.pop() ;

        for(size_t i = 0; i < graf[nod].size(); ++i )
        {
            int vecin = graf[nod][i] ;

            if( cap[nod][vecin] == flux[nod][vecin] || sel[vecin] )
                continue ;

            sel[vecin] = true ;
            tata[vecin] = nod ;

            if( vecin != N )
                coada.push(vecin) ;
        }
    }

    return sel[N] ;
}

void dfs_sursa(int nod)
{
    viz[nod][0] = true ;

    for(size_t i = 0; i < graf[nod].size(); ++i )
    {
        int vecin = graf[nod][i] ;
        if( viz[vecin][0] == false && flux[nod][vecin] < cap[nod][vecin] )
            dfs_sursa( vecin ) ;
    }
}

void dfs_destinatie(int nod)
{
    viz[nod][1] = true ;

    for(size_t i = 0; i < graf[nod].size(); ++i )
    {
        int vecin = graf[nod][i] ;
        if( viz[vecin][1] == false && flux[vecin][nod] < cap[vecin][nod] )
            dfs_destinatie( vecin ) ;
    }
}

int main()
{
    fin >> N >> M ;

    for(int i = 1; i <= M; ++i )
    {
        int cost ;
        fin >> muchii[i].a >> muchii[i].b >> cost ;

        cap[ muchii[i].a ][ muchii[i].b ] = cost ;
        cap[ muchii[i].b ][ muchii[i].a ] = cost ;

        graf[ muchii[i].a ].push_back( muchii[i].b ) ;
        graf[ muchii[i].b ].push_back( muchii[i].a ) ;
    }

    while( bfs() )
    {
        for(size_t i = 0; i < graf[N].size(); ++i )
        {
            int nod = graf[N][i] ;

            if( flux[nod][N] == cap[nod][N] || sel[nod] == false )
                continue ;

            tata[N] = nod ;
            int val = inf ;

            nod = N ;
            while( nod != 1 )
            {
                val = min( val, cap[ tata[nod] ][nod] - flux[ tata[nod] ][nod] ) ;
                nod = tata[nod] ;
            }

            nod = N ;
            while( nod != 1 )
            {
                flux[ tata[nod] ][nod] += val ;
                flux[nod][ tata[nod] ] -= val ;
                nod = tata[nod] ;
            }
        }
    }

    dfs_sursa( 1 ) ;
    dfs_destinatie( N ) ;

    int nrsol = 0 ;
    for(int i = 1; i <= M; ++i )
    {
        int nod1 = muchii[i].a ;
        int nod2 = muchii[i].b ;

        if( ( flux[nod1][nod2] == cap[nod1][nod2] && viz[nod1][0] && viz[nod2][1] ) || ( flux[nod2][nod1] == cap[nod2][nod1] && viz[nod2][0] && viz[nod1][1] ) )
            sol[ ++nrsol ] = i ;
    }

    fout << nrsol << "\n" ;

    for(int i = 1; i <= nrsol; ++i )
        fout << sol[i] << "\n" ;

    return 0 ;
}