#include <iostream>
#include <fstream>
#include <cstdio>
#include <vector>
#include <bitset>
#include <cmath>
#include <queue>
#include <string>
#include <map>
#include <set>


#define DN 1005
#define pb push_back
#define mp make_pair
#define per pair<int,int>
#define INF (1<<30)
#define un unsigned
#define x first
#define y second
using namespace std;

ifstream f("critice.in");
ofstream g("critice.out");

int C[DN][DN],F[DN][DN],n,m,t[DN],arb[DN];
bool first[DN],last[DN];
vector<int> list[DN],rez;
vector< per > v;
bitset<DN> viz;


void dfa(int nod)
{
    viz[ nod ] = true;
    first[nod] = true;
    for(un int i=0;i<list[nod].size();++i){
        int next_nod = list[nod][i];

        if(!viz[next_nod] && C[nod][next_nod] != F[nod][next_nod] )
            dfa(next_nod);
    }
}

void dfb(int nod)
{
    viz[ nod ] = true;
    last[nod] = true;
    for(un int i=0;i<list[nod].size();++i){
        int next_nod = list[nod][i];

        if(!viz[next_nod] && C[nod][next_nod] != F[nod][next_nod] )
            dfb(next_nod);
    }
}


bool bf() /// construim arborele bfs
{
    viz&=0;
    arb[0]=1;
    arb[1]=1;

    viz[1]=1;
    for(int i=1;i<=arb[0];++i)
    {
        int nod = arb[i];
        for(un int j=0;j<list[nod].size();++j){

            int next_nod = list[nod][j];
            if( C[nod][next_nod] == F[nod][next_nod] || viz[next_nod] ) continue;
            viz[next_nod] = true;
            arb[ ++arb[0] ] = next_nod;
            t[next_nod] = nod;
        }
    }
    return viz[n];
}



void solve()
{
    bool exista_flux = true;
    for( ; exista_flux ; )
    {
        exista_flux = bf();
        for(un int i=0;i<list[n].size();++i)
        {
            int nod = list[n][i] , fmin = INF;
            if( C[ nod ][ n ] == F[ nod ][ n ] || !viz[nod] ) continue;
            t[ n ] = nod;

            for( nod = n ; nod!=1 ; nod=t[nod])
                fmin = min(fmin, C[ t[nod] ][ nod ] - F[ t[nod] ][ nod ] );

            if(fmin == 0) continue;

            for( nod = n ; nod!=1 ; nod=t[nod]){

                F[ t[nod] ][ nod ] +=fmin;
                F[ nod ][ t[nod] ]-=fmin;
            }
        }
    }

    viz&=0;
    dfa(1);

    viz&=0;
    dfb(n);
    for(un int i=0;i<v.size();++i)
    {
        int a = v[i].x;
        int b = v[i].y;
        if( ( first[a]&last[b] ) || ( first[b]&last[a] ) )
                rez.pb(i+1);
    }
}

void write()
{
    g<<rez.size()<<"\n";
    for(un int i=0;i<rez.size();++i)
        g<<rez[i]<<"\n";
}

void read()
{
    f>>n>>m;
    for(int i=1;i<=m;++i)
    {
        int a,b,c;
        f>>a>>b>>c;
        v.pb(mp(a,b));

        C[a][b]+=c;
        C[b][a]+=c;
        list[a].pb(b);
        list[b].pb(a);
    }
}

int main()
{
    read();
    solve();
    write();

    return 0;
}