#include<fstream>
#include<vector>
#include<queue>
#include<vector>
#include<string.h>
#define NMax 10000
#define VMax 1001
#define INF 0x3f3f3f3f
using namespace std;

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

int N,K;
int viz[VMax],viz1[VMax];
int C[VMax][VMax],F[VMax][VMax];
int T[VMax];
 queue<int> q;
int s=1,d;
vector<int> G[VMax];

struct ghid { int x,y,fol; } a[NMax];


int bfs()
{

        memset( viz, 0, sizeof(viz) );
        memset( T, 0, sizeof(T) );
        viz[s] = 1;
        q.push(s);
        while( !q.empty() )
        {
                int nod = q.front();

                for(int i=0; i<G[nod].size(); i++)
                {
                        int x = G[nod][i];
                        if(viz[x]==0&& F[nod][x] < C[nod][x]) {
                               q.push(x);
                               viz[x] = 1;
                               T[x] = nod;
                        }
                }
          q.pop();
        }
        return viz[d];
}

void bfsN()
{

        memset( viz1, 0, sizeof(viz1) );

        viz1[N] = 1;
        q.push(N);
        while( !q.empty() )
        {
                int nod = q.front();

                for(int i=0; i<G[nod].size(); i++)
                {
                        int x = G[nod][i];
                        if(viz1[x]==0&& F[x][nod] < C[x][nod]) {
                               q.push(x);
                               viz1[x] = 1;
                        }
                }
          q.pop();
        }

}






void flux()
{
        while( bfs() )
        {
                for(int i=0; i<G[d].size(); i++)
                {
                        int nod = G[d][i];
                        if( !(viz[nod]!=0 && F[nod][d]<C[nod][d]))
                            continue;
                        int r=C[nod][d]-F[nod][d];
                        if(r==0)
                            continue;

                        for( int v=nod; T[v]!=0; v = T[v] )
                                r = min( r, C[ T[v] ][v] - F[ T[v] ][v] );
                        F[ nod ][d] += r;
                        F[d][ nod ] -=r;

                        for( int v =nod; T[v]!=0; v = T[v] )
                        {
                                F[ T[v] ][v] += r;
                                F[v][ T[v] ] -=r;
                        }
                }
        }
}

int main()
{int c;
        f>>N>>K;;
        int x,y;
        for(int i=1; i<=K; i++)
        {
                f>>x>>y>>c;

                G[x].push_back(y); G[y].push_back(x);
                C[x][y]=c;C[y][x]=c;
                a[i].x=x;a[i].y=y;
        }
d=N;
        flux();
      bfsN();

 int nr=0;

                for(int p=1; p<=K; p++)
                        if( viz[a[p].x]&&viz1[a[p].y]||viz[a[p].y]&&viz1[a[p].x]   ) {
                                            a[p].fol=1; nr++;

                                          }
        g<<nr<<"\n";
        for(int i=1; i<=K; i++)
                if( a[i].fol ) g<<i<<"\n";

        return 0;
}