# include <stdio.h>
# include <vector>

using namespace std;

# define uc unsigned char
# define FIN "critice.in"
# define FOUT "critice.out"
# define MAXN 1005
# define MAXM 10005
# define min(a,b) (a < b ? a : b)

int N,M;
vector <int> list[MAXN];
int cap[MAXN][MAXN];
int flux[MAXN][MAXN];
uc s[MAXM];
uc ss[MAXN];
uc sf[MAXN];
int q[MAXN];
int ord[MAXN][MAXN];
int pred[MAXN];

    int bf()
    {
        int i,j;
        for (i = 1; i <= N; ++i)
          s[i] = 0;
        
        int l=1,len,a;
        q[0] = 1;
        
        for (i = 0; i < l; ++i)
          {
              len =  list[q[i]].size();
              for (j = 0; j < len; ++j)
                if (s[list[q[i]][j]] == 0)
                  {
                     a = list[q[i]][j];
                     if (cap[q[i]][a]>flux[q[i]][a])
                       {
                           pred[a] = q[i];
                           q[l++] = a;
                           s[a] = 1;
                       }
                     if (s[N] == 1) return 1;
                  }
          }
        return 0;
    }
    
    void flow()
    {
         int i,aux,a;
         
         while (bf()==1)
           {
               aux = N;
               a = 10000;
               for (i = aux; i != 1; i = pred[i])
                 a = min(a,cap[pred[i]][i]-flux[pred[i]][i]);
               
               aux = N;
               for (i = aux; i != 1; i = pred[i])
                 flux[pred[i]][i]+=a;
           }
    }
    
    void bfs()
    {
         int i,l,j,len,aux;
         
         l = 1;
         q[0] =1;
         ss[1] = 1;
         for (i = 0; i < l; ++i) 
           {
                len = list[q[i]].size();
                for (j = 0; j < len; ++j)
                  if (ss[list[q[i]][j]]==0)
                    {
                        aux = list[q[i]][j]; 
                        if (cap[q[i]][aux]>flux[q[i]][aux])
                          {
                              q[l++] = aux;
                              ss[aux] = 1;
                          }
                    }
           }
    }
    
    void bff()
    {
         int i,l,j,len,aux;
         
         l = 1;
         q[0] = N;
         sf[N] = 1;
         for (i = 0; i < l; ++i) 
           {
                len = list[q[i]].size();
                for (j = 0; j < len; ++j)
                  if (sf[list[q[i]][j]]==0)
                    {
                        aux = list[q[i]][j]; 
                        if (cap[aux][q[i]]>flux[aux][q[i]])
                          {
                              q[l++] = aux;
                              sf[aux] = 1;
                          }
                    }
           }
    }
    
    void solve()
    {
         bfs();
         bff();
         
         int i,j,ct=0;
         
         for (i = 1; i <= M ; ++i)
           s[i] = 0;
         
         for (i = 1; i <= N; ++i)
           for (j = 1; j <= N; ++j)
             if (ord[i][j]!=0)
               if (cap[i][j]==flux[i][j]||cap[j][i]==flux[j][i])
                 if ((ss[i]==1&&sf[j]==1)||(ss[j]==1&&sf[i]==1))
                   {
                       ct++;
                       s[ord[i][j]]=1;
                   } 
         printf("%d\n",ct);
         for (i = 1; i <= M; ++i)
           if (s[i] == 1) printf("%d\n",i);
    }

    int main()
    {
        freopen(FIN,"r",stdin);
        freopen(FOUT,"w",stdout);
        
        scanf("%d%d",&N,&M);
        int i,a,b,c;
        for (i = 1; i <= M; ++i)
          {
              scanf("%d%d%d",&a,&b,&c);
              list[a].push_back(b);
              list[b].push_back(a);
              cap[a][b] = cap[b][a] = c;
              ord[a][b] = i;
          }
        
        flow();
        solve();
        
        return 0;
    }