#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <cstring>
#define NMAX 1001

using namespace std;

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

vector<int> graf[NMAX];
int cap[NMAX][NMAX], flux[NMAX][NMAX], t[NMAX];
vector<pair<int,int> > muchie;
vector<int> rez;
int n, m;
bool viz[NMAX], viz2[NMAX];

void citire()
{
    int i, x, y, c ;
    fin >> n >> m ;
    muchie.push_back(make_pair(0,0)) ;
    for ( i = 1 ; i <= m ; i++ ) {
        fin >> x >> y >> c ;
        muchie.push_back(make_pair(x,y)) ;
        graf[x].push_back(y) ;
        graf[y].push_back(x) ;
        cap[x][y] = c ;
        cap[y][x] = c ;
    }
}

int BFS()
{
    int i, nod ;
    queue<int> Q ;
    memset(viz,false,n+1) ;
    Q.push(1) ;
    viz[1] = true ;
    while(!Q.empty()) {
        nod = Q.front() ;
        Q.pop() ;
        if ( n == nod )
            continue ;
        for ( i = 0 ; i < graf[nod].size() ; i++ ) {
            if ( viz[graf[nod][i]]|| cap[nod][graf[nod][i]]==flux[nod][graf[nod][i]] )
                continue ;
            viz[graf[nod][i]] = true ;
            Q.push(graf[nod][i]) ;
            t[graf[nod][i]] = nod ;
        }
    }
    return viz[n] ;
}

void DFSF(int nod)
{
    int i ;
    viz[nod] = true ;
    for ( i = 0 ; i < graf[nod].size() ; i++ )
        if ( viz[graf[nod][i]] == false && flux[nod][graf[nod][i]] != cap[nod][graf[nod][i]] )
            DFSF(graf[nod][i]) ;
}

void DFSS(int nod)
{
    int i ;
    viz2[nod] = true ;
    for ( i = 0 ; i < graf[nod].size() ; i++ )
        if ( viz2[graf[nod][i]] == false && flux[nod][graf[nod][i]] != cap[nod][graf[nod][i]] )
            DFSS(graf[nod][i]) ;
}

int main()
{
    int fmin, i, flx = 0, j, a, b;

    citire() ;

    while(BFS()) {
        for ( j = 0 ; j < graf[n].size() ; j++ ) {
            if ( cap[graf[n][j]][n]==flux[graf[n][j]][n]||!viz[graf[n][j]])
                continue ;

            t[n] = graf[n][j] ;
            fmin = 0x3f3f3f3f ;
            for ( i = n ; i > 1 ; i = t[i] )
                fmin = min(fmin,cap[t[i]][i]-flux[t[i]][i]) ;

            if ( fmin == 0 )
                continue ;

            for ( i = n ; i > 1 ; i = t[i] ) {
                flux[t[i]][i] = flux[t[i]][i] + fmin ;
                flux[i][t[i]] = flux[i][t[i]] - fmin ;
            }

            flx = flx+fmin ;
        }
    }

    memset(viz,false,n+1) ;
    memset(viz2,false,n+1) ;
    DFSF(1) ;
    DFSS(n) ;

    for ( i = 1 ; i <= m ; i++ ) {
        a = muchie[i].first ;
        b = muchie[i].second ;
        if ( abs(flux[a][b]) == cap[a][b] && (( viz[a] && viz2[b] )^( viz2[a] && viz[b])) )
            rez.push_back(i) ;
    }

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