#include <stdio.h>
#include <fstream>
using namespace std;

#define in "critice.in"
#define out "critice.out"
#define dim 1001

int N, M;
int Q[dim], T[dim], R[dim*10], H[2][dim];
int Cap[dim][dim], Flux[dim][dim];
bool Sel[dim], S1[dim], S2[dim], S[dim][dim];

int BF();
void Augment();
void DF(int);

inline int Minim(int a, int b) {
       if ( a < b ) return a;
       return b;
}

int main()
{
    int X, Y, C, K = 0;
    freopen(in,"r",stdin);
    freopen(out,"w",stdout);
    
    scanf("%d%d", &N, &M);
    for ( int i = 1; i <= M; i++ )
    {
        scanf("%d%d%d", &X, &Y, &C);
        Cap[X][Y] = Cap[Y][X] = C;
        H[0][i] = X, H[1][i] = Y;
    }
    
    for ( int i = 1; i <= N; i++ ) T[i] = -1, S1[i] = 0;
    
    while ( BF() ) Augment();
    
    DF(1);
    
    for ( int i = 1; i <= N; i++ ) 
        S2[i] = S1[i], S1[i] = 0;
    
    DF(N);
    
    for ( int i = 1; i <= M; i++ )
    {
        int nod1 = H[0][i], nod2 = H[1][i];
        
        if ( Cap[nod1][nod2] == Flux[nod1][nod2] )
        {
           if ( (S1[nod1]&S2[nod2]) || (S2[nod1]&S1[nod2]) ) K++, R[K] = i;
        }
        else
        {
            swap(nod1,nod2);
            if ( Cap[nod2][nod1] == Flux[nod1][nod2] )
               if ( (S1[nod1]&S2[nod2]) || (S2[nod1]&S1[nod2]) ) K++, R[K] = i;
        }
           
    }
    
    printf("%d\n", K);
    for ( int i = 1; i <= K; i++ )
        printf("%d\n", R[i]);
}

void DF(int nod)
{
     S1[nod] = 1;
     
     for ( int i = 1; i <= N; i++ )
         if ( !S1[i] && Cap[nod][i] > 0 && Flux[nod][i] != Cap[nod][i] && Flux[i][nod] != Cap[nod][i] ) DF(i);
}

int BF()
{
    memset(Sel,0,sizeof(Sel));
    int act, last;
    
    Q[act=last=1] = Sel[1] = 1;
    
    while ( act <= last )
    {
          int nod = Q[act];
          for ( int i = 1; i <= N; i++ )
              if ( Cap[nod][i] - Flux[nod][i] > 0 && !Sel[i] )
              {
                   last++;
                   Q[last] = i, Sel[i] = 1, T[i] = nod;
                   if ( i == N ) return 1;
              }
          
          act++;
    }
    
    return 0;
}

void Augment()
{
     int minim;
     
     for ( int i = 1; i <= N; i++ )
     {
         if ( T[i] == -1 || Cap[i][N] <= Flux[i][N] ) continue;
         
         minim = Cap[i][N]-Flux[i][N];
         for ( int j = i; j != 1 && j; j = T[j] )
             minim = Minim( minim, Cap[T[j]][j] - Flux[T[j]][j] );
         
         if ( !minim ) continue;
         
         Flux[i][N] += minim, Flux[N][i] -= minim;
         for ( int j = i; j != 1 && j; j = T[j] )
             Flux[T[j]][j] += minim, Flux[j][T[j]] -= minim;
          
     }
}